@massa-ai/mcp-client 1.60.0 → 1.61.0

package/dist/config-cli.js

@@ -997,7 +997,7 @@ function getConfigForEnv() {
   } else {
     console.error(`[getConfigForEnv] embedding.provider "${provider}" has no env-projection branch \u2014 no embedding env vars were set`);
   }
-  env.LOG_LEVEL = config.logging.level;
+  env.MASSA_AI_LOG_LEVEL = config.logging.level;
   env.ENABLE_METRICS = String(config.logging.enableMetrics);
   return env;
 }
@@ -1571,7 +1571,7 @@ var init_config = __esm(() => {
       corsOrigins: envList("MASSA_AI_API_CORS_ORIGINS", fileConfig.security?.corsOrigins ?? [])
     },
     logging: {
-      level: process.env.LOG_LEVEL || fileConfig.logging?.level || "info",
+      level: process.env.MASSA_AI_LOG_LEVEL || fileConfig.logging?.level || "info",
       enableMetrics: process.env.ENABLE_METRICS === "true" || process.env.ENABLE_METRICS === undefined && !!fileConfig.logging?.enableMetrics,
       file: process.env.MASSA_AI_LOG_FILE || fileConfig.logging?.file || path4.join(resolvedDataDir, "logs", "massa-ai.log"),
       enableFileSink: envBool("MASSA_AI_LOG_ENABLE_FILE_SINK", fileConfig.logging?.enableFileSink ?? true),
@@ -1904,6 +1904,32 @@ var init_log_buffer = __esm(() => {
 });
 
 // ../../packages/shared/dist/utils/logger.js
+function formatAgo(ms) {
+  const totalSeconds = Math.floor(ms / 1000);
+  if (totalSeconds < 60)
+    return `${totalSeconds}s`;
+  return `${Math.floor(totalSeconds / 60)}m`;
+}
+function capErrorText(value) {
+  if (value.length <= MAX_ERROR_TEXT_CHARS)
+    return value;
+  const truncatedChars = value.length - MAX_ERROR_TEXT_CHARS;
+  return `${value.slice(0, MAX_ERROR_TEXT_CHARS)}\u2026(truncated ${truncatedChars} chars)`;
+}
+function pickErrorFields(err, includeStack) {
+  const out = { name: err.name, message: capErrorText(err.message) };
+  if (includeStack)
+    out.stack = err.stack;
+  const code = err.code;
+  if (code !== undefined)
+    out.code = code;
+  const cause = err.cause;
+  if (cause !== undefined) {
+    out.cause = capErrorText(cause instanceof Error ? cause.message : String(cause));
+  }
+  return out;
+}
+
 class Logger {
   _level;
   _enableMetrics;
@@ -1912,6 +1938,7 @@ class Logger {
   _maxFileSizeBytes;
   _maxFiles;
   _initialized = false;
+  repeats = new Map;
   constructor() {}
   ensureInitialized() {
     if (!this._initialized) {
@@ -1972,13 +1999,70 @@ class Logger {
   shouldLog(level) {
     return level >= this.level;
   }
+  serializeMetaErrors(meta) {
+    if (!meta)
+      return meta;
+    let out;
+    for (const [key, value] of Object.entries(meta)) {
+      if (value instanceof Error) {
+        if (!out)
+          out = { ...meta };
+        out[key] = pickErrorFields(value, false);
+      }
+    }
+    return out ?? meta;
+  }
+  applyRepeatAccounting(level, message, meta) {
+    if (level !== LogLevel.WARN && level !== LogLevel.ERROR)
+      return meta;
+    const label = typeof meta?.label === "string" ? meta.label : "";
+    const key = `${level}|${message}|${label}`;
+    const now = Date.now();
+    const existing = this.repeats.get(key);
+    if (!existing || now - existing.firstSeenAt > REPEAT_WINDOW_MS) {
+      if (this.repeats.size >= MAX_REPEAT_KEYS)
+        this.repeats.clear();
+      this.repeats.set(key, { firstSeenAt: now, count: 1 });
+      return meta;
+    }
+    existing.count += 1;
+    return {
+      ...meta,
+      occurrences: existing.count,
+      firstSeenAgo: formatAgo(now - existing.firstSeenAt)
+    };
+  }
+  _resetRepeatsForTesting() {
+    this.repeats.clear();
+  }
+  safeStringifyMeta(meta) {
+    const seen = new WeakSet;
+    try {
+      return JSON.stringify(meta, (_key, value) => {
+        if (typeof value === "bigint")
+          return value.toString();
+        if (typeof value === "object" && value !== null) {
+          if (seen.has(value))
+            return "[Circular]";
+          seen.add(value);
+        }
+        return value;
+      });
+    } catch (err) {
+      return JSON.stringify({
+        metaUnserializable: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   formatMessage(level, message, meta, timestamp = new Date().toISOString()) {
-    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    const metaStr = meta ? ` ${this.safeStringifyMeta(meta)}` : "";
     return `[${timestamp}] [${level}] ${message}${metaStr}`;
   }
   emit(level, message, meta) {
+    const serializedMeta = this.serializeMetaErrors(meta);
+    const finalMeta = this.applyRepeatAccounting(level, message, serializedMeta);
     const ts = new Date().toISOString();
-    const line = this.formatMessage(LOG_LEVEL_LABELS[level], message, meta, ts);
+    const line = this.formatMessage(LOG_LEVEL_LABELS[level], message, finalMeta, ts);
     console.error(line);
     if (this.enableFileSink) {
       const filePath = this.logFilePath;
@@ -1990,7 +2074,7 @@ class Logger {
       ts,
       level: LOG_LEVEL_BUFFER_TAGS[level],
       message,
-      ...meta ? { meta } : {}
+      ...finalMeta ? { meta: finalMeta } : {}
     });
   }
   debug(message, meta) {
@@ -2012,11 +2096,7 @@ class Logger {
     if (this.shouldLog(LogLevel.ERROR)) {
       const errorMeta = error ? {
         ...meta,
-        error: {
-          name: error.name,
-          message: error.message,
-          stack: error.stack
-        }
+        error: error instanceof Error ? pickErrorFields(error, true) : { message: String(error) }
       } : meta;
       this.emit(LogLevel.ERROR, message, errorMeta);
     }
@@ -2047,7 +2127,7 @@ class Logger {
     return childLogger;
   }
 }
-var LogLevel, LOG_LEVEL_LABELS, LOG_LEVEL_BUFFER_TAGS, logger;
+var LogLevel, LOG_LEVEL_LABELS, LOG_LEVEL_BUFFER_TAGS, REPEAT_WINDOW_MS, MAX_REPEAT_KEYS = 500, MAX_ERROR_TEXT_CHARS = 300, logger;
 var init_logger = __esm(() => {
   init_config();
   init_log_sink();
@@ -2070,6 +2150,7 @@ var init_logger = __esm(() => {
     [LogLevel.WARN]: "warn",
     [LogLevel.ERROR]: "error"
   };
+  REPEAT_WINDOW_MS = 15 * 60 * 1000;
   logger = new Logger;
 });
 
@@ -2125,8 +2206,9 @@ var init_metrics = __esm(() => {
         }
       } catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
-        logger.warn(`Failed to fetch pricing for ${modelId}`, {
-          error: { name: err.name, message: err.message }
+        logger.warn("MetricsCollector: failed to fetch pricing", {
+          modelId,
+          error: err
         });
       }
       const fallback = FALLBACK_PRICING[modelId];
@@ -2134,7 +2216,7 @@ var init_metrics = __esm(() => {
         logger.debug(`Using fallback pricing for ${modelId}`);
         return fallback;
       }
-      logger.warn(`Unknown model ${modelId}, using gpt-4 pricing as default`);
+      logger.warn("MetricsCollector: unknown model, using gpt-4 pricing as default", { modelId });
       return FALLBACK_PRICING["gpt-4"];
     }
     static calculateCost(inputTokens, outputTokens, model) {
@@ -2313,7 +2395,9 @@ class SmartRateLimiter {
     const hasRequestCapacity = this.requestLimiter.tryConsume(1);
     const hasTokenCapacity = this.tokenLimiter.tryConsume(estimatedTokens);
     if (!hasRequestCapacity) {
-      logger.warn("Request rate limit exceeded");
+      logger.warn("Request rate limit exceeded", {
+        availableTokens: this.requestLimiter.getAvailableTokens()
+      });
       return false;
     }
     if (!hasTokenCapacity) {
@@ -2679,12 +2763,13 @@ function selectRecord(records) {
   }
   return best ?? pool[pool.length - 1];
 }
-function resolveClaudeMarketplaceRoot(opts = {}) {
+function resolveClaudeMarketplaceInstall(opts = {}) {
   const targetHome = opts.targetHome ?? os5.homedir();
   const pluginKey = opts.pluginKey ?? DEFAULT_PLUGIN_KEY;
   const directoryResult = resolveDirectorySourceRoot(targetHome, pluginKey);
-  if (directoryResult !== undefined)
-    return directoryResult;
+  if (directoryResult !== undefined) {
+    return directoryResult === null ? null : { root: directoryResult, route: "directory-source" };
+  }
   const registryPath = path9.join(targetHome, ".claude", "plugins", "installed_plugins.json");
   let records;
   try {
@@ -2706,15 +2791,213 @@ function resolveClaudeMarketplaceRoot(opts = {}) {
   } catch {
     return null;
   }
-  return installPath;
+  return { root: installPath, route: "registry-cache" };
+}
+function resolveClaudeMarketplaceRoot(opts = {}) {
+  return resolveClaudeMarketplaceInstall(opts)?.root ?? null;
+}
+function readInstalledPluginVersion(opts = {}) {
+  const targetHome = opts.targetHome ?? os5.homedir();
+  const pluginKey = opts.pluginKey ?? DEFAULT_PLUGIN_KEY;
+  const registryPath = path9.join(targetHome, ".claude", "plugins", "installed_plugins.json");
+  let records;
+  try {
+    const parsed = JSON.parse(fs5.readFileSync(registryPath, "utf8"));
+    records = parsed?.plugins?.[pluginKey];
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(records) || records.length === 0)
+    return null;
+  return selectRecord(records)?.version ?? null;
 }
 var DEFAULT_PLUGIN_KEY = "massa-ai@massa-ai";
 var init_claude_marketplace = () => {};
 
-// ../../packages/shared/dist/profile-switch/engine.js
+// ../../packages/shared/dist/profile-switch/frontmatter.js
+function parseFrontmatter(raw2) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/.exec(raw2);
+  if (!match) {
+    throw new Error("charter missing YAML frontmatter (--- ... ---) block");
+  }
+  const yamlText = match[1] ?? "";
+  const body = (match[2] ?? "").replace(/^\r?\n/, "");
+  const frontmatter = parseSimpleYaml(yamlText);
+  return { frontmatter, body };
+}
+function parseSimpleYaml(text) {
+  const result = {};
+  const lines = text.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      i++;
+      continue;
+    }
+    const m = /^([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/.exec(line);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const key = m[1];
+    const rest = (m[2] ?? "").trim();
+    if (rest !== "") {
+      result[key] = unquoteScalar(rest);
+      i++;
+      continue;
+    }
+    const nested = {};
+    i++;
+    while (i < lines.length) {
+      const nestedLine = lines[i] ?? "";
+      if (/^\s{2,}\S/.test(nestedLine) === false)
+        break;
+      const nm = /^\s{2,}([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/.exec(nestedLine);
+      if (!nm)
+        break;
+      nested[nm[1]] = unquoteScalar((nm[2] ?? "").trim());
+      i++;
+    }
+    result[key] = nested;
+  }
+  return result;
+}
+function unquoteScalar(s) {
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+// ../../packages/shared/dist/profile-switch/doctor.js
 import fs6 from "fs";
-import path10 from "path";
 import os6 from "os";
+import path10 from "path";
+function readTextFile(filePath) {
+  try {
+    return fs6.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readJsonFile(filePath) {
+  const raw2 = readTextFile(filePath);
+  if (raw2 === null)
+    return null;
+  try {
+    return JSON.parse(raw2);
+  } catch {
+    return null;
+  }
+}
+function readPluginVersion(pluginRoot) {
+  const manifest = readJsonFile(path10.join(pluginRoot, ".claude-plugin", "plugin.json"));
+  return typeof manifest?.version === "string" ? manifest.version : null;
+}
+function detectEnvOverride(env) {
+  for (const name of ENV_OVERRIDE_VARS) {
+    const value = env[name];
+    if (typeof value === "string" && value.trim()) {
+      return { name, value: value.trim() };
+    }
+  }
+  return null;
+}
+function readRoles(liveRoot, activeProfile) {
+  const agentsDir = path10.join(liveRoot, "agents");
+  let entries;
+  try {
+    entries = fs6.readdirSync(agentsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const roles = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.startsWith("massa-ai-") || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const activeRaw = readTextFile(path10.join(agentsDir, entry.name));
+    let model = null;
+    let effort = null;
+    if (activeRaw !== null) {
+      try {
+        const { frontmatter } = parseFrontmatter(activeRaw);
+        model = typeof frontmatter.model === "string" ? frontmatter.model : null;
+        effort = typeof frontmatter.effort === "string" ? frontmatter.effort : null;
+      } catch {}
+    }
+    let staleVariant = false;
+    if (activeProfile && activeRaw !== null) {
+      const variantRaw = readTextFile(path10.join(liveRoot, "agent-profiles", activeProfile, entry.name));
+      if (variantRaw !== null) {
+        staleVariant = variantRaw !== activeRaw;
+      }
+    }
+    roles.push({ name: entry.name, model, effort, staleVariant });
+  }
+  return roles.sort((a, b) => a.name.localeCompare(b.name));
+}
+function runtimeDriftReport(opts = {}) {
+  const targetHome = opts.targetHome ?? os6.homedir();
+  const host = opts.host ?? "claude";
+  const stateFilePath = opts.stateFilePath ?? path10.join(targetHome, ".config", "massa-ai", "install-state.json");
+  let state = opts.state ?? null;
+  if (state === null) {
+    try {
+      state = readInstallState(stateFilePath);
+    } catch {
+      state = null;
+    }
+  }
+  const platform = state?.platforms?.[host];
+  const stateVersion = typeof platform?.plugin?.version === "string" ? platform.plugin.version : null;
+  const activeProfile = platform?.modelProfile?.profile ?? null;
+  if (host !== "claude") {
+    return {
+      host,
+      route: "unresolved",
+      liveRoot: null,
+      sourceVersion: null,
+      stateVersion,
+      pinnedVersion: null,
+      activeProfile,
+      roles: [],
+      envOverride: detectEnvOverride(opts.env ?? process.env),
+      versionDrift: false,
+      profileMaterialized: false
+    };
+  }
+  const install = resolveClaudeMarketplaceInstall({ targetHome, pluginKey: opts.pluginKey });
+  const liveRoot = install?.root ?? null;
+  const sourceVersion = liveRoot === null ? null : readPluginVersion(liveRoot);
+  const pinnedVersion = readInstalledPluginVersion({ targetHome, pluginKey: opts.pluginKey });
+  const roles = liveRoot === null ? [] : readRoles(liveRoot, activeProfile);
+  return {
+    host: "claude",
+    route: install?.route ?? "unresolved",
+    liveRoot,
+    sourceVersion,
+    stateVersion,
+    pinnedVersion,
+    activeProfile,
+    roles,
+    envOverride: detectEnvOverride(opts.env ?? process.env),
+    versionDrift: sourceVersion !== null && stateVersion !== null && sourceVersion !== stateVersion,
+    profileMaterialized: roles.some((role) => role.staleVariant)
+  };
+}
+var ENV_OVERRIDE_VARS;
+var init_doctor = __esm(() => {
+  init_claude_marketplace();
+  init_state();
+  ENV_OVERRIDE_VARS = ["CLAUDE_CODE_SUBAGENT_MODEL"];
+});
+
+// ../../packages/shared/dist/profile-switch/engine.js
+import fs7 from "fs";
+import path11 from "path";
+import os7 from "os";
 import crypto4 from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
 function namedError3(name, message) {
@@ -2723,10 +3006,10 @@ function namedError3(name, message) {
   return err;
 }
 function defaultStatePath(targetHome) {
-  return path10.join(targetHome, ".config", "massa-ai", "install-state.json");
+  return path11.join(targetHome, ".config", "massa-ai", "install-state.json");
 }
 function resolveCommon(opts) {
-  const targetHome = opts.targetHome ?? os6.homedir();
+  const targetHome = opts.targetHome ?? os7.homedir();
   const stateFilePath = opts.stateFilePath ?? defaultStatePath(targetHome);
   return { targetHome, stateFilePath };
 }
@@ -2734,7 +3017,7 @@ function marketplaceRoots(targetHome, state) {
   return state.platforms.claude?.installRoute === "marketplace" ? { claude: resolveClaudeMarketplaceRoot({ targetHome }) ?? undefined } : {};
 }
 function claudeMarketplaceUnresolvedReason(targetHome) {
-  const registryPath = path10.join(targetHome, ".claude", "plugins", "installed_plugins.json");
+  const registryPath = path11.join(targetHome, ".claude", "plugins", "installed_plugins.json");
   return `claude installRoute is "marketplace" but no install root could be resolved from ${registryPath} ` + "\u2014 re-run the Claude plugin installer, or verify the plugin registry file";
 }
 function listProfiles(opts = {}) {
@@ -2742,6 +3025,12 @@ function listProfiles(opts = {}) {
   const state = readInstallState(stateFilePath);
   const roots = marketplaceRoots(targetHome, state);
   const universe = opts.hosts ?? HOSTS;
+  const claudeDrift = universe.includes("claude") ? runtimeDriftReport({ targetHome, stateFilePath, state, env: opts.env }) : null;
+  const claudeDriftFields = (host) => host === "claude" && claudeDrift !== null ? {
+    liveRoot: claudeDrift.liveRoot,
+    sourceVersion: claudeDrift.sourceVersion,
+    envOverride: claudeDrift.envOverride ? `${claudeDrift.envOverride.name}=${claudeDrift.envOverride.value}` : null
+  } : { liveRoot: null, sourceVersion: null, envOverride: null };
   const hosts = universe.map((host) => {
     if (host === "claude" && state.platforms.claude?.installRoute === "marketplace" && roots.claude === undefined) {
       const platform2 = state.platforms.claude;
@@ -2750,9 +3039,10 @@ function listProfiles(opts = {}) {
         installed: false,
         skipped: false,
         skipReason: null,
-        activeProfile: platform2.modelProfile?.profile ?? opts.hostDefaults?.[host] ?? "balanced",
+        activeProfile: platform2.modelProfile?.profile ?? "balanced",
         bundleVersion: platform2.plugin?.version ?? null,
-        availableProfiles: []
+        availableProfiles: [],
+        ...claudeDriftFields(host)
       };
     }
     const layout = resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot, marketplaceRoot: roots });
@@ -2764,10 +3054,11 @@ function listProfiles(opts = {}) {
         skipReason: layout.reason,
         activeProfile: null,
         bundleVersion: null,
-        availableProfiles: []
+        availableProfiles: [],
+        ...claudeDriftFields(host)
       };
     }
-    const installed = fs6.existsSync(layout.activeDir);
+    const installed = fs7.existsSync(layout.activeDir);
     const availableProfiles = listVariantProfiles(layout);
     const platform = state.platforms[host];
     return {
@@ -2775,17 +3066,18 @@ function listProfiles(opts = {}) {
       installed,
       skipped: false,
       skipReason: null,
-      activeProfile: platform?.modelProfile?.profile ?? opts.hostDefaults?.[host] ?? "balanced",
+      activeProfile: platform?.modelProfile?.profile ?? "balanced",
       bundleVersion: platform?.plugin?.version ?? null,
-      availableProfiles
+      availableProfiles,
+      ...claudeDriftFields(host)
     };
   });
   return { hosts };
 }
 function listVariantProfiles(layout) {
-  if (!fs6.existsSync(layout.variantsRoot))
+  if (!fs7.existsSync(layout.variantsRoot))
     return [];
-  return fs6.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  return fs7.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function matchesGlob(filename, glob) {
   const starIdx = glob.indexOf("*");
@@ -2796,7 +3088,7 @@ function matchesGlob(filename, glob) {
   return filename.length >= prefix.length + suffix.length && filename.startsWith(prefix) && filename.endsWith(suffix);
 }
 function matchingFileNames(dir, glob) {
-  return fs6.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && matchesGlob(e.name, glob)).map((e) => e.name);
+  return fs7.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && matchesGlob(e.name, glob)).map((e) => e.name);
 }
 function detectGitAvailability(dir) {
   try {
@@ -2822,7 +3114,7 @@ function gitTrackedFileNames(dir, filenames) {
   }
 }
 function checkTrackedPathGuard(activeDir, filenames) {
-  if (filenames.length === 0 || !fs6.existsSync(activeDir))
+  if (filenames.length === 0 || !fs7.existsSync(activeDir))
     return GUARD_PASS;
   const availability = detectGitAvailability(activeDir);
   if (availability === "no-git")
@@ -2833,53 +3125,53 @@ function checkTrackedPathGuard(activeDir, filenames) {
   if (tracked.size === 0)
     return GUARD_PASS;
   const offending = filenames.find((name) => tracked.has(name));
-  return { blocked: true, path: path10.join(activeDir, offending), unchecked: false };
+  return { blocked: true, path: path11.join(activeDir, offending), unchecked: false };
 }
 function assertStateWritable(stateFilePath) {
-  const dir = path10.dirname(stateFilePath);
+  const dir = path11.dirname(stateFilePath);
   try {
-    fs6.mkdirSync(dir, { recursive: true });
+    fs7.mkdirSync(dir, { recursive: true });
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
-  const checkPath = fs6.existsSync(stateFilePath) ? stateFilePath : dir;
+  const checkPath = fs7.existsSync(stateFilePath) ? stateFilePath : dir;
   try {
-    fs6.accessSync(checkPath, fs6.constants.W_OK);
+    fs7.accessSync(checkPath, fs7.constants.W_OK);
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
 }
 function copyFileRouteVariant(layout, variantDir) {
-  fs6.mkdirSync(layout.activeDir, { recursive: true });
+  fs7.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs6.readdirSync(variantDir, { withFileTypes: true })) {
+  for (const entry of fs7.readdirSync(variantDir, { withFileTypes: true })) {
     if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
       continue;
-    fs6.copyFileSync(path10.join(variantDir, entry.name), path10.join(layout.activeDir, entry.name));
+    fs7.copyFileSync(path11.join(variantDir, entry.name), path11.join(layout.activeDir, entry.name));
     changed++;
   }
   return changed;
 }
 function repointOpencodeVariant(layout, variantDir) {
-  fs6.mkdirSync(layout.activeDir, { recursive: true });
+  fs7.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs6.readdirSync(variantDir, { withFileTypes: true })) {
+  for (const entry of fs7.readdirSync(variantDir, { withFileTypes: true })) {
     if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
       continue;
-    const dest = path10.join(layout.activeDir, entry.name);
-    const target = path10.resolve(path10.join(variantDir, entry.name));
+    const dest = path11.join(layout.activeDir, entry.name);
+    const target = path11.resolve(path11.join(variantDir, entry.name));
     let destExists = true;
     let destIsSymlink = false;
     try {
-      destIsSymlink = fs6.lstatSync(dest).isSymbolicLink();
+      destIsSymlink = fs7.lstatSync(dest).isSymbolicLink();
     } catch {
       destExists = false;
     }
     if (destExists && !destIsSymlink)
       continue;
     const tmp = `${dest}.massa-ai-switch.${crypto4.randomUUID()}`;
-    fs6.symlinkSync(target, tmp);
-    fs6.renameSync(tmp, dest);
+    fs7.symlinkSync(target, tmp);
+    fs7.renameSync(tmp, dest);
     changed++;
   }
   return changed;
@@ -2919,13 +3211,13 @@ function switchProfile(opts) {
   if (fileHosts.length === 0) {
     return { profile: opts.profile, dryRun, hosts: orderRows(universe, skipRows), restartRequired: false };
   }
-  const installedFileHosts = fileHosts.filter((h) => fs6.existsSync(h.layout.activeDir));
+  const installedFileHosts = fileHosts.filter((h) => fs7.existsSync(h.layout.activeDir));
   if (installedFileHosts.length === 0)
     throw NoHostsDetectedError();
   const withAvailability = fileHosts.map((h) => {
-    const variantsRootExists = fs6.existsSync(h.layout.variantsRoot);
+    const variantsRootExists = fs7.existsSync(h.layout.variantsRoot);
     const variantDir = h.layout.variantDir(opts.profile);
-    const available = variantsRootExists && fs6.existsSync(variantDir) && fs6.statSync(variantDir).isDirectory();
+    const available = variantsRootExists && fs7.existsSync(variantDir) && fs7.statSync(variantDir).isDirectory();
     return { ...h, variantsRootExists, variantDir, available };
   });
   if (!withAvailability.some((h) => h.available)) {
@@ -2961,7 +3253,7 @@ function switchProfile(opts) {
         continue;
       }
       if (dryRun) {
-        rows.push({ host: h.host, status: "switched" });
+        rows.push({ host: h.host, status: "would-switch" });
         continue;
       }
       const candidateNames = matchingFileNames(h.variantDir, h.layout.activeGlob);
@@ -3006,6 +3298,7 @@ var init_engine = __esm(() => {
   init_state();
   init_lock();
   init_claude_marketplace();
+  init_doctor();
   SwitchEngineError = class SwitchEngineError extends Error {
     constructor(message) {
       super(message);
@@ -3018,29 +3311,29 @@ var init_engine = __esm(() => {
 
 // ../../packages/shared/dist/profile-switch/report.js
 function reportSucceeded(report) {
-  return report.hosts.every((h) => h.status === "switched" || h.status === "skipped");
+  return report.hosts.every((h) => h.status === "switched" || h.status === "would-switch" || h.status === "skipped");
 }
 
 // ../../packages/shared/dist/profile-switch/variant-sync.js
-import fs7 from "fs";
-import path11 from "path";
-import os7 from "os";
+import fs8 from "fs";
+import path12 from "path";
+import os8 from "os";
 import crypto5 from "crypto";
 function defaultStatePath2(targetHome) {
-  return path11.join(targetHome, ".config", "massa-ai", "install-state.json");
+  return path12.join(targetHome, ".config", "massa-ai", "install-state.json");
 }
 function marketplaceRoots2(targetHome, state) {
   return state.platforms.claude?.installRoute === "marketplace" ? { claude: resolveClaudeMarketplaceRoot({ targetHome }) ?? undefined } : {};
 }
 function writeFileIntoDirAtomically(destDir, destName, content) {
   const unique = `${process.pid}.${++tempFileCounter2}.${crypto5.randomBytes(6).toString("hex")}`;
-  const tempFile = path11.join(destDir, `.${destName}.${unique}.tmp`);
+  const tempFile = path12.join(destDir, `.${destName}.${unique}.tmp`);
   try {
-    fs7.writeFileSync(tempFile, content);
-    fs7.renameSync(tempFile, path11.join(destDir, destName));
+    fs8.writeFileSync(tempFile, content);
+    fs8.renameSync(tempFile, path12.join(destDir, destName));
   } catch (error) {
     try {
-      fs7.unlinkSync(tempFile);
+      fs8.unlinkSync(tempFile);
     } catch {}
     throw error;
   }
@@ -3048,20 +3341,20 @@ function writeFileIntoDirAtomically(destDir, destName, content) {
 function isSafeDirName(name) {
   if (name === "." || name === "..")
     return false;
-  if (name.includes("/") || name.includes("\\") || name.includes(path11.sep))
+  if (name.includes("/") || name.includes("\\") || name.includes(path12.sep))
     return false;
-  return path11.basename(name) === name;
+  return path12.basename(name) === name;
 }
 function syncHost(host, sourceRoot, targetHome, marketplaceRoot) {
   const layout = resolveHostLayout(host, { targetHome, marketplaceRoot });
   if (layout.route === "skip") {
     return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: layout.reason };
   }
-  const srcDir = path11.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
-  if (!fs7.existsSync(srcDir) || !fs7.statSync(srcDir).isDirectory()) {
+  const srcDir = path12.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
+  if (!fs8.existsSync(srcDir) || !fs8.statSync(srcDir).isDirectory()) {
     return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: "no generated variants for this host" };
   }
-  if (!fs7.existsSync(layout.variantsRoot)) {
+  if (!fs8.existsSync(layout.variantsRoot)) {
     return {
       host,
       status: "skipped",
@@ -3073,24 +3366,24 @@ function syncHost(host, sourceRoot, targetHome, marketplaceRoot) {
   }
   const profiles = [];
   let files = 0;
-  for (const entry of fs7.readdirSync(srcDir, { withFileTypes: true })) {
+  for (const entry of fs8.readdirSync(srcDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     if (!isSafeDirName(entry.name))
       continue;
-    const srcProfileDir = path11.join(srcDir, entry.name);
-    const destProfileDir = path11.join(layout.variantsRoot, entry.name);
-    fs7.mkdirSync(destProfileDir, { recursive: true });
-    for (const fileEntry of fs7.readdirSync(srcProfileDir, { withFileTypes: true })) {
+    const srcProfileDir = path12.join(srcDir, entry.name);
+    const destProfileDir = path12.join(layout.variantsRoot, entry.name);
+    fs8.mkdirSync(destProfileDir, { recursive: true });
+    for (const fileEntry of fs8.readdirSync(srcProfileDir, { withFileTypes: true })) {
       if (!fileEntry.isFile())
         continue;
-      const content = fs7.readFileSync(path11.join(srcProfileDir, fileEntry.name));
+      const content = fs8.readFileSync(path12.join(srcProfileDir, fileEntry.name));
       writeFileIntoDirAtomically(destProfileDir, fileEntry.name, content);
       files++;
     }
     profiles.push(entry.name);
   }
-  const retained = fs7.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && !profiles.includes(e.name)).map((e) => e.name).sort();
+  const retained = fs8.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && !profiles.includes(e.name)).map((e) => e.name).sort();
   return { host, status: "synced", profiles: profiles.sort(), retained, files };
 }
 function syncGeneratedVariants(opts) {
@@ -3106,7 +3399,7 @@ function syncGeneratedVariants(opts) {
     }));
   }
   const sourceRoot = opts.sourceRoot;
-  const targetHome = opts.targetHome ?? os7.homedir();
+  const targetHome = opts.targetHome ?? os8.homedir();
   const state = readInstallState(defaultStatePath2(targetHome));
   const roots = marketplaceRoots2(targetHome, state);
   return hosts.map((host) => {
@@ -3125,14 +3418,14 @@ var init_variant_sync = __esm(() => {
 });
 
 // ../../packages/shared/dist/profile-switch/repo-root.js
-import fs8 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path13 from "path";
 function findRepoRootWithMarker(startDir, marker, maxLevels) {
   let dir = startDir;
   for (let i = 0;i <= maxLevels; i++) {
-    if (fs8.existsSync(path12.join(dir, marker)))
+    if (fs9.existsSync(path13.join(dir, marker)))
       return dir;
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -3230,7 +3523,7 @@ var init_rules = __esm(() => {
 });
 
 // ../../packages/shared/dist/bootstrap/state.js
-import fs9 from "fs";
+import fs10 from "fs";
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -3261,7 +3554,7 @@ function resolveBootstrapState(doc) {
 }
 function readConfigBytes() {
   try {
-    return fs9.readFileSync(getConfigPath(), "utf-8");
+    return fs10.readFileSync(getConfigPath(), "utf-8");
   } catch (error) {
     if (error?.code === "ENOENT")
       return "";
@@ -3316,7 +3609,7 @@ var init_state2 = __esm(() => {
 });
 
 // ../../packages/shared/dist/bootstrap/render.js
-import path13 from "path";
+import path14 from "path";
 function wrapBootstrapBlock(body) {
   return `${BOOTSTRAP_BLOCK_START}
 ${body.replace(/\n+$/, "")}
@@ -3329,19 +3622,19 @@ function ruleMarker(id, suffix) {
 function resolveHostRoot(host, targetHome, hostRoot) {
   requireAbsoluteTargetHome(targetHome);
   if (hostRoot === undefined)
-    return path13.join(targetHome, ...HOST_CONFIG_DIR[host]);
-  const relative = path13.relative(targetHome, hostRoot);
-  if (!path13.isAbsolute(hostRoot) || relative === "" || relative.startsWith("..") || path13.isAbsolute(relative)) {
+    return path14.join(targetHome, ...HOST_CONFIG_DIR[host]);
+  const relative = path14.relative(targetHome, hostRoot);
+  if (!path14.isAbsolute(hostRoot) || relative === "" || relative.startsWith("..") || path14.isAbsolute(relative)) {
     throw new BootstrapRenderError("HostRootOutsideTargetHomeError", `hostRoot must be an absolute directory inside targetHome, got "${hostRoot}" for targetHome "${targetHome}"`, [hostRoot, targetHome]);
   }
   return hostRoot;
 }
 function bootstrapContractPath(host, targetHome, hostRoot) {
-  return path13.join(resolveHostRoot(host, targetHome, hostRoot), CONTRACT_FILENAME);
+  return path14.join(resolveHostRoot(host, targetHome, hostRoot), CONTRACT_FILENAME);
 }
 function bootstrapStateFilePath(targetHome) {
   requireAbsoluteTargetHome(targetHome);
-  return path13.join(targetHome, ".config", "massa-ai", "config.json");
+  return path14.join(targetHome, ".config", "massa-ai", "config.json");
 }
 function renderBootstrap(options) {
   const { source, state, host, targetHome, hostRoot } = options;
@@ -3364,7 +3657,7 @@ ${body}`;
   return { contract, pointer };
 }
 function requireAbsoluteTargetHome(targetHome) {
-  if (!path13.isAbsolute(targetHome)) {
+  if (!path14.isAbsolute(targetHome)) {
     throw new BootstrapRenderError("TargetHomeNotAbsoluteError", `targetHome must be an absolute path, got "${targetHome}"`, [targetHome]);
   }
 }
@@ -3541,14 +3834,14 @@ var init_report = __esm(() => {
 });
 
 // ../../packages/shared/dist/bootstrap/engine.js
-import fs10 from "fs";
-import path14 from "path";
+import fs11 from "fs";
+import path15 from "path";
 function applyBootstrapState(options) {
   const { targetHome } = options;
   const dryRun = options.dryRun ?? false;
   const warn = options.onWarning ?? ((message) => console.warn(message));
   const configPath = bootstrapStateFilePath(targetHome);
-  const installStatePath = path14.join(path14.dirname(configPath), INSTALL_STATE_FILENAME);
+  const installStatePath = path15.join(path15.dirname(configPath), INSTALL_STATE_FILENAME);
   const { platforms } = readInstallState(installStatePath);
   const installed = HOSTS.filter((host) => platforms[host] !== undefined);
   if (installed.length === 0) {
@@ -3641,22 +3934,22 @@ function applyHost(input) {
 }
 function wiringArtifact(host, targetHome, hostRoot) {
   const root = resolveHostRoot(host, targetHome, hostRoot);
-  const contractPath = path14.join(root, CONTRACT_FILENAME);
+  const contractPath = path15.join(root, CONTRACT_FILENAME);
   switch (host) {
     case "claude":
-      return { file: path14.join(root, "CLAUDE.md"), token: `@${CONTRACT_FILENAME}` };
+      return { file: path15.join(root, "CLAUDE.md"), token: `@${CONTRACT_FILENAME}` };
     case "codex":
     case "cursor":
-      return { file: path14.join(root, "AGENTS.md"), token: contractPath };
+      return { file: path15.join(root, "AGENTS.md"), token: contractPath };
     case "opencode":
       return { file: openCodeConfigPath(root), token: `"${contractPath}"` };
   }
 }
 function openCodeConfigPath(root) {
-  const json = path14.join(root, "opencode.json");
-  if (fs10.existsSync(json))
+  const json = path15.join(root, "opencode.json");
+  if (fs11.existsSync(json))
     return json;
-  return path14.join(root, "opencode.jsonc");
+  return path15.join(root, "opencode.jsonc");
 }
 function isWired(host, targetHome, hostRoot) {
   const artifact = wiringArtifact(host, targetHome, hostRoot);
@@ -3669,7 +3962,7 @@ function notWiredReason(host, targetHome, hostRoot) {
 }
 function readFileOrNull(filePath) {
   try {
-    return fs10.readFileSync(filePath, "utf-8");
+    return fs11.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -3753,6 +4046,7 @@ var init_dist = __esm(() => {
   init_engine();
   init_variant_sync();
   init_repo_root();
+  init_doctor();
   init_bootstrap();
   init_types();
   init_interfaces();
@@ -5275,7 +5569,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path15, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
+}, defaultPlatform, path16, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -5333,11 +5627,11 @@ var init_esm = __esm(() => {
   starRE = /^\*+$/;
   qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
   defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-  path15 = {
+  path16 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep = defaultPlatform === "win32" ? path15.win32.sep : path15.posix.sep;
+  sep = defaultPlatform === "win32" ? path16.win32.sep : path16.posix.sep;
   minimatch.sep = sep;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -7303,12 +7597,12 @@ var init_esm4 = __esm(() => {
     childrenCache() {
       return this.#children;
     }
-    resolve(path16) {
-      if (!path16) {
+    resolve(path17) {
+      if (!path17) {
         return this;
       }
-      const rootPath = this.getRootString(path16);
-      const dir = path16.substring(rootPath.length);
+      const rootPath = this.getRootString(path17);
+      const dir = path17.substring(rootPath.length);
       const dirParts = dir.split(this.splitSep);
       const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
       return result;
@@ -7836,8 +8130,8 @@ var init_esm4 = __esm(() => {
     newChild(name, type = UNKNOWN, opts = {}) {
       return new PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
     }
-    getRootString(path16) {
-      return win32.parse(path16).root;
+    getRootString(path17) {
+      return win32.parse(path17).root;
     }
     getRoot(rootPath) {
       rootPath = uncToDrive(rootPath.toUpperCase());
@@ -7862,8 +8156,8 @@ var init_esm4 = __esm(() => {
     constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
       super(name, type, root, roots, nocase, children, opts);
     }
-    getRootString(path16) {
-      return path16.startsWith("/") ? "/" : "";
+    getRootString(path17) {
+      return path17.startsWith("/") ? "/" : "";
     }
     getRoot(_rootPath) {
       return this.root;
@@ -7882,8 +8176,8 @@ var init_esm4 = __esm(() => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs11 = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs11);
+    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs12 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs12);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = fileURLToPath(cwd);
       }
@@ -7919,11 +8213,11 @@ var init_esm4 = __esm(() => {
       }
       this.cwd = prev;
     }
-    depth(path16 = this.cwd) {
-      if (typeof path16 === "string") {
-        path16 = this.cwd.resolve(path16);
+    depth(path17 = this.cwd) {
+      if (typeof path17 === "string") {
+        path17 = this.cwd.resolve(path17);
       }
-      return path16.depth();
+      return path17.depth();
     }
     childrenCache() {
       return this.#children;
@@ -8339,9 +8633,9 @@ var init_esm4 = __esm(() => {
       process2();
       return results;
     }
-    chdir(path16 = this.cwd) {
+    chdir(path17 = this.cwd) {
       const oldCwd = this.cwd;
-      this.cwd = typeof path16 === "string" ? this.cwd.resolve(path16) : path16;
+      this.cwd = typeof path17 === "string" ? this.cwd.resolve(path17) : path17;
       this.cwd[setAsCwd](oldCwd);
     }
   };
@@ -8358,8 +8652,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(dir) {
       return win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs11) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs11 });
+    newRoot(fs12) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs12 });
     }
     isAbsolute(p) {
       return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -8375,8 +8669,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs11) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs11 });
+    newRoot(fs12) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs12 });
     }
     isAbsolute(p) {
       return p.startsWith("/");
@@ -8633,8 +8927,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n : n & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path16, n]) => [
-      path16,
+    return [...this.store.entries()].map(([path17, n]) => [
+      path17,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -8838,9 +9132,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path16, opts) {
+  constructor(patterns, path17, opts) {
     this.patterns = patterns;
-    this.path = path16;
+    this.path = path17;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -8859,11 +9153,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path16) {
-    return this.seen.has(path16) || !!this.#ignore?.ignored?.(path16);
+  #ignored(path17) {
+    return this.seen.has(path17) || !!this.#ignore?.ignored?.(path17);
   }
-  #childrenIgnored(path16) {
-    return !!this.#ignore?.childrenIgnored?.(path16);
+  #childrenIgnored(path17) {
+    return !!this.#ignore?.childrenIgnored?.(path17);
   }
   pause() {
     this.paused = true;
@@ -9080,8 +9374,8 @@ var init_walker = __esm(() => {
   init_processor();
   GlobWalker = class GlobWalker extends GlobUtil {
     matches = new Set;
-    constructor(patterns, path16, opts) {
-      super(patterns, path16, opts);
+    constructor(patterns, path17, opts) {
+      super(patterns, path17, opts);
     }
     matchEmit(e) {
       this.matches.add(e);
@@ -9118,8 +9412,8 @@ var init_walker = __esm(() => {
   };
   GlobStream = class GlobStream extends GlobUtil {
     results;
-    constructor(patterns, path16, opts) {
-      super(patterns, path16, opts);
+    constructor(patterns, path17, opts) {
+      super(patterns, path17, opts);
       this.results = new Minipass({
         signal: this.signal,
         objectMode: true
@@ -9547,20 +9841,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path16, originalPath, doThrow) => {
-    if (!isString(path16)) {
+  var checkPath = (path17, originalPath, doThrow) => {
+    if (!isString(path17)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path16) {
+    if (!path17) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path16)) {
+    if (checkPath.isNotRelative(path17)) {
       const r = "`path.relative()`d";
       return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path16) => REGEX_TEST_INVALID_PATH.test(path16);
+  var isNotRelative = (path17) => REGEX_TEST_INVALID_PATH.test(path17);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p) => p;
 
@@ -9603,7 +9897,7 @@ var require_ignore = __commonJS((exports, module) => {
     addPattern(pattern) {
       return this.add(pattern);
     }
-    _testOne(path16, checkUnignored) {
+    _testOne(path17, checkUnignored) {
       let ignored = false;
       let unignored = false;
       this._rules.forEach((rule) => {
@@ -9611,7 +9905,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule.regex.test(path16);
+        const matched = rule.regex.test(path17);
         if (matched) {
           ignored = !negative;
           unignored = negative;
@@ -9623,39 +9917,39 @@ var require_ignore = __commonJS((exports, module) => {
       };
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path16 = originalPath && checkPath.convert(originalPath);
-      checkPath(path16, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path16, cache, checkUnignored, slices);
+      const path17 = originalPath && checkPath.convert(originalPath);
+      checkPath(path17, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path17, cache, checkUnignored, slices);
     }
-    _t(path16, cache, checkUnignored, slices) {
-      if (path16 in cache) {
-        return cache[path16];
+    _t(path17, cache, checkUnignored, slices) {
+      if (path17 in cache) {
+        return cache[path17];
       }
       if (!slices) {
-        slices = path16.split(SLASH2);
+        slices = path17.split(SLASH2);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path16] = this._testOne(path16, checkUnignored);
+        return cache[path17] = this._testOne(path17, checkUnignored);
       }
       const parent = this._t(slices.join(SLASH2) + SLASH2, cache, checkUnignored, slices);
-      return cache[path16] = parent.ignored ? parent : this._testOne(path16, checkUnignored);
+      return cache[path17] = parent.ignored ? parent : this._testOne(path17, checkUnignored);
     }
-    ignores(path16) {
-      return this._test(path16, this._ignoreCache, false).ignored;
+    ignores(path17) {
+      return this._test(path17, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path16) => !this.ignores(path16);
+      return (path17) => !this.ignores(path17);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path16) {
-      return this._test(path16, this._testCache, true);
+    test(path17) {
+      return this._test(path17, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore2(options);
-  var isPathValid = (path16) => checkPath(path16 && checkPath.convert(path16), path16, RETURN_FALSE);
+  var isPathValid = (path17) => checkPath(path17 && checkPath.convert(path17), path17, RETURN_FALSE);
   factory.isPathValid = isPathValid;
   factory.default = factory;
   module.exports = factory;
@@ -9663,7 +9957,7 @@ var require_ignore = __commonJS((exports, module) => {
     const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
     checkPath.convert = makePosix;
     const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-    checkPath.isNotRelative = (path16) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path16) || isNotRelative(path16);
+    checkPath.isNotRelative = (path17) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path17) || isNotRelative(path17);
   }
 });
 
@@ -9725,13 +10019,13 @@ function validatePolicy(policy, opts = {}) {
     }
   }
 }
-function matchesGlob2(path16, pattern) {
+function matchesGlob2(path17, pattern) {
   let re = regexCache.get(pattern);
   if (!re) {
     re = globToRegex(pattern);
     regexCache.set(pattern, re);
   }
-  return re.test(path16);
+  return re.test(path17);
 }
 var DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
   const normalized = filePath.trim();
@@ -9748,8 +10042,8 @@ var init_capture_policy = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/ignore-patterns.js
-import fs11 from "fs/promises";
-import path16 from "path";
+import fs12 from "fs/promises";
+import path17 from "path";
 function buildExtensionGlob(extensions) {
   return extensions.map((ext2) => `**/*${ext2}`);
 }
@@ -9772,8 +10066,8 @@ async function loadProjectIgnore(projectPath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
   try {
-    const gitignorePath = path16.join(projectPath, ".gitignore");
-    const gitignoreContent = await fs11.readFile(gitignorePath, "utf8");
+    const gitignorePath = path17.join(projectPath, ".gitignore");
+    const gitignoreContent = await fs12.readFile(gitignorePath, "utf8");
     const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     ig.add(rules);
@@ -11372,15 +11666,15 @@ var require_pg_connection_string = __commonJS((exports, module) => {
     if (config2.sslnegotiation === "direct" && config2.ssl === undefined) {
       config2.ssl = true;
     }
-    const fs12 = config2.sslcert || config2.sslkey || config2.sslrootcert ? __require("fs") : null;
+    const fs13 = config2.sslcert || config2.sslkey || config2.sslrootcert ? __require("fs") : null;
     if (config2.sslcert) {
-      config2.ssl.cert = fs12.readFileSync(config2.sslcert).toString();
+      config2.ssl.cert = fs13.readFileSync(config2.sslcert).toString();
     }
     if (config2.sslkey) {
-      config2.ssl.key = fs12.readFileSync(config2.sslkey).toString();
+      config2.ssl.key = fs13.readFileSync(config2.sslkey).toString();
     }
     if (config2.sslrootcert) {
-      config2.ssl.ca = fs12.readFileSync(config2.sslrootcert).toString();
+      config2.ssl.ca = fs13.readFileSync(config2.sslrootcert).toString();
     }
     if (options.useLibpqCompat && config2.uselibpqcompat) {
       throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
@@ -13094,7 +13388,7 @@ var require_split2 = __commonJS((exports, module) => {
 
 // ../../node_modules/pgpass/lib/helper.js
 var require_helper = __commonJS((exports, module) => {
-  var path17 = __require("path");
+  var path18 = __require("path");
   var Stream2 = __require("stream").Stream;
   var split = require_split2();
   var util = __require("util");
@@ -13134,7 +13428,7 @@ var require_helper = __commonJS((exports, module) => {
   };
   exports.getFileName = function(rawEnv) {
     var env = rawEnv || process.env;
-    var file = env.PGPASSFILE || (isWin ? path17.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path17.join(env.HOME || "./", ".pgpass"));
+    var file = env.PGPASSFILE || (isWin ? path18.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path18.join(env.HOME || "./", ".pgpass"));
     return file;
   };
   exports.usePgPass = function(stats, fname) {
@@ -13258,16 +13552,16 @@ var require_helper = __commonJS((exports, module) => {
 
 // ../../node_modules/pgpass/lib/index.js
 var require_lib = __commonJS((exports, module) => {
-  var path17 = __require("path");
-  var fs12 = __require("fs");
+  var path18 = __require("path");
+  var fs13 = __require("fs");
   var helper = require_helper();
   module.exports = function(connInfo, cb) {
     var file = helper.getFileName();
-    fs12.stat(file, function(err, stat) {
+    fs13.stat(file, function(err, stat) {
       if (err || !helper.usePgPass(stat, file)) {
         return cb(undefined);
       }
-      var st = fs12.createReadStream(file);
+      var st = fs13.createReadStream(file);
       helper.getPassword(connInfo, st, cb);
     });
   };
@@ -14905,7 +15199,7 @@ class ProjectIdentityAliasResolver {
       this.cache.set(projectId, { canonical, expiresAt: this.now() + this.ttlMs });
       return canonical;
     } catch (error) {
-      logger.warn("[project-identity] alias resolution failed; using original id", safeErrorSummary(error));
+      logger.warn("[project-identity] alias resolution failed; using original id", { projectId, ...safeErrorSummary(error) });
       return projectId;
     }
   }
@@ -14966,8 +15260,8 @@ var init_alias_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/index-manager.js
-import fs12 from "fs";
-import path17 from "path";
+import fs13 from "fs";
+import path18 from "path";
 
 class IndexManager {
   metadataCache = new Map;
@@ -15060,9 +15354,9 @@ class IndexManager {
       const fileMetadata = {};
       let totalSize = 0;
       for (const filePath of indexedFiles) {
-        const fullPath = path17.join(projectPath, filePath);
+        const fullPath = path18.join(projectPath, filePath);
         try {
-          const stat = await fs12.promises.stat(fullPath);
+          const stat = await fs13.promises.stat(fullPath);
           fileMetadata[filePath] = {
             path: filePath,
             mtime: stat.mtimeMs,
@@ -15113,9 +15407,9 @@ class IndexManager {
         if (ig.ignores(match2)) {
           continue;
         }
-        const fullPath = path17.join(projectPath, match2);
+        const fullPath = path18.join(projectPath, match2);
         try {
-          const stat = await fs12.promises.stat(fullPath);
+          const stat = await fs13.promises.stat(fullPath);
           files.set(match2, {
             path: match2,
             mtime: stat.mtimeMs,
@@ -15566,10 +15860,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -15897,11 +16191,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -16114,16 +16408,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path18 = []) => {
+  const processError = (error2, path19 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -16150,17 +16444,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path18 = []) => {
+  const processError = (error2, path19 = []) => {
     var _a3, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -16192,8 +16486,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -29196,13 +29490,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -30691,8 +30985,8 @@ class ParseStatus {
   }
 }
 var makeIssue = (params) => {
-  const { data, path: path18, errorMaps, issueData } = params;
-  const fullPath = [...path18, ...issueData.path || []];
+  const { data, path: path19, errorMaps, issueData } = params;
+  const fullPath = [...path19, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -30737,11 +31031,11 @@ var init_errorUtil = __esm(() => {
 
 // ../../node_modules/zod/v3/types.js
 class ParseInputLazyPath {
-  constructor(parent, value, path18, key) {
+  constructor(parent, value, path19, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path18;
+    this._path = path19;
     this._key = key;
   }
   get path() {
@@ -36806,23 +37100,23 @@ var require_auth_config = __commonJS((exports, module) => {
     writeAuthConfig: () => writeAuthConfig
   });
   module.exports = __toCommonJS2(auth_config_exports);
-  var fs13 = __toESM2(__require("fs"));
-  var path18 = __toESM2(__require("path"));
+  var fs14 = __toESM2(__require("fs"));
+  var path19 = __toESM2(__require("path"));
   var import_token_util = require_token_util();
   function getAuthConfigPath() {
     const dataDir = (0, import_token_util.getVercelDataDir)();
     if (!dataDir) {
       throw new Error(`Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`);
     }
-    return path18.join(dataDir, "auth.json");
+    return path19.join(dataDir, "auth.json");
   }
   function readAuthConfig() {
     try {
       const authPath = getAuthConfigPath();
-      if (!fs13.existsSync(authPath)) {
+      if (!fs14.existsSync(authPath)) {
         return null;
       }
-      const content = fs13.readFileSync(authPath, "utf8");
+      const content = fs14.readFileSync(authPath, "utf8");
       if (!content) {
         return null;
       }
@@ -36833,11 +37127,11 @@ var require_auth_config = __commonJS((exports, module) => {
   }
   function writeAuthConfig(config3) {
     const authPath = getAuthConfigPath();
-    const authDir = path18.dirname(authPath);
-    if (!fs13.existsSync(authDir)) {
-      fs13.mkdirSync(authDir, { mode: 504, recursive: true });
+    const authDir = path19.dirname(authPath);
+    if (!fs14.existsSync(authDir)) {
+      fs14.mkdirSync(authDir, { mode: 504, recursive: true });
     }
-    fs13.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+    fs14.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
   }
   function isValidAccessToken(authConfig, expirationBufferMs = 0) {
     if (!authConfig.token)
@@ -37012,8 +37306,8 @@ var require_token_util = __commonJS((exports, module) => {
     saveToken: () => saveToken
   });
   module.exports = __toCommonJS2(token_util_exports);
-  var path18 = __toESM2(__require("path"));
-  var fs13 = __toESM2(__require("fs"));
+  var path19 = __toESM2(__require("path"));
+  var fs14 = __toESM2(__require("fs"));
   var import_token_error = require_token_error();
   var import_token_io = require_token_io();
   var import_auth_config = require_auth_config();
@@ -37025,7 +37319,7 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dataDir) {
       return null;
     }
-    return path18.join(dataDir, vercelFolder);
+    return path19.join(dataDir, vercelFolder);
   }
   async function getVercelToken2(options) {
     const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -37093,11 +37387,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find project root directory. Have you linked your project with `vc link?`");
     }
-    const prjPath = path18.join(dir, ".vercel", "project.json");
-    if (!fs13.existsSync(prjPath)) {
+    const prjPath = path19.join(dir, ".vercel", "project.json");
+    if (!fs14.existsSync(prjPath)) {
       throw new import_token_error.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");
     }
-    const prj = JSON.parse(fs13.readFileSync(prjPath, "utf8"));
+    const prj = JSON.parse(fs14.readFileSync(prjPath, "utf8"));
     if (typeof prj.projectId !== "string" && typeof prj.orgId !== "string") {
       throw new TypeError("Expected a string-valued projectId property. Try running `vc link` to re-link your project.");
     }
@@ -37108,11 +37402,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find user data directory. Please reach out to Vercel support.");
     }
-    const tokenPath = path18.join(dir, "com.vercel.token", `${projectId}.json`);
+    const tokenPath = path19.join(dir, "com.vercel.token", `${projectId}.json`);
     const tokenJson = JSON.stringify(token);
-    fs13.mkdirSync(path18.dirname(tokenPath), { mode: 504, recursive: true });
-    fs13.writeFileSync(tokenPath, tokenJson);
-    fs13.chmodSync(tokenPath, 432);
+    fs14.mkdirSync(path19.dirname(tokenPath), { mode: 504, recursive: true });
+    fs14.writeFileSync(tokenPath, tokenJson);
+    fs14.chmodSync(tokenPath, 432);
     return;
   }
   function loadToken(projectId) {
@@ -37120,11 +37414,11 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dir) {
       throw new import_token_error.VercelOidcTokenError("Unable to find user data directory. Please reach out to Vercel support.");
     }
-    const tokenPath = path18.join(dir, "com.vercel.token", `${projectId}.json`);
-    if (!fs13.existsSync(tokenPath)) {
+    const tokenPath = path19.join(dir, "com.vercel.token", `${projectId}.json`);
+    if (!fs14.existsSync(tokenPath)) {
       return null;
     }
-    const token = JSON.parse(fs13.readFileSync(tokenPath, "utf8"));
+    const token = JSON.parse(fs14.readFileSync(tokenPath, "utf8"));
     assertVercelOidcTokenResponse(token);
     return token;
   }
@@ -47966,37 +48260,37 @@ function createOpenAI(options = {}) {
   }, `ai-sdk/openai/${VERSION4}`);
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path18 }) => `${baseURL}${path18}`,
+    url: ({ path: path19 }) => `${baseURL}${path19}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -48009,7 +48303,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path18 }) => `${baseURL}${path18}`,
+      url: ({ path: path19 }) => `${baseURL}${path19}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -52450,7 +52744,7 @@ async function _checkJsonSchemaSupport() {
   } catch (e) {
     _jsonSchemaSupported = false;
     logger.warn("json_schema: version check error \u2014 falling back to json_object", {
-      error: e.message
+      error: e
     });
     return false;
   }
@@ -52498,7 +52792,7 @@ function hostPort(url2) {
     return null;
   }
 }
-function resolveInferenceSpec(baseUrl) {
+function resolveMatchedProviderSpec(baseUrl) {
   const target = hostPort(baseUrl);
   if (target) {
     const match2 = inferenceProviderList().find((spec) => hostPort(spec.defaultLlmBaseUrl) === target);
@@ -52516,7 +52810,13 @@ function resolveInferenceSpec(baseUrl) {
   if (embeddingProvider && LOCAL_INFERENCE_IDS.includes(embeddingProvider)) {
     return INFERENCE_PROVIDERS[embeddingProvider];
   }
-  return INFERENCE_PROVIDERS.ollama;
+  return;
+}
+function resolveInferenceSpec(baseUrl) {
+  return resolveMatchedProviderSpec(baseUrl) ?? INFERENCE_PROVIDERS.ollama;
+}
+function resolveProviderIdForLogging(baseUrl) {
+  return resolveMatchedProviderSpec(baseUrl)?.id ?? "unknown";
 }
 function _wrapFetchDisableThink(baseFetch) {
   const wrapped = async (input, init) => {
@@ -52659,12 +52959,40 @@ function _isAbortOrTimeoutError(err) {
   }
   return false;
 }
-async function llmComplete(prompt, opts = {}) {
+function summarizeZodIssues(error51, maxIssues = 5) {
+  return error51.issues.slice(0, maxIssues).map((issue2) => `${issue2.path.join(".") || "(root)"}: ${issue2.message}`).join("; ");
+}
+function recordLlmFailure(label, role, model, baseUrl, timeoutMs, elapsedMs, err) {
+  const consecutiveFailures = (llmFailureStreaks.get(label) ?? 0) + 1;
+  llmFailureStreaks.set(label, consecutiveFailures);
+  logger.warn("LLM call failed \u2014 using non-LLM fallback", {
+    label,
+    role,
+    model,
+    provider: resolveProviderIdForLogging(baseUrl),
+    timeoutMs,
+    elapsedMs,
+    timedOut: _isAbortOrTimeoutError(err),
+    error: err,
+    consecutiveFailures
+  });
+  return consecutiveFailures;
+}
+function recordLlmSuccess(label, model) {
+  const priorFailures = llmFailureStreaks.get(label) ?? 0;
+  if (priorFailures > 0) {
+    logger.info("LLM call recovered", { label, model, afterFailures: priorFailures });
+  }
+  llmFailureStreaks.set(label, 0);
+}
+async function llmComplete(prompt, opts) {
   if (!isLlmEnabled()) {
     return { ok: false, error: "llm disabled" };
   }
   const llm = getLlmConfig({ modelRole: opts.modelRole });
+  const role = opts.modelRole ?? "instruct";
   const timeoutMs = opts.timeoutMs ?? llm.timeoutMs;
+  const startedAt = Date.now();
   try {
     const result = await generateText({
       model: buildProvider(llm),
@@ -52675,14 +53003,17 @@ async function llmComplete(prompt, opts = {}) {
       abortSignal: timeoutSignal(timeoutMs)
     });
     const text2 = result.text ?? "";
-    if (text2.length > 0)
+    if (text2.length > 0) {
+      recordLlmSuccess(opts.label, llm.model);
       return { ok: true, value: text2 };
+    }
     if (llm.disableThink) {
       const reasoning = _reasoningToText(result);
       if (reasoning.length > 0) {
         logger.warn("llmComplete: empty content \u2014 recovered from reasoning channel", {
           reasoningLen: reasoning.length
         });
+        recordLlmSuccess(opts.label, llm.model);
         return { ok: true, value: reasoning };
       }
       logger.warn("llm reasoning-recovery empty", {
@@ -52690,21 +53021,22 @@ async function llmComplete(prompt, opts = {}) {
         finishReason: result?.finishReason ?? null
       });
     }
-    logger.warn("llmComplete: empty content and no reasoning \u2014 degrading", {});
-    return { ok: false, error: "empty content (thinking model)" };
+    const emptyErr = new Error("empty content (thinking model)");
+    recordLlmFailure(opts.label, role, llm.model, llm.baseUrl, timeoutMs, Date.now() - startedAt, emptyErr);
+    return { ok: false, error: emptyErr.message };
   } catch (e) {
-    logger.warn("llmComplete failed \u2014 degrading to non-LLM path", {
-      error: e.message
-    });
+    recordLlmFailure(opts.label, role, llm.model, llm.baseUrl, timeoutMs, Date.now() - startedAt, e);
     return { ok: false, error: e.message };
   }
 }
-async function llmObject(prompt, schema, opts = {}) {
+async function llmObject(prompt, schema, opts) {
   if (!isLlmEnabled()) {
     return { ok: false, error: "llm disabled" };
   }
   const llm = getLlmConfig({ modelRole: opts.modelRole });
+  const role = opts.modelRole ?? "instruct";
   const timeoutMs = opts.timeoutMs ?? llm.timeoutMs;
+  const startedAt = Date.now();
   let result = null;
   try {
     const useJsonSchema = llm.disableThink && await _checkJsonSchemaSupport();
@@ -52719,7 +53051,8 @@ async function llmObject(prompt, schema, opts = {}) {
         maxOutputTokens: llm.maxOutputTokens,
         abortSignal: timeoutSignal(timeoutMs)
       });
-      logger.info("json_schema: constrained decoding used", {});
+      logger.debug("json_schema: constrained decoding used", { label: opts.label, model: llm.model });
+      recordLlmSuccess(opts.label, llm.model);
       return { ok: true, value: result.object };
     }
     result = await generateObject({
@@ -52733,7 +53066,8 @@ async function llmObject(prompt, schema, opts = {}) {
     });
     const validated = schema.safeParse(result.object);
     if (validated.success) {
-      logger.info("json_schema: fallback to json_object \u2014 validated", {});
+      logger.debug("json_schema: fallback to json_object \u2014 validated", { label: opts.label, model: llm.model });
+      recordLlmSuccess(opts.label, llm.model);
       return { ok: true, value: validated.data };
     }
     if (llm.disableThink) {
@@ -52746,15 +53080,17 @@ async function llmObject(prompt, schema, opts = {}) {
             logger.warn("llmObject: recovered object from reasoning channel (fallback path)", {
               reasoningLen: reasoning.length
             });
+            recordLlmSuccess(opts.label, llm.model);
             return { ok: true, value: recovered.data };
           }
         }
       }
     }
-    logger.warn("llmObject: fallback validation failed", {
-      zodError: validated.error.issues.map((i) => i.message).join("; ")
+    const validationErr = new Error("schema validation failed (fallback path)", {
+      cause: summarizeZodIssues(validated.error)
     });
-    return { ok: false, error: "schema validation failed (fallback path)" };
+    recordLlmFailure(opts.label, role, llm.model, llm.baseUrl, timeoutMs, Date.now() - startedAt, validationErr);
+    return { ok: false, error: validationErr.message };
   } catch (e) {
     if (llm.disableThink && !_isAbortOrTimeoutError(e)) {
       const reasoning = _reasoningToText(result).length > 0 ? _reasoningToText(result) : _reasoningToText(e);
@@ -52766,6 +53102,7 @@ async function llmObject(prompt, schema, opts = {}) {
             logger.warn("llmObject: recovered object from reasoning channel", {
               reasoningLen: reasoning.length
             });
+            recordLlmSuccess(opts.label, llm.model);
             return { ok: true, value: validated.data };
           }
         }
@@ -52775,19 +53112,18 @@ async function llmObject(prompt, schema, opts = {}) {
         finishReason: e?.finishReason ?? null
       });
     }
-    logger.warn("llmObject failed \u2014 degrading to non-LLM path", {
-      error: e.message
-    });
+    recordLlmFailure(opts.label, role, llm.model, llm.baseUrl, timeoutMs, Date.now() - startedAt, e);
     return { ok: false, error: e.message };
   }
 }
-var _jsonSchemaSupported = null, testEnabledOverride = null, testBaseUrlOverride = null, llm;
+var _jsonSchemaSupported = null, testEnabledOverride = null, testBaseUrlOverride = null, llmFailureStreaks, llm;
 var init_llm_client = __esm(() => {
   init_dist6();
   init_dist7();
   init_dist();
   init_config();
   init_inference_providers();
+  llmFailureStreaks = new Map;
   llm = {
     complete: llmComplete,
     object: llmObject,
@@ -61800,7 +62136,7 @@ class MetricsCollector2 {
     try {
       writeFileSync(this.metricsPath, JSON.stringify(this.currentMetrics, null, 2));
     } catch (error51) {
-      logger.error("[Metrics] Failed to save:", error51);
+      logger.error("Metrics: failed to save", error51, { path: this.metricsPath });
     }
   }
   reset() {
@@ -61975,7 +62311,8 @@ class EmbeddingRateLimiter {
         }
       }
       if (this.config.requestsPerDay && this.dailyRequestsWindow.length >= this.config.requestsPerDay) {
-        logger.warn(`[${this.providerId}] RPD limit reached, waiting 60s`, {
+        logger.warn("EmbeddingRateLimiter: RPD limit reached, waiting 60s", {
+          providerId: this.providerId,
           rpd: this.config.requestsPerDay,
           current: this.dailyRequestsWindow.length
         });
@@ -64621,26 +64958,26 @@ var require_process = __commonJS((exports, module) => {
 
 // ../../node_modules/detect-libc/lib/filesystem.js
 var require_filesystem = __commonJS((exports, module) => {
-  var fs13 = __require("fs");
+  var fs14 = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync2 = (path18) => {
-    const fd = fs13.openSync(path18, "r");
+  var readFileSync2 = (path19) => {
+    const fd = fs14.openSync(path19, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs13.close(fd, () => {});
+    const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs14.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile = (path18) => new Promise((resolve4, reject) => {
-    fs13.open(path18, "r", (err, fd) => {
+  var readFile = (path19) => new Promise((resolve4, reject) => {
+    fs14.open(path19, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
-        fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+        fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
           resolve4(buffer.subarray(0, bytesRead));
-          fs13.close(fd, () => {});
+          fs14.close(fd, () => {});
         });
       }
     });
@@ -64745,11 +65082,11 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     return null;
   };
-  var familyFromInterpreterPath = (path18) => {
-    if (path18) {
-      if (path18.includes("/ld-musl-")) {
+  var familyFromInterpreterPath = (path19) => {
+    if (path19) {
+      if (path19.includes("/ld-musl-")) {
         return MUSL;
-      } else if (path18.includes("/ld-linux-")) {
+      } else if (path19.includes("/ld-linux-")) {
         return GLIBC;
       }
     }
@@ -64794,8 +65131,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = await readFile(SELF_PATH);
-      const path18 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+      const path19 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path19);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -64806,8 +65143,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = readFileSync2(SELF_PATH);
-      const path18 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+      const path19 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path19);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -66469,18 +66806,18 @@ var require_sharp = __commonJS((exports, module) => {
     `@img/sharp-${runtimePlatform}/sharp.node`,
     "@img/sharp-wasm32/sharp.node"
   ];
-  var path18;
+  var path19;
   var sharp;
   var errors4 = [];
-  for (path18 of paths) {
+  for (path19 of paths) {
     try {
-      sharp = __require(path18);
+      sharp = __require(path19);
       break;
     } catch (err) {
       errors4.push(err);
     }
   }
-  if (sharp && path18.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+  if (sharp && path19.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
     const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
     err.code = "Unsupported CPU";
     errors4.push(err);
@@ -66489,7 +66826,7 @@ var require_sharp = __commonJS((exports, module) => {
   if (sharp) {
     module.exports = sharp;
   } else {
-    const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os8) => runtimePlatform.startsWith(os8));
+    const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os9) => runtimePlatform.startsWith(os9));
     const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
     errors4.forEach((err) => {
       if (err.code !== "MODULE_NOT_FOUND") {
@@ -66502,9 +66839,9 @@ var require_sharp = __commonJS((exports, module) => {
       const { found, expected } = isUnsupportedNodeRuntime();
       help.push("- Please upgrade Node.js:", `    Found ${found}`, `    Requires ${expected}`);
     } else if (prebuiltPlatforms.includes(runtimePlatform)) {
-      const [os8, cpu] = runtimePlatform.split("-");
-      const libc = os8.endsWith("musl") ? " --libc=musl" : "";
-      help.push("- Ensure optional dependencies can be installed:", "    npm install --include=optional sharp", "- Ensure your package manager supports multi-platform installation:", "    See https://sharp.pixelplumbing.com/install#cross-platform", "- Add platform-specific dependencies:", `    npm install --os=${os8.replace("musl", "")}${libc} --cpu=${cpu} sharp`);
+      const [os9, cpu] = runtimePlatform.split("-");
+      const libc = os9.endsWith("musl") ? " --libc=musl" : "";
+      help.push("- Ensure optional dependencies can be installed:", "    npm install --include=optional sharp", "- Ensure your package manager supports multi-platform installation:", "    See https://sharp.pixelplumbing.com/install#cross-platform", "- Add platform-specific dependencies:", `    npm install --os=${os9.replace("musl", "")}${libc} --cpu=${cpu} sharp`);
     } else {
       help.push(`- Manually install libvips >= ${minimumLibvipsVersion}`, "- Add experimental WebAssembly-based dependencies:", "    npm install --cpu=wasm32 sharp", "    npm install @img/sharp-wasm32");
     }
@@ -69342,15 +69679,15 @@ var require_color = __commonJS((exports, module) => {
     };
   }
   function wrapConversion(toModel, graph) {
-    const path18 = [graph[toModel].parent, toModel];
+    const path19 = [graph[toModel].parent, toModel];
     let fn = conversions_default[graph[toModel].parent][toModel];
     let cur = graph[toModel].parent;
     while (graph[cur].parent) {
-      path18.unshift(graph[cur].parent);
+      path19.unshift(graph[cur].parent);
       fn = link(conversions_default[graph[cur].parent][cur], fn);
       cur = graph[cur].parent;
     }
-    fn.conversion = path18;
+    fn.conversion = path19;
     return fn;
   }
   function route(fromModel) {
@@ -69955,7 +70292,7 @@ var require_output = __commonJS((exports, module) => {
     Copyright 2013 Lovell Fuller and others.
     SPDX-License-Identifier: Apache-2.0
   */
-  var path18 = __require("path");
+  var path19 = __require("path");
   var is = require_is();
   var sharp = require_sharp();
   var formats = new Map([
@@ -69986,9 +70323,9 @@ var require_output = __commonJS((exports, module) => {
     let err;
     if (!is.string(fileOut)) {
       err = new Error("Missing output file path");
-    } else if (is.string(this.options.input.file) && path18.resolve(this.options.input.file) === path18.resolve(fileOut)) {
+    } else if (is.string(this.options.input.file) && path19.resolve(this.options.input.file) === path19.resolve(fileOut)) {
       err = new Error("Cannot use same file for input and output");
-    } else if (jp2Regex.test(path18.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+    } else if (jp2Regex.test(path19.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
       err = errJp2Save();
     }
     if (err) {
@@ -77235,11 +77572,11 @@ var init_transformers_node = __esm(() => {
             throw new Error(`The number of external data chunks (${num_chunks}) exceeds the maximum allowed value (${_utils_hub_js__WEBPACK_IMPORTED_MODULE_5__.MAX_EXTERNAL_DATA_CHUNKS}).`);
           }
           for (let i = 0;i < num_chunks; ++i) {
-            const path18 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
-            const fullPath = `${options.subfolder ?? ""}/${path18}`;
+            const path19 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+            const fullPath = `${options.subfolder ?? ""}/${path19}`;
             externalDataPromises.push(new Promise(async (resolve4, reject) => {
               const data = await (0, _utils_hub_js__WEBPACK_IMPORTED_MODULE_5__.getModelFile)(pretrained_model_name_or_path, fullPath, true, options, return_path);
-              resolve4(data instanceof Uint8Array ? { path: path18, data } : path18);
+              resolve4(data instanceof Uint8Array ? { path: path19, data } : path19);
             }));
           }
         } else if (session_options.externalData !== undefined) {
@@ -90303,7 +90640,7 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           const blob = new Blob([wav], { type: "audio/wav" });
           return blob;
         }
-        async save(path18) {
+        async save(path19) {
           let fn;
           if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_BROWSER_ENV) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_WEBWORKER_ENV) {
@@ -90311,14 +90648,14 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
             }
             fn = _core_js__WEBPACK_IMPORTED_MODULE_2__.saveBlob;
           } else if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_FS_AVAILABLE) {
-            fn = async (path19, blob) => {
+            fn = async (path20, blob) => {
               let buffer = await blob.arrayBuffer();
-              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path19, Buffer.from(buffer));
+              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path20, Buffer.from(buffer));
             };
           } else {
             throw new Error("Unable to save because filesystem is disabled in this environment.");
           }
-          await fn(path18, this.toBlob());
+          await fn(path19, this.toBlob());
         }
       }
     },
@@ -90414,11 +90751,11 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       function calculateReflectOffset(i, w) {
         return Math.abs((i + w) % (2 * w) - w);
       }
-      function saveBlob(path18, blob) {
+      function saveBlob(path19, blob) {
         const dataURL = URL.createObjectURL(blob);
         const downloadLink = document.createElement("a");
         downloadLink.href = dataURL;
-        downloadLink.download = path18;
+        downloadLink.download = path19;
         downloadLink.click();
         downloadLink.remove();
         URL.revokeObjectURL(dataURL);
@@ -91019,8 +91356,8 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       }
 
       class FileCache {
-        constructor(path18) {
-          this.path = path18;
+        constructor(path19) {
+          this.path = path19;
         }
         async match(request) {
           let filePath = node_path__WEBPACK_IMPORTED_MODULE_1__["default"].join(this.path, request);
@@ -91776,20 +92113,20 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           }
           return this;
         }
-        async save(path18) {
+        async save(path19) {
           if (IS_BROWSER_OR_WEBWORKER) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_2__.apis.IS_WEBWORKER_ENV) {
               throw new Error("Unable to save an image from a Web Worker.");
             }
-            const extension = path18.split(".").pop().toLowerCase();
+            const extension = path19.split(".").pop().toLowerCase();
             const mime = CONTENT_TYPE_MAP.get(extension) ?? "image/png";
             const blob = await this.toBlob(mime);
-            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path18, blob);
+            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path19, blob);
           } else if (!_env_js__WEBPACK_IMPORTED_MODULE_2__.apis.IS_FS_AVAILABLE) {
             throw new Error("Unable to save the image because filesystem is disabled in this environment.");
           } else {
             const img = this.toSharp();
-            return await img.toFile(path18);
+            return await img.toFile(path19);
           }
         }
         toSharp() {
@@ -95278,16 +95615,16 @@ class LocalTransformersEmbeddingProvider {
       const out = await extractor("test", { pooling: "mean", normalize: true });
       const vec = Array.from(out.data);
       if (!Array.isArray(vec) || vec.length !== this.dimensions) {
-        logger.error(`[${this.id}] Invalid embedding dimensions`, undefined, { expected: this.dimensions, got: vec.length });
+        logger.error("LocalTransformersProvider: invalid embedding dimensions", undefined, { providerId: this.id, expected: this.dimensions, got: vec.length });
         return false;
       }
       if (vec.some((v) => typeof v !== "number" || isNaN(v))) {
-        logger.error(`[${this.id}] Invalid embedding values (not numbers)`);
+        logger.error("LocalTransformersProvider: invalid embedding values (not numbers)", undefined, { providerId: this.id });
         return false;
       }
       return true;
     } catch (error51) {
-      logger.error(`[${this.id}] Local provider unavailable`, error51);
+      logger.error("LocalTransformersProvider: provider unavailable", error51, { providerId: this.id });
       return false;
     }
   }
@@ -95327,7 +95664,13 @@ async function withRetry(fn, config3, context2) {
       lastError2 = error51;
       if (attempt < config3.maxRetries) {
         const delay2 = getRetryDelay(attempt, config3);
-        logger.warn(`[EmbeddingProvider] ${context2} failed (attempt ${attempt + 1}/${config3.maxRetries + 1}), retrying in ${delay2}ms`, { error: lastError2.message });
+        logger.warn("EmbeddingProvider: operation failed, retrying", {
+          context: context2,
+          attempt: attempt + 1,
+          maxAttempts: config3.maxRetries + 1,
+          delayMs: delay2,
+          error: lastError2
+        });
         await sleep(delay2);
       }
     }
@@ -95643,7 +95986,7 @@ var init_provider = __esm(() => {
             return output;
           }, this.retryConfig, `[${this.id}] embedBatchDirect (${texts.length} texts)`), this.timeout, `[${this.id}] embedBatchDirect`);
         } catch (error51) {
-          logger.warn(`[${this.id}] Ollama batch endpoint unavailable, falling back to sequential embeds: ${error51.message}`);
+          logger.warn("EmbeddingProvider: Ollama batch endpoint unavailable, falling back to sequential embeds", { providerId: this.id, textCount: texts.length, error: error51 });
           const embeddings = [];
           let consecutiveFailures = 0;
           for (const text2 of texts) {
@@ -95682,11 +96025,11 @@ var init_provider = __esm(() => {
             });
             clearTimeout(timeoutId);
             if (!response.ok) {
-              logger.error(`[${this.id}] Ollama API returned ${response.status}`);
+              logger.error("EmbeddingProvider: Ollama API returned non-OK status", undefined, { providerId: this.id, status: response.status });
               return false;
             }
           } catch {
-            logger.error(`[${this.id}] Ollama service unreachable`, undefined, { baseURL: this.baseURL, timeoutMs: 2000 });
+            logger.error("EmbeddingProvider: Ollama service unreachable", undefined, { providerId: this.id, baseURL: this.baseURL, timeoutMs: 2000 });
             return false;
           }
         }
@@ -95696,16 +96039,16 @@ var init_provider = __esm(() => {
           if (Array.isArray(embedding)) {
             this.lastDimensionMismatch = new DimensionMismatchError(this.id, this.dimensions, embedding.length);
           }
-          logger.error(`[${this.id}] Invalid embedding dimensions`, undefined, { expected: this.dimensions, got: embedding.length });
+          logger.error("EmbeddingProvider: invalid embedding dimensions", undefined, { providerId: this.id, expected: this.dimensions, got: embedding.length });
           return false;
         }
         if (!embedding.every((v) => typeof v === "number" && !isNaN(v))) {
-          logger.error(`[${this.id}] Invalid embedding values (not numbers)`);
+          logger.error("EmbeddingProvider: invalid embedding values (not numbers)", undefined, { providerId: this.id });
           return false;
         }
         return true;
       } catch (error51) {
-        logger.error(`[${this.id}] Provider unavailable`, error51);
+        logger.error("EmbeddingProvider: provider unavailable", error51, { providerId: this.id });
         return false;
       }
     }
@@ -101018,7 +101361,7 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a;
   function ns(e = Yo, t = Yo) {
     return (r) => e(t(r));
   }
-  function os8({ dataPath: e, modelName: t, args: r, runtimeDataModel: n }) {
+  function os9({ dataPath: e, modelName: t, args: r, runtimeDataModel: n }) {
     let i = { modelName: t, args: r ?? {} }, o = dp(e);
     if (!o || o.length === 0)
       return i;
@@ -101323,10 +101666,10 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a;
       super(t, "P2023", r);
     }
   };
-  var fs13 = new WeakMap;
+  var fs14 = new WeakMap;
   function Ep(e) {
-    let t = fs13.get(e);
-    return t || (t = Object.entries(e), fs13.set(e, t)), t;
+    let t = fs14.get(e);
+    return t || (t = Object.entries(e), fs14.set(e, t)), t;
   }
   function hs(e, t, r) {
     switch (t.type) {
@@ -104891,7 +105234,7 @@ new PrismaClient({
           let m = await es(this, d);
           if (!d.model)
             return m;
-          let g = os8({ dataPath: d.dataPath, modelName: d.model, args: d.args, runtimeDataModel: this._runtimeDataModel });
+          let g = os9({ dataPath: d.dataPath, modelName: d.model, args: d.args, runtimeDataModel: this._runtimeDataModel });
           return Wo({ result: m, modelName: g.modelName, args: g.args, extensions: this._extensions, runtimeDataModel: this._runtimeDataModel, globalOmit: this._globalOmit });
         };
         return this._tracingHelper.runInChildSpan(s.operation, () => new zl.AsyncResource("prisma-client-request").runInAsyncScope(() => a(o)));
@@ -105294,7 +105637,7 @@ var require_prisma = __commonJS((exports) => {
   Prisma.JsonNull = JsonNull2;
   Prisma.AnyNull = AnyNull2;
   Prisma.NullTypes = NullTypes2;
-  var path18 = __require("path");
+  var path19 = __require("path");
   exports.Prisma.TransactionIsolationLevel = makeStrictEnum2({
     ReadUncommitted: "ReadUncommitted",
     ReadCommitted: "ReadCommitted",
@@ -107921,7 +108264,7 @@ function getPrismaClient2() {
     const pg2 = _adapters.loadPg();
     const { PrismaPg: PrismaPg2 } = _adapters.loadPrismaPg();
     const pool = new pg2.Pool({ connectionString: databaseUrl, max: 10, idleTimeoutMillis: 30000, connectionTimeoutMillis: 5000 });
-    pool.on("error", (error51) => logger.error("Unexpected PG pool error", error51));
+    pool.on("error", (error51) => logger.error("prisma-client: unexpected PG pool error", error51, { poolMax: 10 }));
     prismaPool = pool;
     prismaInstance = new import_prisma.PrismaClient({ adapter: new PrismaPg2(pool) });
     logger.info("Prisma Client initialized with PostgreSQL");
@@ -108230,7 +108573,10 @@ var init_config2 = __esm(() => {
     "local"
   ]);
   if (!SELECTABLE_PROVIDERS.has(selectedProvider)) {
-    logger.warn(`[EmbeddingConfig] selected provider "${selectedProvider}" has no runtime entry \u2014 falling back to priority order`, { source: process.env.EMBEDDING_PROVIDER ? "EMBEDDING_PROVIDER env" : "config.json embedding.provider" });
+    logger.warn("EmbeddingConfig: selected provider has no runtime entry, falling back to priority order", {
+      selectedProvider,
+      source: process.env.EMBEDDING_PROVIDER ? "EMBEDDING_PROVIDER env" : "config.json embedding.provider"
+    });
   }
   embeddingProviders = {
     google: (() => {
@@ -108270,7 +108616,12 @@ var init_config2 = __esm(() => {
       const envDimensions = Number.isInteger(rawEnvDimensions) && rawEnvDimensions > 0 ? rawEnvDimensions : undefined;
       const resolvedDimensions = resolveEmbeddingDimensions(model, file2?.dimensions, envDimensions);
       if (resolvedDimensions.correctedFrom !== undefined) {
-        logger.warn(`[ollama] config.json records embedding.dimensions ${resolvedDimensions.correctedFrom} for model ` + `"${model}", which emits ${resolvedDimensions.dimensions}. Using ${resolvedDimensions.dimensions}. ` + "Update embedding.dimensions in config.json (or set OLLAMA_EMBEDDING_DIMENSIONS) to silence this.");
+        logger.warn("EmbeddingConfig: ollama config.json dimensions mismatch corrected", {
+          provider: "ollama",
+          model,
+          configuredDimensions: resolvedDimensions.correctedFrom,
+          correctedDimensions: resolvedDimensions.dimensions
+        });
       }
       return {
         provider: "ollama",
@@ -108422,8 +108773,8 @@ class EmbeddingService {
         dimensions: this.provider.dimensions
       });
     } catch (error51) {
-      logger.error("Failed to initialize embedding service", error51);
-      logger.warn("Embedding service will use fallback mode");
+      logger.error("Failed to initialize embedding service", error51, { stage: "initialize" });
+      logger.warn("Embedding service will use fallback mode", { stage: "initialize" });
     }
   }
   async ensureInitialized() {
@@ -108505,7 +108856,7 @@ async function tryCreateProvider(config3, providerId, skipHealthCheck) {
   return { provider };
 }
 function refuseOnDimensionMismatch(providerId, mismatch) {
-  logger.error(`[${providerId}] Configured embedding provider failed with a dimension mismatch \u2014 refusing to ` + `fall through to another provider (that would silently degrade retrieval quality). ` + `configured dimensions ${mismatch.expected} \u2260 model output ${mismatch.got} \u2014 fix ` + "`embedding.dimensions` in config.json or OLLAMA_EMBEDDING_DIMENSIONS to match the model actually pulled.");
+  logger.error("EmbeddingProvider: configured provider failed with a dimension mismatch, refusing to fall through", mismatch, { providerId, configuredDimensions: mismatch.expected, modelDimensions: mismatch.got });
   throw mismatch;
 }
 async function createEmbeddingProvider(options = {}) {
@@ -108604,6 +108955,7 @@ Write the hypothetical implementation paragraph.`;
 }
 async function rewriteQuery(query, surface, opts = {}) {
   const res = await surface.object(rewritePrompt(query), QueryRewriteSchema, {
+    label: "query-rewrite",
     system: REWRITE_SYSTEM,
     timeoutMs: opts.timeoutMs
   });
@@ -108616,6 +108968,7 @@ async function rewriteQuery(query, surface, opts = {}) {
 }
 async function hyde(query, surface, embedFn, opts = {}) {
   const text2 = await surface.complete(hydePrompt(query), {
+    label: "hyde",
     system: HYDE_SYSTEM,
     timeoutMs: opts.timeoutMs
   });
@@ -108629,7 +108982,7 @@ async function hyde(query, surface, embedFn, opts = {}) {
     return vec;
   } catch (e) {
     logger.warn("hyde embed failed \u2014 skipping HyDE stream", {
-      error: e.message
+      error: e
     });
     return null;
   }
@@ -110357,7 +110710,7 @@ class KeywordSearchPg {
       `);
       this.trigramAvailable = true;
     } catch (error51) {
-      logger.warn("pg_trgm unavailable \u2014 trigram RRF stream disabled on PG", { err: error51.message });
+      logger.warn("pg_trgm unavailable \u2014 trigram RRF stream disabled on PG", { error: error51 });
       this.trigramAvailable = false;
     }
     logger.info("PostgreSQL keyword search initialized", {
@@ -110896,7 +111249,8 @@ var init_postgres_vector_store = __esm(() => {
         this.schemaDimensions = providerDimensions;
         const { rows } = await client.query(`SELECT tablename FROM pg_tables WHERE tablename = $1`, [this.tableName]);
         if (rows.length === 0) {
-          logger.warn(`Table ${this.tableName} not found. Creating fallback table.`, {
+          logger.warn("PostgresVectorStore: table not found, creating fallback table", {
+            tableName: this.tableName,
             note: 'Run "prisma migrate deploy" to create tables via migrations'
           });
           await this.createFallbackTable(client, providerDimensions);
@@ -110933,10 +111287,12 @@ var init_postgres_vector_store = __esm(() => {
           if (projects.length === 0)
             continue;
           const otherDim = tablename.match(/_([0-9]+)d$/)?.[1];
-          logger.warn(`[vector] Orphaned chunks detected: ${tablename} has data for projects not in ${this.tableName}. Embedding model likely changed from ${otherDim}d \u2192 ${currentDim}d. Reindex required.`, {
+          logger.warn("PostgresVectorStore: orphaned chunks detected, embedding model likely changed, reindex required", {
             currentTable: this.tableName,
             currentCount,
+            currentDim,
             orphanedTable: tablename,
+            orphanedDim: otherDim,
             affectedProjects: projects.map((p) => ({ projectId: p.project_id, chunks: p.n }))
           });
         }
@@ -111080,7 +111436,7 @@ var init_postgres_vector_store = __esm(() => {
           logger.warn("[postgres] Sub-batch embedding failed, falling back per-document", {
             subBatchIndex: Math.floor(i / EMBED_SUB_BATCH_SIZE),
             count: subBatch.length,
-            error: error51.message
+            error: error51
           });
         }
         if (embeddings) {
@@ -111092,7 +111448,7 @@ var init_postgres_vector_store = __esm(() => {
             logger.warn("[postgres] Sub-batch insert failed, falling back per-document", {
               subBatchIndex: Math.floor(i / EMBED_SUB_BATCH_SIZE),
               count: subBatch.length,
-              error: error51.message
+              error: error51
             });
           }
         }
@@ -111105,7 +111461,7 @@ var init_postgres_vector_store = __esm(() => {
             totalFailed++;
             logger.warn("[postgres] Skipping document due to embedding/insert error", {
               id: doc2.id,
-              error: singleError.message
+              error: singleError
             });
           }
         }
@@ -111777,7 +112133,9 @@ class SearchAnalyticsPg {
   }
   trackSearch(event) {
     this.trackSearchAsync(event).catch((err) => {
-      logger.error("Failed to track search event", err);
+      logger.error("Failed to track search event", err, {
+        projectId: event.projectId
+      });
     });
   }
   async trackSearchAsync(event) {
@@ -111802,7 +112160,9 @@ class SearchAnalyticsPg {
         event.score || null
       ]);
     } catch (error51) {
-      logger.error("Failed to track search event in PostgreSQL", error51);
+      logger.error("Failed to track search event in PostgreSQL", error51, {
+        projectId: event.projectId
+      });
     }
   }
   async recordQuery(query, projectId, resultsCount = 0, duration3 = 0, cacheHit = false) {
@@ -114403,7 +114763,11 @@ class GraphStorePg {
       `;
       return rows[0] ? rowToEdge(rows[0]) : null;
     } catch (error51) {
-      logger.error("Failed to create edge", error51);
+      logger.error("Failed to create edge", error51, {
+        sourceId: edge.sourceId,
+        targetId: edge.targetId,
+        relationType: edge.relationType
+      });
       return null;
     }
   }
@@ -114999,7 +115363,7 @@ class PgSynapseSessionStore {
       } catch (e) {
         this.hydrateFailedAt = Date.now();
         logger.warn("PgSynapseSessionStore hydrate failed (best-effort)", {
-          error: e.message
+          error: e
         });
       } finally {
         this.hydrating = null;
@@ -115134,7 +115498,7 @@ class PgSynapseSessionStore {
     const next = prev.then(fn).catch((e) => {
       logger.warn("PgSynapseSessionStore write failed (best-effort)", {
         key,
-        error: e.message
+        error: e
       });
     });
     this.inflight.set(key, next);
@@ -115240,7 +115604,7 @@ class SessionRegistry {
     try {
       this.store?.save(session);
     } catch (error51) {
-      logger.warn("[SessionRegistry] store save failed:", { error: error51.message });
+      logger.warn("SessionRegistry: store save failed", { sessionId: session.sessionId, error: error51 });
     }
     return session;
   }
@@ -115248,7 +115612,7 @@ class SessionRegistry {
     try {
       await this.store?.ensureReady();
     } catch (error51) {
-      logger.warn("[SessionRegistry] store ensureReady failed:", { error: error51.message });
+      logger.warn("SessionRegistry: store ensureReady failed", { error: error51 });
     }
   }
   async getAsync(sessionId, now2 = Date.now()) {
@@ -115269,7 +115633,7 @@ class SessionRegistry {
           session = loaded;
         }
       } catch (error51) {
-        logger.warn("[SessionRegistry] store load failed:", { error: error51.message });
+        logger.warn("SessionRegistry: store load failed", { sessionId, error: error51 });
       }
     }
     if (!session)
@@ -115279,7 +115643,7 @@ class SessionRegistry {
       try {
         this.store?.delete(sessionId);
       } catch (error51) {
-        logger.warn("[SessionRegistry] store delete (expired) failed:", { error: error51.message });
+        logger.warn("SessionRegistry: store delete (expired) failed", { sessionId, error: error51 });
       }
       return null;
     }
@@ -115301,7 +115665,7 @@ class SessionRegistry {
     try {
       this.store?.save(session);
     } catch (error51) {
-      logger.warn("[SessionRegistry] store save (updateTaskContext) failed:", { error: error51.message });
+      logger.warn("SessionRegistry: store save (updateTaskContext) failed", { sessionId, error: error51 });
     }
     return session;
   }
@@ -115328,7 +115692,7 @@ class SessionRegistry {
     try {
       this.store?.recordAccess(sessionId, memoryId, nextCount);
     } catch (error51) {
-      logger.warn("[SessionRegistry] store recordAccess failed:", { error: error51.message });
+      logger.warn("SessionRegistry: store recordAccess failed", { sessionId, memoryId, error: error51 });
     }
   }
   delete(sessionId) {
@@ -115336,7 +115700,7 @@ class SessionRegistry {
     try {
       this.store?.delete(sessionId);
     } catch (error51) {
-      logger.warn("[SessionRegistry] store delete failed:", { error: error51.message });
+      logger.warn("SessionRegistry: store delete failed", { sessionId, error: error51 });
     }
     return removed;
   }
@@ -115364,7 +115728,7 @@ function getSessionRegistry() {
       const { getSessionStore: getSessionStore2 } = (init_session_store(), __toCommonJS(exports_session_store));
       store2 = getSessionStore2();
     } catch (error51) {
-      logger.warn("[SessionRegistry] store init failed, falling back to MemorySessionStore:", { error: error51.message });
+      logger.warn("SessionRegistry: store init failed, falling back to MemorySessionStore", { error: error51 });
       const { MemorySessionStore: MemorySessionStore2 } = (init_session_store(), __toCommonJS(exports_session_store));
       store2 = new MemorySessionStore2;
     }
@@ -116181,19 +116545,22 @@ class LLMJudgeReranker {
     const tail = results.slice(k);
     const prompt = buildPrompt(query, head);
     let verdict;
+    let verdictError;
     try {
-      const res = await this.llm.object(prompt, RerankVerdictSchema, { modelRole: "code" });
+      const res = await this.llm.object(prompt, RerankVerdictSchema, { label: "reranker", modelRole: "code" });
       verdict = res.ok ? res.value ?? null : null;
+      verdictError = res.ok ? undefined : res.error;
     } catch (e) {
       logger.warn("LLMJudgeReranker threw \u2014 degrading to input order", {
         query,
-        error: e.message
+        error: e
       });
       return results;
     }
     if (!verdict) {
       logger.warn("LLMJudgeReranker got {ok:false} \u2014 degrading to input order", {
-        query
+        query,
+        error: verdictError
       });
       return results;
     }
@@ -116992,10 +117359,10 @@ var init_chunker_code = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/smart-chunker.js
-import path18 from "path";
+import path19 from "path";
 function smartChunk(content, filePath, config3 = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config3 };
-  const ext2 = path18.extname(filePath).toLowerCase();
+  const ext2 = path19.extname(filePath).toLowerCase();
   const relativePath = filePath;
   const fileImports = isCodeFile(ext2) ? extractFileImports(content, ext2) : undefined;
   let chunks;
@@ -117333,8 +117700,8 @@ var init_embedding_freshness = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/project-indexer.js
-import fs13 from "fs/promises";
-import path19 from "path";
+import fs14 from "fs/promises";
+import path20 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function runWithIndexLock(lockMap, projectId, work) {
   const prevLock = lockMap.get(projectId);
@@ -117377,7 +117744,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
       dot: false
     });
     const filteredFiles = files.filter((file2) => {
-      const relativePath = path19.relative(projectPath, file2);
+      const relativePath = path20.relative(projectPath, file2);
       const shouldIgnore = ig.ignores(relativePath);
       if (shouldIgnore) {
         logger.debug("Ignoring file per .gitignore during indexing", {
@@ -117417,7 +117784,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
         });
       }
     }
-    const indexedFilesList = filteredFiles.map((f) => path19.relative(projectPath, f));
+    const indexedFilesList = filteredFiles.map((f) => path20.relative(projectPath, f));
     await deps.indexManager.updateIndexMetadata(projectId, projectPath, indexedFilesList);
     logger.info("Project indexing completed", {
       projectId,
@@ -117547,7 +117914,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
   let errors4 = 0;
   for (const relativeFilePath of filesToReindex) {
     try {
-      const fullPath = path19.join(projectPath, relativeFilePath);
+      const fullPath = path20.join(projectPath, relativeFilePath);
       const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
       filesIndexed++;
       chunksIndexed += result.chunks;
@@ -117607,8 +117974,8 @@ async function checkSearchAdmission(deps, projectId, projectPath) {
 }
 async function indexFile(deps, filePath, projectId, projectRoot, centralityMap) {
   projectId = await getProjectIdentityAliasResolver().resolve(projectId);
-  const content = await fs13.readFile(filePath, "utf-8");
-  const relativePath = path19.relative(projectRoot, filePath);
+  const content = await fs14.readFile(filePath, "utf-8");
+  const relativePath = path20.relative(projectRoot, filePath);
   const maxFileSize = config.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -117628,7 +117995,7 @@ async function indexFile(deps, filePath, projectId, projectRoot, centralityMap)
       chunkIndex: i,
       totalChunks: chunks.length,
       type: chunk.type,
-      language: path19.extname(filePath).slice(1),
+      language: path20.extname(filePath).slice(1),
       lineStart: chunk.lineStart,
       lineEnd: chunk.lineEnd,
       label: chunk.label,
@@ -118039,7 +118406,7 @@ class TaskEnvelopeService {
         errors4.push("prime");
         logger.warn("synapse_task_begin: prime sub-step failed", {
           sessionId,
-          error: err instanceof Error ? err.message : String(err)
+          error: err
         });
       }
     }
@@ -118062,7 +118429,7 @@ class TaskEnvelopeService {
       errors4.push("search");
       logger.warn("synapse_task_begin: search sub-step failed", {
         sessionId,
-        error: err instanceof Error ? err.message : String(err)
+        error: err
       });
     }
     if (firstHitFile) {
@@ -118085,7 +118452,7 @@ class TaskEnvelopeService {
         errors4.push("prefetch");
         logger.warn("synapse_task_begin: prefetch sub-step failed", {
           sessionId,
-          error: err instanceof Error ? err.message : String(err)
+          error: err
         });
       }
     }
@@ -118096,7 +118463,7 @@ class TaskEnvelopeService {
         errors4.push("access");
         logger.warn("synapse_task_begin: access sub-step failed", {
           sessionId,
-          error: err instanceof Error ? err.message : String(err)
+          error: err
         });
       }
     }
@@ -118439,7 +118806,7 @@ async function applySynapseState(deps, baseResults, query, projectId, sessionId,
     logger.warn("Synapse session lookup failed \u2014 using stateless search", {
       sessionId,
       projectId,
-      error: error51.message
+      error: error51
     });
     return baseResults;
   }
@@ -118460,7 +118827,7 @@ async function applySynapseState(deps, baseResults, query, projectId, sessionId,
     logger.warn("Synapse processing failed \u2014 using stateless search", {
       sessionId,
       projectId,
-      error: error51.message
+      error: error51
     });
     return baseResults;
   }
@@ -119355,7 +119722,7 @@ class RelationExtractor {
     } catch (error51) {
       logger.warn("RelationExtractor: extraction failed", {
         memoryId,
-        error: error51.message
+        error: error51
       });
     }
     return edgesCreated;
@@ -119802,7 +120169,7 @@ class MemoryGraphService {
     } catch (error51) {
       logger.warn("Graph update failed after memory store", {
         memoryId,
-        error: error51.message
+        error: error51
       });
     }
   }
@@ -119818,7 +120185,7 @@ class MemoryGraphService {
     } catch (error51) {
       logger.warn("Graph cleanup failed after memory delete", {
         memoryId,
-        error: error51.message
+        error: error51
       });
     }
   }
@@ -119967,7 +120334,7 @@ async function consolidateWindow(candidates, llm2, opts = {}) {
   if (!llm2.isEnabled())
     return null;
   const prompt = buildPrompt2(window2);
-  const result = await llm2.object(prompt, ConsolidatedBatchSchema);
+  const result = await llm2.object(prompt, ConsolidatedBatchSchema, { label: "memory-consolidation" });
   if (!result.ok || !result.value)
     return null;
   const batch = {
@@ -120068,7 +120435,7 @@ class MemoryConsolidationJob {
     } catch (error51) {
       logger.warn("Memory consolidation skipped", {
         trigger,
-        error: error51.message
+        error: error51
       });
     } finally {
       this.running = false;
@@ -120091,7 +120458,7 @@ class MemoryConsolidationJob {
       candidates = await Promise.resolve(repo.listConsolidationCandidates(staleSinceMs, 500));
     } catch (e) {
       logger.warn("consolidation: candidate list failed (decay)", {
-        error: e.message
+        error: e
       });
       return 0;
     }
@@ -120113,7 +120480,7 @@ class MemoryConsolidationJob {
       } catch (e) {
         logger.warn("consolidation: decay write failed", {
           id: row.id,
-          error: e.message
+          error: e
         });
       }
     }
@@ -120142,14 +120509,14 @@ class MemoryConsolidationJob {
           } catch (e) {
             logger.warn("consolidation: soft-delete failed", {
               id: row.id,
-              error: e.message
+              error: e
             });
           }
         }
       }
     } catch (e) {
       logger.warn("consolidation: prune scan failed", {
-        error: e.message
+        error: e
       });
     }
     return pruned;
@@ -120160,7 +120527,7 @@ class MemoryConsolidationJob {
       candidates = await Promise.resolve(repo.listConsolidationCandidates(staleSinceMs, 200));
     } catch (e) {
       logger.warn("consolidation: candidate list failed (merge)", {
-        error: e.message
+        error: e
       });
       return { merged: 0, batchesCreated: 0 };
     }
@@ -120186,7 +120553,7 @@ class MemoryConsolidationJob {
     } catch (e) {
       logger.warn("consolidation: merge insert failed", {
         batchId: batch.id,
-        error: e.message
+        error: e
       });
       return { merged: 0, batchesCreated: 0 };
     }
@@ -120199,7 +120566,7 @@ class MemoryConsolidationJob {
         logger.warn("consolidation: addSupercedesEdge failed", {
           newId,
           sourceId,
-          error: e.message
+          error: e
         });
       }
     }
@@ -120239,7 +120606,7 @@ class MemoryConsolidationJob {
       return result;
     } catch (e) {
       logger.warn("consolidation: promote (PG) failed", {
-        error: e.message
+        error: e
       });
       return 0;
     }
@@ -120278,19 +120645,22 @@ class SalienceJudge {
     }
     const prompt = buildPrompt3(trimmed, type);
     let verdict;
+    let verdictError;
     try {
-      const res = await this.llm.object(prompt, SalienceSchema);
+      const res = await this.llm.object(prompt, SalienceSchema, { label: "salience-judge" });
       verdict = res.ok ? res.value ?? null : null;
+      verdictError = res.ok ? undefined : res.error;
     } catch (e) {
       logger.warn("SalienceJudge threw \u2014 degrading to neutral default", {
         type,
-        error: e.message
+        error: e
       });
       return { salience: NEUTRAL_SALIENCE, source: "default" };
     }
     if (!verdict) {
       logger.warn("SalienceJudge got {ok:false} \u2014 degrading to neutral default", {
-        type
+        type,
+        error: verdictError
       });
       return { salience: NEUTRAL_SALIENCE, source: "default" };
     }
@@ -120505,7 +120875,8 @@ class MemoryController {
         }
       } catch (err) {
         logger.warn("Graph enrichment failed", {
-          error: err.message
+          projectId,
+          error: err
         });
       }
     }
@@ -120707,7 +121078,7 @@ class CodeCompressor {
             }
             const prompt = buildLlmCompressPrompt(content, language3, targetRatio, preservedElements);
             try {
-              const res = await this.llmCompleteFn(prompt, { timeoutMs, modelRole: "code" });
+              const res = await this.llmCompleteFn(prompt, { label: "code-compressor", timeoutMs, modelRole: "code" });
               if (res.ok && typeof res.value === "string" && res.value.trim().length > 0 && res.value.length <= content.length) {
                 compressed = res.value;
                 compressionSource = "llm";
@@ -120747,7 +121118,10 @@ class CodeCompressor {
       });
       return compressedContent;
     } catch (error51) {
-      logger.error("Code compression failed", error51);
+      logger.error("Code compression failed", error51, {
+        strategy: useStrategy,
+        originalLength: content.length
+      });
       return CompressedContent.identity(content);
     }
   }
@@ -121057,9 +121431,9 @@ class TokenMetrics {
       }
       throw new Error("Model not found in models.dev");
     } catch (error51) {
-      logger.warn("Failed to fetch pricing from models.dev, using fallback", {
+      logger.warn("TokenMetrics: failed to fetch pricing from models.dev, using fallback", {
         modelId,
-        error: error51 instanceof Error ? error51.message : String(error51)
+        error: error51
       });
       const fallback = FALLBACK_PRICING2[modelId] || FALLBACK_PRICING2["gpt-4"];
       this.pricingCache.set(modelId, {
@@ -122179,16 +122553,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path20 = e.route;
-    if (!path20)
+    const path21 = e.route;
+    if (!path21)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path20;
+    const key = method + " " + path21;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path20,
+      path: path21,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -122199,12 +122573,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path20 = parsed?.path ?? d.name;
-    const key = method + " " + path20;
+    const path21 = parsed?.path ?? d.name;
+    const key = method + " " + path21;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path20, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path21, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -122425,8 +122799,8 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path20 from "path";
-import fs14 from "fs/promises";
+import path21 from "path";
+import fs15 from "fs/promises";
 
 class SymbolGraphService {
   identityLookup;
@@ -122597,9 +122971,9 @@ class SymbolGraphService {
       return null;
     const workspace = graphSnapshot.workspace;
     const arch = await this.computeArchitectureMapSafe(graphSnapshot.architecture).catch((err) => {
-      logger.warn("getProjectMap: architecture map failed; skipping", {
+      logger.warn("SymbolGraphService: getProjectMap architecture map failed, skipping", {
         projectId,
-        error: err?.message?.slice(0, 160)
+        error: err
       });
       return null;
     });
@@ -122754,7 +123128,7 @@ class SymbolGraphService {
   async readSnippet(relativePath, lineStart, lineEnd, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs14.readFile(absolutePath, "utf-8");
+      const content = await fs15.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       return lines.slice(Math.max(0, lineStart - 1), Math.min(lines.length, lineEnd)).join(`
@@ -122766,7 +123140,7 @@ class SymbolGraphService {
   async readContext(relativePath, lineNumber, contextLines, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs14.readFile(absolutePath, "utf-8");
+      const content = await fs15.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const start = Math.max(0, lineNumber - contextLines - 1);
@@ -122779,7 +123153,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path20.resolve(root, relativePath) : relativePath;
+    return root ? path21.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -122874,7 +123248,7 @@ class ContextController {
           });
         }
       } catch (err) {
-        logger.warn("Graph prefilter failed", { query, error: err.message });
+        logger.warn("ContextController: graph prefilter failed", { projectId, query, error: err });
       }
     }
     const [searchResult, memories] = await Promise.all([
@@ -123028,9 +123402,11 @@ class ContextController {
       });
       return result.memories;
     } catch (error51) {
-      logger.warn("Memory search failed, continuing without memories", {
-        error: error51.message,
-        query: query.slice(0, 30)
+      logger.warn("ContextController: memory search failed, continuing without memories", {
+        projectId: opts.projectId,
+        sessionId: opts.sessionId,
+        query: query.slice(0, 30),
+        error: error51
       });
       return [];
     }
@@ -123352,7 +123728,7 @@ function warnSandboxUnavailable() {
     return;
   _warnedAboutNoSandbox = true;
   const missingTool = process.platform === "darwin" ? "sandbox-exec" : "docker";
-  logger.warn(`sandbox: MASSA_AI_EXECUTOR_SANDBOX=auto found no '${missingTool}' on this platform, ` + `so code is executing with best-effort containment and no OS-level isolation. ` + `Install '${missingTool}', or set MASSA_AI_EXECUTOR_SANDBOX=on to fail loudly instead of falling back.`, { missingTool, platform: process.platform, effectiveMode: "none" });
+  logger.warn("Sandbox: no sandbox tool found for auto mode, falling back to best-effort containment", { missingTool, platform: process.platform, effectiveMode: "none" });
 }
 function getSandboxMode() {
   const env4 = process.env.MASSA_AI_EXECUTOR_SANDBOX ?? "auto";
@@ -124267,7 +124643,10 @@ class ExecutorController {
         }
       };
     } catch (error51) {
-      logger.error("batch_execute failed", error51);
+      logger.error("batch_execute failed", error51, {
+        commandCount: commands.length,
+        concurrency: effectiveConcurrency
+      });
       return {
         success: false,
         error: `batch_execute failed: ${error51.message}`
@@ -124557,31 +124936,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path21) => {
+    const walk = (fqn, path22) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path21.join("\u2192");
+      const key = path22.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path21.length > 1)
-          chains.push(path21.map((n) => this.fqnToName(n)).join(" \u2192 "));
+        if (path22.length > 1)
+          chains.push(path22.map((n) => this.fqnToName(n)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path21.includes(child)) {
-          const cycled = [...path21, `${this.fqnToName(child)}\u21BA`];
+        if (path22.includes(child)) {
+          const cycled = [...path22, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n) => n).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path21, child]);
+        walk(child, [...path22, child]);
       }
     };
     for (const seed of seeds) {
@@ -126604,9 +126983,9 @@ var init_inference_probe = __esm(() => {
 });
 
 // ../../packages/core/dist/services/health/local-health-checker.js
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path21 from "path";
+import path22 from "path";
 
 class LocalHealthChecker {
   dataDir = config.get("dataDir");
@@ -126684,10 +127063,10 @@ class LocalHealthChecker {
     const start = Date.now();
     try {
       if (!existsSync3(this.dataDir))
-        await fs15.mkdir(this.dataDir, { recursive: true });
-      const probe = path21.join(this.dataDir, ".health-check-test");
-      await fs15.writeFile(probe, "ok");
-      await fs15.unlink(probe);
+        await fs16.mkdir(this.dataDir, { recursive: true });
+      const probe = path22.join(this.dataDir, ".health-check-test");
+      await fs16.writeFile(probe, "ok");
+      await fs16.unlink(probe);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
     } catch (error51) {
       return { available: false, latency: Date.now() - start, error: `Data directory error: ${error51.message}` };
@@ -126823,7 +127202,7 @@ class PgJobStore {
           } catch (e) {
             this.recovered = true;
             logger.warn("PgJobStore markStaleRunningFailed failed (best-effort)", {
-              error: e.message
+              error: e
             });
           }
         }
@@ -126849,7 +127228,7 @@ class PgJobStore {
         logger.info("PgJobStore hydrated", { rows: this.mirror.size });
       } catch (e) {
         logger.warn("PgJobStore hydrate failed (best-effort)", {
-          error: e.message
+          error: e
         });
       } finally {
         this.hydrating = null;
@@ -126872,7 +127251,7 @@ class PgJobStore {
     next.catch((e) => {
       logger.warn("PgJobStore.save failed (best-effort)", {
         jobId: job.jobId,
-        error: e.message
+        error: e
       });
     });
   }
@@ -127004,7 +127383,7 @@ class PgJobStore {
         }
       } catch (e) {
         logger.warn("PgJobStore markStaleRunningFailed failed (best-effort)", {
-          error: e.message
+          error: e
         });
       }
     })();
@@ -127194,7 +127573,13 @@ class IndexJobTracker {
       const stale = hbMs != null && hbMs < cutoff || hbMs == null && startedMs != null && startedMs < cutoff;
       if (!stale)
         continue;
-      logger.warn(`indexJobTracker: reaping stale running job ${job.jobId} (heartbeatAt=${job.heartbeatAt?.toISOString() ?? "n/a"}, startedAt=${job.startedAt?.toISOString() ?? "n/a"}, staleMs=${staleMs})`, { jobId: job.jobId, projectId: job.projectId, staleMs });
+      logger.warn("indexJobTracker: reaping stale running job", {
+        jobId: job.jobId,
+        projectId: job.projectId,
+        staleMs,
+        heartbeatAt: job.heartbeatAt?.toISOString() ?? "n/a",
+        startedAt: job.startedAt?.toISOString() ?? "n/a"
+      });
       this.jobs.set(job.jobId, job);
       const reapedPrevStatus = job.status;
       this.setResult(job.jobId, undefined, "heartbeat stale (possible crash/OOM)");
@@ -127219,7 +127604,7 @@ class IndexJobTracker {
     try {
       this.store?.save(job);
     } catch (err) {
-      logger.warn(`indexJobTracker: job store write failed for ${jobId} on setResult`, { jobId, error: err?.message ?? String(err) });
+      logger.warn("indexJobTracker: job store write failed on setResult", { jobId, error: err });
     }
     if (prevStatus === "pending") {
       this.publishStateChange(job, prevStatus);
@@ -127249,7 +127634,7 @@ class IndexJobTracker {
       const survivors = remaining.slice(0, this.MAX_JOBS);
       const overflow = remaining.slice(this.MAX_JOBS);
       for (const job of overflow) {
-        logger.warn(`indexJobTracker: evicting non-terminal job ${job.jobId} (status=${job.status}) to honor MAX_JOBS cap \u2014 caller may lose visibility`, { jobId: job.jobId, projectId: job.projectId, status: job.status });
+        logger.warn("indexJobTracker: evicting non-terminal job to honor MAX_JOBS cap \u2014 caller may lose visibility", { jobId: job.jobId, projectId: job.projectId, status: job.status });
         this.jobs.delete(job.jobId);
       }
     }
@@ -127486,7 +127871,7 @@ class PgScheduledJobStore {
         logger.info("PgScheduledJobStore hydrated", { rows: this.mirror.size });
       } catch (e) {
         logger.warn("PgScheduledJobStore hydrate failed (best-effort)", {
-          error: e.message
+          error: e
         });
       } finally {
         this.hydrating = null;
@@ -127500,9 +127885,10 @@ class PgScheduledJobStore {
       try {
         await action();
       } catch (e) {
-        logger.warn(`PgScheduledJobStore.${operation} failed (best-effort)`, {
+        logger.warn("PgScheduledJobStore mutation failed (best-effort)", {
           id,
-          error: e.message
+          operation,
+          error: e
         });
       }
     };
@@ -127755,7 +128141,7 @@ class Scheduler {
     this.timer = setInterval(() => {
       this.tick().catch((e) => {
         logger.warn("Scheduler tick failed (swallowed)", {
-          error: e.message
+          error: e
         });
       });
     }, this.tickIntervalMs);
@@ -127870,7 +128256,7 @@ class Scheduler {
         logger.warn("Scheduler: job handler threw (caught)", {
           id: job.id,
           jobKind: job.jobKind,
-          error: errMsg
+          error: e
         });
       } finally {
         if (succeeded) {
@@ -127889,7 +128275,7 @@ class Scheduler {
         } catch (e) {
           logger.warn("Scheduler: persist after fire failed", {
             id: job.id,
-            error: e.message
+            error: e
           });
         }
         this.running.delete(job.jobKind);
@@ -127909,6 +128295,8 @@ class Scheduler {
         enabled: j.enabled,
         nextRunAt: j.nextRunAt,
         lastRunAt: j.lastRunAt,
+        lastSuccessAt: j.lastSuccessAt ?? null,
+        consecutiveFailures: j.consecutiveFailures ?? 0,
         due: j.enabled && j.nextRunAt <= now2,
         currentlyRunning: this.running.has(j.jobKind)
       }))
@@ -128410,7 +128798,7 @@ class PgObservationStore {
       } catch (e) {
         this.hydrateFailedAt = Date.now();
         logger.warn("PgObservationStore hydrate failed (best-effort)", {
-          error: e.message
+          error: e
         });
       } finally {
         this.hydrating = null;
@@ -128461,7 +128849,7 @@ class PgObservationStore {
     const next = prev.then(fn).catch((e) => {
       logger.warn("PgObservationStore.insert failed (best-effort)", {
         id: key,
-        error: e.message
+        error: e
       });
     });
     this.inflight.set(key, next);
@@ -128775,7 +129163,7 @@ async function enrichWithLlm(candidates, observations, surface) {
   const prompt = buildEnrichmentPrompt(candidates, observations);
   let enrichment = null;
   try {
-    const res = await surface.object(prompt, ProposalEnrichmentSchema);
+    const res = await surface.object(prompt, ProposalEnrichmentSchema, { label: "auto-improve" });
     if (!res.ok || !res.value || !Array.isArray(res.value.items)) {
       return { candidates, used: false };
     }
@@ -128971,7 +129359,7 @@ async function runOnce(job, projectId) {
   try {
     observations = job.observationStore.listRecent(projectId, job.maxWindow);
   } catch (e) {
-    logger.warn("auto-improve: listRecent failed", { projectId, error: e.message });
+    logger.warn("auto-improve: listRecent failed", { projectId, error: e });
     return noop2;
   }
   if (observations.length < 2)
@@ -128986,7 +129374,7 @@ async function runOnce(job, projectId) {
     if (res.used)
       source = "llm";
   } catch (e) {
-    logger.warn("auto-improve: enrichWithLlm threw (silent)", { projectId, error: e.message });
+    logger.warn("auto-improve: enrichWithLlm threw (silent)", { projectId, error: e });
   }
   const seen = new Set;
   const unique = candidates.filter((c) => {
@@ -129034,7 +129422,7 @@ async function runOnce(job, projectId) {
       } catch (e) {
         if (e instanceof SearchServiceError)
           throw e;
-        logger.warn("proposal:auto-approved:threw", { id: r.id, projectId, error: e.message });
+        logger.warn("proposal:auto-approved:threw", { id: r.id, projectId, error: e });
       }
     }
     result.proposalsApplied = applied;
@@ -129063,7 +129451,7 @@ async function approve(job, id, projectId, source = "rule-based") {
     appliedMemoryId = await applyProposal(job, row);
   } catch (e) {
     const reason = e instanceof ApplyRejection ? e.reason : "apply-failed";
-    logger.warn("proposal:apply-failed", { id, projectId: row.projectId, reason, error: e.message });
+    logger.warn("proposal:apply-failed", { id, projectId: row.projectId, reason, error: e });
     return { ok: false, reason };
   }
   let updated;
@@ -129198,9 +129586,9 @@ class AutoImproveJob {
         return;
       this.newSinceRun = 0;
       this.lastRunAt = now2;
-      this.runOnce(projectId).catch((e) => logger.warn("auto-improve: runOnce failed (silent)", { projectId, error: e.message }));
+      this.runOnce(projectId).catch((e) => logger.warn("auto-improve: runOnce failed (silent)", { projectId, error: e }));
     } catch (e) {
-      logger.warn("auto-improve: maybeRun swallowed", { projectId, error: e.message });
+      logger.warn("auto-improve: maybeRun swallowed", { projectId, error: e });
     }
   }
   async runOnce(projectId) {
@@ -129300,13 +129688,13 @@ class ObservationConsolidationJob {
       this.runOnce(projectId).catch((e) => {
         logger.warn("observation consolidation: runOnce failed (silent)", {
           projectId,
-          error: e.message
+          error: e
         });
       });
     } catch (e) {
       logger.warn("observation consolidation: maybeRun swallowed", {
         projectId,
-        error: e.message
+        error: e
       });
     }
   }
@@ -129330,7 +129718,7 @@ class ObservationConsolidationJob {
     } catch (e) {
       logger.warn("observation consolidation: listRecent failed", {
         projectId,
-        error: e.message
+        error: e
       });
       return noop2;
     }
@@ -129341,7 +129729,7 @@ class ObservationConsolidationJob {
     const prompt = buildObservationPrompt(window2);
     let batch;
     try {
-      const res = await this.llm.object(prompt, ConsolidatedBatchSchema);
+      const res = await this.llm.object(prompt, ConsolidatedBatchSchema, { label: "observation-consolidation" });
       if (!res.ok || !res.value) {
         return noop2;
       }
@@ -129357,7 +129745,7 @@ class ObservationConsolidationJob {
     } catch (e) {
       logger.warn("observation consolidation: llm.object threw (silent)", {
         projectId,
-        error: e.message
+        error: e
       });
       return noop2;
     }
@@ -129386,7 +129774,7 @@ class ObservationConsolidationJob {
     } catch (e) {
       logger.warn("observation consolidation: summary insert failed", {
         batchId: batch.id,
-        error: e.message
+        error: e
       });
       return noop2;
     }
@@ -129497,7 +129885,7 @@ class PgCheckpointStore {
       } catch (e) {
         this.hydrateFailedAt = Date.now();
         logger.warn("PgCheckpointStore hydrate failed (best-effort)", {
-          error: e.message
+          error: e
         });
       } finally {
         this.hydrating = null;
@@ -129691,8 +130079,9 @@ class PgCheckpointStore {
       }
       return existing;
     } catch (e) {
-      logger.warn("countExistingMemoryIds failed (best-effort: assuming all exist)", {
-        error: e.message
+      logger.warn("PgCheckpointStore: countExistingMemoryIds failed (best-effort, assuming all exist)", {
+        memoryIdCount: memoryIds.length,
+        error: e
       });
       return memoryIds;
     }
@@ -129759,7 +130148,7 @@ class PgCheckpointStore {
     const next = prev.then(fn).catch((e) => {
       logger.warn("PgCheckpointStore write failed (best-effort)", {
         key,
-        error: e.message
+        error: e
       });
     });
     this.inflight.set(key, next);
@@ -129978,9 +130367,9 @@ var init_scheduler2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs16 from "fs/promises";
+import fs17 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path22 from "path";
+import path23 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -130000,7 +130389,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path22.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path23.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -130008,7 +130397,7 @@ var init_models_dev_client = __esm(() => {
         if (!existsSync4(cachePath)) {
           return null;
         }
-        const content = await fs16.readFile(cachePath, "utf-8");
+        const content = await fs17.readFile(cachePath, "utf-8");
         const data = JSON.parse(content);
         const age = Date.now() - data.timestamp;
         if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
@@ -130035,21 +130424,22 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path22.dirname(cachePath);
-        await fs16.mkdir(dir, { recursive: true });
+        const dir = path23.dirname(cachePath);
+        await fs17.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
           version: "1.0.0",
           models: Object.fromEntries(models)
         };
-        await fs16.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        await fs17.writeFile(cachePath, JSON.stringify(data), "utf-8");
         logger.debug("Saved pricing to local cache", {
           models: models.size,
           path: cachePath
         });
       } catch (error51) {
-        logger.warn("Failed to save local pricing cache", {
-          error: error51.message
+        logger.warn("ModelsDevClient: failed to save local pricing cache", {
+          path: cachePath,
+          error: error51
         });
       }
     }
@@ -130271,7 +130661,7 @@ var init_models_dev_client = __esm(() => {
           return value;
         }
       }
-      logger.warn(`Model pricing not found: ${modelId}`);
+      logger.warn("ModelsDevClient: model pricing not found", { modelId });
       return null;
     }
     async searchModels(query) {
@@ -130371,12 +130761,13 @@ var init_models_dev_client = __esm(() => {
       const cachePath = this.getLocalCachePath();
       try {
         if (existsSync4(cachePath)) {
-          await fs16.unlink(cachePath);
+          await fs17.unlink(cachePath);
           logger.debug("Local pricing cache file deleted");
         }
       } catch (error51) {
-        logger.warn("Failed to delete local pricing cache", {
-          error: error51.message
+        logger.warn("ModelsDevClient: failed to delete local pricing cache", {
+          path: cachePath,
+          error: error51
         });
       }
     }
@@ -130974,8 +131365,8 @@ function stripNul(content) {
 }
 
 // ../../packages/core/dist/services/etl/stages/discover.js
-import fs17 from "fs/promises";
-import path23 from "path";
+import fs18 from "fs/promises";
+import path24 from "path";
 import { createHash as createHash8 } from "crypto";
 
 class DiscoverStage {
@@ -131001,7 +131392,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path23.isAbsolute(p) ? path23.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path24.isAbsolute(p) ? path24.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -131060,10 +131451,10 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path23.join(ctx.projectPath, relativePath);
+    const absolutePath = path24.join(ctx.projectPath, relativePath);
     try {
-      const stat = await fs17.stat(absolutePath);
-      const content = stripNul(await fs17.readFile(absolutePath, "utf-8"));
+      const stat = await fs18.stat(absolutePath);
+      const content = stripNul(await fs18.readFile(absolutePath, "utf-8"));
       const contentHash = createHash8("sha256").update(content).digest("hex");
       let needsReparse = forceReindex;
       if (!forceReindex) {
@@ -131081,8 +131472,9 @@ class DiscoverStage {
       };
     } catch (err) {
       logger.warn("DiscoverStage: failed to stat/read file", {
+        projectId: ctx.projectId,
         relativePath,
-        error: err.message
+        error: err
       });
       throw new Error(`required_file_unreadable:${relativePath}:${err.message}`);
     }
@@ -131106,8 +131498,8 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path23.join(projectPath, ".gitignore");
-      const gitignoreContent = await fs17.readFile(gitignorePath, "utf8");
+      const gitignorePath = path24.join(projectPath, ".gitignore");
+      const gitignoreContent = await fs18.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       ig.add(rules);
@@ -132462,8 +132854,8 @@ function rustUseLeaves(node, source, prefix = []) {
   }
   if (node.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path24 = rustPathSegments(node, source);
-  return path24.length ? [{ path: [...prefix, ...path24] }] : [];
+  const path25 = rustPathSegments(node, source);
+  return path25.length ? [{ path: [...prefix, ...path25] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -133435,8 +133827,8 @@ var init_structural_runtime = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path24 from "path";
-import fs18 from "fs/promises";
+import path25 from "path";
+import fs19 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
   if (Number.isFinite(global2) && global2 > 0)
@@ -133464,8 +133856,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() !== ".h"),
-      files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() === ".h")
+      files.filter((file2) => path25.extname(file2.relativePath).toLowerCase() !== ".h"),
+      files.filter((file2) => path25.extname(file2.relativePath).toLowerCase() === ".h")
     ];
     const batches = phases.flatMap((phase) => Array.from({ length: Math.ceil(phase.length / BATCH_SIZE) }, (_, index) => phase.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE)));
     for (const batch of batches) {
@@ -133503,19 +133895,19 @@ class ParseStage {
     return files.map((file2) => results.get(file2.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path24.posix.normalize(file2.relativePath)));
+    const knownHeaders = new Set(files.filter((file2) => path25.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path25.posix.normalize(file2.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path24.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path25.extname(parsed.file.relativePath).toLowerCase();
       const key = extension === ".c" ? "cImporters" : [".cpp", ".hpp"].includes(extension) ? "cppImporters" : undefined;
       if (!key)
         continue;
       for (const imported of parsed.rawImports) {
         if (!["c_include", "cpp_include"].includes(imported.form) || imported.specifier.startsWith("<"))
           continue;
-        const header = path24.posix.normalize(path24.posix.join(path24.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path25.posix.normalize(path25.posix.join(path25.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -133526,9 +133918,9 @@ class ParseStage {
   }
   async parseFile(ctx, file2) {
     if (!file2.needsReparse) {
-      const extension = path24.extname(file2.relativePath).toLowerCase();
+      const extension = path25.extname(file2.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
-        const content = file2.snapshotContent ?? await fs18.readFile(file2.absolutePath, "utf8");
+        const content = file2.snapshotContent ?? await fs19.readFile(file2.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
         if (outcome.status === "failed")
           throw new StructuralEtlParseError(file2.relativePath, outcome.failureKind, `Structural evidence parse failed (${outcome.failureKind})`, outcome.diagnosticCount, outcome.diagnostics.slice(0, 10));
@@ -133540,8 +133932,8 @@ class ParseStage {
       return { file: file2, chunks: [], symbols: [], rawImports: [], rawEdges: [] };
     }
     try {
-      const content = file2.snapshotContent ?? await fs18.readFile(file2.absolutePath, "utf-8");
-      const ext2 = path24.extname(file2.relativePath).toLowerCase();
+      const content = file2.snapshotContent ?? await fs19.readFile(file2.absolutePath, "utf-8");
+      const ext2 = path25.extname(file2.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file2.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -133607,8 +133999,9 @@ class ParseStage {
         timestamp: Date.now()
       });
       logger.warn("ParseStage: failed to parse file", {
+        projectId: ctx.projectId,
         filePath: file2.relativePath,
-        error: err.message
+        error: err
       });
       if (err instanceof StructuralEtlParseError)
         throw err;
@@ -134095,7 +134488,7 @@ var init_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path25 from "path";
+import path26 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -134190,7 +134583,7 @@ function probe(base, known, dialect = "typescript") {
   const bases = /\.[cm]?jsx?$/u.test(base) ? [base.replace(/\.[cm]?jsx?$/u, ".ts"), base.replace(/\.[cm]?jsx?$/u, ".tsx"), base] : [base];
   for (const candidateBase of bases)
     for (const suffix of DIALECT_PROBES[dialect] ?? [""]) {
-      const value = path25.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path26.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -134199,7 +134592,7 @@ function probe(base, known, dialect = "typescript") {
 function resolveStructuralSpecifier(specifier, fromFile, build, dialect = "typescript") {
   const known = new Set(build.knownFiles.map(normalizeStructuralFile));
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    return probe(path25.posix.join(path25.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path26.posix.join(path26.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -134463,7 +134856,7 @@ var init_scripting2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path26 from "path";
+import path27 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -134482,7 +134875,7 @@ var init_systems2 = __esm(() => {
           const bindings = item.bindings.map((binding) => binding.imported === "*" && binding.local === "*" && unresolvedTarget && !unresolvedTarget.qualifier ? { ...binding, imported: unresolvedTarget.name, local: unresolvedTarget.name } : binding);
           if (item.specifier === "crate" || item.specifier.startsWith("crate/")) {
             const crateRoot = file2.file.startsWith("src/") ? "src" : "";
-            return { ...item, bindings, specifier: `./${path26.posix.relative(path26.posix.dirname(file2.file), path26.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path27.posix.relative(path27.posix.dirname(file2.file), path27.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
           }
           if (item.specifier === "self" || item.specifier.startsWith("self/"))
             return { ...item, bindings, specifier: `./${item.specifier.replace(/^self\/?/u, "")}` };
@@ -134580,8 +134973,8 @@ var init_data_document2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path27 from "path";
-import fs19 from "fs";
+import path28 from "path";
+import fs20 from "fs";
 
 class ResolveStage {
   symbolRepository;
@@ -134605,7 +134998,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file2) => {
       if (!file2.structure)
         return [];
-      const language = resolveStructuralLanguage(path27.extname(file2.file.relativePath));
+      const language = resolveStructuralLanguage(path28.extname(file2.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file2.file.relativePath}`);
       return [{
@@ -134617,13 +135010,13 @@ class ResolveStage {
       }];
     });
     const currentStructuralFiles = new Set(structuralDocuments.map((document2) => document2.file));
-    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path28.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
     const pathAliasesByFile = Object.fromEntries([...knownRelPaths].map((file2) => [
       file2,
       this.structuralAliasesFor(file2, rootAliases, monorepoPackages)
     ]));
     const buildMetadata = { knownFiles: [...knownRelPaths], pathAliasesByFile };
-    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(definition.file_path).toLowerCase())).filter((definition) => knownRelPaths.has(definition.file_path) && skippedStructuralFiles.has(definition.file_path)).filter((definition) => !currentStructuralFiles.has(definition.file_path));
+    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path28.extname(definition.file_path).toLowerCase())).filter((definition) => knownRelPaths.has(definition.file_path) && skippedStructuralFiles.has(definition.file_path)).filter((definition) => !currentStructuralFiles.has(definition.file_path));
     const seedIds = new Set;
     for (const definition of seedRows) {
       if (seedIds.has(definition.id))
@@ -134716,7 +135109,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path27.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path28.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -134768,7 +135161,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path27.dirname(path27.join(projectPath, parsed.file.relativePath));
+    const fromDir = path28.dirname(path28.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -134839,12 +135232,12 @@ class ResolveStage {
         index.set(def.name, `${def.file_path}#${def.name}`);
       }
     } catch (err) {
-      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(file2.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path28.extname(file2.file.relativePath).toLowerCase()));
       if (skippedStructural)
         throw new Error("structural_repository_seed_failed", { cause: err });
       logger.warn("buildSymbolIndex: repo seed failed, in-batch only", {
         projectId,
-        error: err?.message
+        error: err
       });
     }
     const inBatch = new Map;
@@ -134863,7 +135256,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path27.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path28.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -134871,8 +135264,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path27.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path27.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path28.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path28.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -134888,7 +135281,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path27.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path28.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -134896,9 +135289,9 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path27.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path28.join(projectPath, "tsconfig.json");
     try {
-      const raw2 = fs19.readFileSync(tsconfigPath, "utf-8");
+      const raw2 = fs20.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
       const tsconfig = JSON.parse(stripped);
       const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -134927,7 +135320,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path27.join(projectPath, packageRelPath);
+      const absPackagePath = path28.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -134957,7 +135350,7 @@ class ResolveStage {
   structuralAliasesFor(filePath, rootAliases, packages) {
     return [...this.getPackageAliases(filePath, packages), ...rootAliases].map((alias) => ({
       pattern: alias.prefix + (alias.targets.some((target) => target.includes("*")) ? "/*" : ""),
-      targets: alias.targets.map((target) => alias.packagePath ? path27.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path28.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -135007,7 +135400,7 @@ async function withDeadlockRetry(operation, options = {}) {
         attempt,
         maxAttempts,
         delayMs,
-        error: error51?.message?.slice(0, 120)
+        error: error51
       });
       await new Promise((resolve7) => setTimeout(resolve7, delayMs));
     }
@@ -135021,7 +135414,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/load.js
-import path28 from "path";
+import path29 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -135298,7 +135691,7 @@ class LoadStage {
     const filePath = file2.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file2);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path28.extname(filePath));
+      const manifest = getLanguageManifestEntry(path29.extname(filePath));
       const diagnostics2 = (file2.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -135755,9 +136148,9 @@ var init_graph_generation_coordinator = __esm(() => {
 // ../../packages/core/dist/services/etl/pipeline.js
 import { createHash as createHash10 } from "crypto";
 import { setTimeout as delay2 } from "timers/promises";
-import path29 from "path";
+import path30 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file2) => path29.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path29.posix.normalize(file2.relativePath)));
+  const headers = new Set(files.filter((file2) => path30.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path30.posix.normalize(file2.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -135768,7 +136161,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file2 of files) {
-    if (path29.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
+    if (path30.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -135784,11 +136177,11 @@ function buildHeaderLanguageEvidence(files) {
       const record2 = command;
       if (typeof record2.file !== "string")
         continue;
-      const projectRoot = path29.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record2.directory === "string" ? path29.resolve(projectRoot, record2.directory) : projectRoot;
-      const absoluteInput = path29.resolve(commandDirectory, record2.file);
-      const relative3 = path29.relative(projectRoot, absoluteInput);
-      const header = path29.posix.normalize(relative3.replaceAll(path29.sep, "/"));
+      const projectRoot = path30.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record2.directory === "string" ? path30.resolve(projectRoot, record2.directory) : projectRoot;
+      const absoluteInput = path30.resolve(commandDirectory, record2.file);
+      const relative3 = path30.relative(projectRoot, absoluteInput);
+      const header = path30.posix.normalize(relative3.replaceAll(path30.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record2.command === "string" ? record2.command : Array.isArray(record2.arguments) ? record2.arguments.join(" ") : "";
@@ -136137,7 +136530,7 @@ var init_pipeline = __esm(() => {
           logger.warn("EtlPipeline: search-admission marker write failed", {
             projectId,
             jobId,
-            error: markerError.message.slice(0, 160)
+            error: markerError
           });
         }
         if (forceReindex) {
@@ -136149,7 +136542,7 @@ var init_pipeline = __esm(() => {
               logger.warn("EtlPipeline: embedding fingerprint stamp failed", {
                 projectId,
                 jobId,
-                error: stampError.message.slice(0, 160)
+                error: stampError
               });
             }
           }
@@ -136312,9 +136705,10 @@ class SearchSessionHook {
       });
     } catch (err) {
       logger.warn("SearchSessionHook: store failed (best-effort)", {
-        error: err.message,
         projectId,
-        query: query.slice(0, 60)
+        sessionId,
+        query: query.slice(0, 60),
+        error: err
       });
     }
   }
@@ -136390,8 +136784,10 @@ class CoRetrievalHook {
       peers = await this.findPeers(memoryId, projectId, sessionId);
     } catch (err) {
       logger.warn("CoRetrievalHook: peer lookup failed", {
-        error: err.message,
-        memoryId
+        projectId,
+        sessionId,
+        memoryId,
+        error: err
       });
       return;
     }
@@ -141670,33 +142066,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path30) {
-        if (!path30)
-          return path30;
+      function remove_dot_segments(path31) {
+        if (!path31)
+          return path31;
         var output = "";
-        while (path30.length > 0) {
-          if (path30 === "." || path30 === "..") {
-            path30 = "";
+        while (path31.length > 0) {
+          if (path31 === "." || path31 === "..") {
+            path31 = "";
             break;
           }
-          var twochars = path30.substring(0, 2);
-          var threechars = path30.substring(0, 3);
-          var fourchars = path30.substring(0, 4);
+          var twochars = path31.substring(0, 2);
+          var threechars = path31.substring(0, 3);
+          var fourchars = path31.substring(0, 4);
           if (threechars === "../") {
-            path30 = path30.substring(3);
+            path31 = path31.substring(3);
           } else if (twochars === "./") {
-            path30 = path30.substring(2);
+            path31 = path31.substring(2);
           } else if (threechars === "/./") {
-            path30 = "/" + path30.substring(3);
-          } else if (twochars === "/." && path30.length === 2) {
-            path30 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path30.length === 3) {
-            path30 = "/" + path30.substring(4);
+            path31 = "/" + path31.substring(3);
+          } else if (twochars === "/." && path31.length === 2) {
+            path31 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path31.length === 3) {
+            path31 = "/" + path31.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path30.match(/(\/?([^\/]*))/)[0];
+            var segment = path31.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path30 = path30.substring(segment.length);
+            path31 = path31.substring(segment.length);
           }
         }
         return output;
@@ -153766,21 +154162,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path30, out) {
+function walk(val, path31, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path30, content: `**${path30}** = _[]_` });
+      out.push({ path: path31, content: `**${path31}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path30}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path31}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path30, content: `**${path30}**
+    out.push({ path: path31, content: `**${path31}**
 
 ${items}` });
     return;
@@ -153788,16 +154184,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path30, content: `**${path30}** = _{}_` });
+      out.push({ path: path31, content: `**${path31}** = _{}_` });
       return;
     }
     for (const [k, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
-      walk(v, `${path30}.${safeKey}`, out);
+      walk(v, `${path31}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path30, content: `**${path30}** = \`${String(val)}\`` });
+  out.push({ path: path31, content: `**${path31}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -153901,6 +154297,7 @@ async function fetchAndConvertOne(url2, deps, opts = {}) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       logger.error("fetch_and_index indexChunk failed", err, {
+        projectId,
         url: url2,
         chunkId: chunk.id
       });
@@ -154091,6 +154488,7 @@ class WebController {
         return s.value;
       const msg = s.reason instanceof Error ? s.reason.message : String(s.reason);
       logger.error("fetch_and_index job rejected", s.reason, {
+        projectId,
         url: batch[i].url
       });
       return { kind: "error", url: batch[i].url, error: msg };
@@ -154222,8 +154620,8 @@ var init_recover_project = __esm(() => {
 init_config();
 init_dist();
 init_inference_providers();
-import os8 from "os";
-import path30 from "path";
+import os9 from "os";
+import path31 from "path";
 var WRITABLE_PROVIDERS = ["ollama", "lmstudio", "mistral", "openai", "google", "cohere"];
 var GENERATOR_MARKER = "scripts/generate-subagent-artifacts.ts";
 var GENERATOR_MARKER_MAX_LEVELS = 6;
@@ -154266,6 +154664,14 @@ Commands:
   profile set <name> [--host <h>] [--dry-run]
                     Switch installed agents to a profile (restart required after)
 
+  doctor [--fix] [--host <h>] [--target <dir>]
+                    Report agent model/profile drift: live-tree vs recorded
+                    versions, per-role models, variant staleness, env
+                    overrides. --fix re-runs the profile switch for the
+                    recorded active profile (restart required after).
+                    --target redirects the home the state/registries are
+                    read from (test seam, same convention as bootstrap)
+
   bootstrap list    List every startup-contract rule: state, default, description
   bootstrap show    Same as 'bootstrap list'
   bootstrap enable <rule-id> [--target <dir> --yes] [--dry-run]
@@ -154283,6 +154689,8 @@ Examples:
   massa-ai-config set embedding.dimensions 1024
   massa-ai-config recover my-project --path /home/user/renamed-dir
   massa-ai-config profile set work --dry-run
+  massa-ai-config doctor
+  massa-ai-config doctor --fix
   massa-ai-config bootstrap list
   massa-ai-config bootstrap disable caveman
 `);
@@ -154326,6 +154734,30 @@ function formatSwitchReport(report) {
 A host session restart is required for the change to take effect.`);
   }
 }
+function formatDriftReport(report) {
+  console.log(`doctor (${report.host}, route: ${report.route})`);
+  console.log(`  live root:       ${report.liveRoot ?? "n/a"}`);
+  console.log(`  source version:  ${report.sourceVersion ?? "n/a"} (live tree)`);
+  console.log(`  state version:   ${report.stateVersion ?? "n/a"} (install-state)`);
+  console.log(`  pinned version:  ${report.pinnedVersion ?? "n/a"} (installed_plugins)`);
+  console.log(`  active profile:  ${report.activeProfile ?? "n/a"}`);
+  for (const role of report.roles) {
+    const stale = role.staleVariant ? " \u2014 STALE vs the recorded profile's variant" : "";
+    console.log(`  ${role.name}: model=${role.model ?? "unknown"} effort=${role.effort ?? "unknown"}${stale}`);
+  }
+  if (report.versionDrift) {
+    console.log(`  drift: live tree ${report.sourceVersion} != recorded ${report.stateVersion} \u2014 update the plugin (or re-run the installer)`);
+  }
+  if (report.profileMaterialized) {
+    console.log("  drift: active agent files differ from the recorded profile's variants \u2014 run `massa-ai-config doctor --fix` (re-runs the profile switch)");
+  }
+  if (report.envOverride) {
+    console.log(`  override: ${report.envOverride.name}=${report.envOverride.value} wins over every per-agent model at runtime \u2014 remove it from the host env to let profiles govern`);
+  }
+  if (report.route !== "unresolved" && !report.versionDrift && !report.profileMaterialized && !report.envOverride) {
+    console.log("  healthy: every recording agrees.");
+  }
+}
 async function runCli(argv) {
   const args = argv;
   const command = args[0];
@@ -154561,6 +154993,39 @@ Using defaults:`);
       console.error("Usage: massa-ai-config profile <list|show|set> ...");
       return 1;
     }
+    case "doctor": {
+      const fix = options["fix"] === true;
+      const hostOpt = typeof options.host === "string" ? options.host : undefined;
+      if (hostOpt !== undefined && !isHost(hostOpt)) {
+        console.error(`Error: unknown host "${hostOpt}"`);
+        return 1;
+      }
+      const host = hostOpt ?? "claude";
+      const targetHome = typeof options.target === "string" ? options.target : os9.homedir();
+      try {
+        let report = runtimeDriftReport({ targetHome, host });
+        if (fix) {
+          const profile = report.activeProfile;
+          if (!profile) {
+            console.error("Error: no recorded active profile in install-state.json \u2014 run " + "`massa-ai-config profile set <name>` first; there is nothing to fix from.");
+            return 1;
+          }
+          const sourceRoot = findRepoRootWithMarker(import.meta.dirname, GENERATOR_MARKER, GENERATOR_MARKER_MAX_LEVELS);
+          formatVariantSync(syncGeneratedVariants({ sourceRoot, targetHome }));
+          const switchReport = switchProfile({ profile, host, targetHome });
+          formatSwitchReport(switchReport);
+          if (!reportSucceeded(switchReport)) {
+            return 1;
+          }
+          report = runtimeDriftReport({ targetHome, host });
+        }
+        formatDriftReport(report);
+        return 0;
+      } catch (e) {
+        console.error(`Error: ${e.message}`);
+        return 1;
+      }
+    }
     case "bootstrap": {
       const subcommand = args[1];
       if (subcommand === "list" || subcommand === "show") {
@@ -154585,9 +155050,9 @@ Using defaults:`);
           return 1;
         }
         const targetOpt = typeof options.target === "string" ? options.target : undefined;
-        const targetHome = targetOpt === undefined ? os8.homedir() : path30.resolve(targetOpt);
-        if (targetHome !== os8.homedir() && options.yes !== true) {
-          console.error(`Error: --target ${targetHome} is not your home (${os8.homedir()}) \u2014 pass --yes to confirm writing there`);
+        const targetHome = targetOpt === undefined ? os9.homedir() : path31.resolve(targetOpt);
+        if (targetHome !== os9.homedir() && options.yes !== true) {
+          console.error(`Error: --target ${targetHome} is not your home (${os9.homedir()}) \u2014 pass --yes to confirm writing there`);
           return 1;
         }
         const dryRun = options["dry-run"] === true;
@@ -154605,7 +155070,7 @@ Using defaults:`);
           const report = applyBootstrapState({
             targetHome,
             dryRun,
-            sourcePath: repoRoot === null ? undefined : path30.join(repoRoot, "skills", "AGENTS.md")
+            sourcePath: repoRoot === null ? undefined : path31.join(repoRoot, "skills", "AGENTS.md")
           });
           console.log(formatBootstrapReport(report));
           return bootstrapReportSucceeded(report) ? 0 : 1;