@massa-ai/tools-api 1.46.0 → 1.48.0

package/dist/index.js

@@ -401,9 +401,64 @@ var init_xdg = () => {};
 
 // ../../packages/shared/dist/config/massa-ai-config.js
 import path2 from "path";
-var defaultMassaAiConfig;
+var SCHEDULER_JOB_KINDS, MAX_MATCH_WORK = 1e5, MAX_IGNORE_PATTERNS = 1024, DEFAULT_CAPTURE_POLICY, DEFAULT_SCHEDULER_CONFIG, defaultMassaAiConfig;
 var init_massa_ai_config = __esm(() => {
   init_xdg();
+  SCHEDULER_JOB_KINDS = [
+    "memory-consolidation",
+    "decay-sweep",
+    "auto-improve",
+    "observation-bridge",
+    "checkpoint-purge"
+  ];
+  DEFAULT_CAPTURE_POLICY = {
+    rules: [
+      { pattern: "**/node_modules/**", disposition: "Drop" },
+      { pattern: "**/.git/**", disposition: "Drop" },
+      { pattern: "**/dist/**", disposition: "Drop" },
+      { pattern: "**/build/**", disposition: "Drop" },
+      { pattern: "**/coverage/**", disposition: "Drop" },
+      { pattern: ".env", disposition: "Drop" },
+      { pattern: ".env.*", disposition: "Drop" },
+      { pattern: "**/generated/**", disposition: "Drop" },
+      { pattern: "**/*.generated.*", disposition: "Drop" },
+      { pattern: "**/*.d.ts", disposition: "Drop" },
+      { pattern: "**/__tests__/**", disposition: "Drop" },
+      { pattern: "**/tests/**", disposition: "Drop" },
+      { pattern: "**/*.test.ts", disposition: "Drop" },
+      { pattern: "**/*.test.tsx", disposition: "Drop" },
+      { pattern: "**/*.test.js", disposition: "Drop" },
+      { pattern: "**/*.test.jsx", disposition: "Drop" },
+      { pattern: "**/*.spec.ts", disposition: "Drop" },
+      { pattern: "**/*.spec.tsx", disposition: "Drop" },
+      { pattern: "**/*.spec.js", disposition: "Drop" },
+      { pattern: "**/*.spec.jsx", disposition: "Drop" },
+      { pattern: "**/benchmarks/**", disposition: "Drop" },
+      { pattern: "**/fixtures/**", disposition: "Drop" },
+      { pattern: "**/*.wasm*", disposition: "Drop" },
+      { pattern: "**/*.min.*", disposition: "Drop" },
+      { pattern: "**/*.map", disposition: "Drop" },
+      { pattern: "**/lock.yaml", disposition: "Drop" },
+      { pattern: "**/pnpm-lock.yaml", disposition: "Drop" },
+      { pattern: "**/package-lock.json", disposition: "Drop" },
+      { pattern: "**/bun.lockb", disposition: "Drop" },
+      { pattern: "**/yarn.lock", disposition: "Drop" }
+    ],
+    maxMatchWork: MAX_MATCH_WORK,
+    maxIgnorePatterns: MAX_IGNORE_PATTERNS
+  };
+  DEFAULT_SCHEDULER_CONFIG = {
+    enabled: false,
+    tickMs: 60000,
+    maxConcurrent: 2,
+    jobs: {
+      "memory-consolidation": { enabled: false, intervalMs: 30 * 60 * 1000 },
+      "decay-sweep": { enabled: false, intervalMs: 60 * 60 * 1000 },
+      "auto-improve": { enabled: false, intervalMs: 30 * 60 * 1000 },
+      "observation-bridge": { enabled: false, intervalMs: 30 * 60 * 1000 },
+      "checkpoint-purge": { enabled: false, intervalMs: 60 * 60 * 1000 }
+    }
+  };
   defaultMassaAiConfig = {
     database: {
       url: ""
@@ -422,7 +477,7 @@ var init_massa_ai_config = __esm(() => {
     impact: {
       bfsCteEnabled: false
     },
-    capturePolicy: undefined,
+    capturePolicy: DEFAULT_CAPTURE_POLICY,
     cache: {
       enabled: true,
       l1MaxSizeMB: 100,
@@ -545,7 +600,8 @@ var init_massa_ai_config = __esm(() => {
     },
     security: {
       corsOrigins: []
-    }
+    },
+    scheduler: DEFAULT_SCHEDULER_CONFIG
   };
 });
 
@@ -555,6 +611,8 @@ __export(exports_config_loader, {
   writeFileAtomically: () => writeFileAtomically,
   saveConfig: () => saveConfig,
   migrateDataDirOnce: () => migrateDataDirOnce,
+  mergeSchedulerSection: () => mergeSchedulerSection,
+  loadRawUserConfig: () => loadRawUserConfig,
   loadConfigSafe: () => loadConfigSafe,
   loadConfig: () => loadConfig,
   initConfig: () => initConfig,
@@ -577,6 +635,22 @@ function getConfigPath() {
 function configExists() {
   return fs.existsSync(CONFIG_FILE);
 }
+function mergeSchedulerJobs(base, incoming) {
+  const defaults = defaultMassaAiConfig.scheduler?.jobs ?? {};
+  const merged = {};
+  for (const kind of Object.keys(defaults)) {
+    merged[kind] = { ...defaults[kind], ...base?.[kind], ...incoming?.[kind] };
+  }
+  return merged;
+}
+function mergeSchedulerSection(base, incoming) {
+  return {
+    ...defaultMassaAiConfig.scheduler,
+    ...base,
+    ...incoming,
+    jobs: mergeSchedulerJobs(base?.jobs, incoming?.jobs)
+  };
+}
 function loadConfig() {
   if (!fs.existsSync(CONFIG_FILE)) {
     return defaultMassaAiConfig;
@@ -597,13 +671,27 @@ function loadConfig() {
       memory: { ...defaultMassaAiConfig.memory, ...userConfig.memory },
       hooks: { ...defaultMassaAiConfig.hooks, ...userConfig.hooks },
       handoffs: { ...defaultMassaAiConfig.handoffs, ...userConfig.handoffs },
-      security: { ...defaultMassaAiConfig.security, ...userConfig.security }
+      security: { ...defaultMassaAiConfig.security, ...userConfig.security },
+      scheduler: mergeSchedulerSection(undefined, userConfig.scheduler),
+      capturePolicy: userConfig.capturePolicy ?? defaultMassaAiConfig.capturePolicy
     };
   } catch (error) {
     console.error(`Error loading config from ${CONFIG_FILE}:`, error);
     return defaultMassaAiConfig;
   }
 }
+function loadRawUserConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_FILE))
+      return {};
+    const parsed = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
 function loadConfigSafe() {
   try {
     return loadConfig();
@@ -759,6 +847,8 @@ function restartNeededSections(config) {
       return config.llm !== undefined;
     if (s === "security")
       return config.security !== undefined;
+    if (s === "scheduler")
+      return config.scheduler !== undefined;
     return false;
   });
 }
@@ -1007,6 +1097,29 @@ function validatePartial(partial) {
         details.push("security.allowedExtensions[] must be dot-prefixed extensions");
     }
   }
+  if (partial.scheduler !== undefined) {
+    const sch = partial.scheduler;
+    if (sch.enabled !== undefined && !checkBoolean(sch.enabled))
+      details.push("scheduler.enabled must be a boolean");
+    if (sch.tickMs !== undefined && !checkNumber(sch.tickMs, 1000))
+      details.push("scheduler.tickMs must be a number >= 1000");
+    if (sch.maxConcurrent !== undefined && !checkNumber(sch.maxConcurrent, 1))
+      details.push("scheduler.maxConcurrent must be a number >= 1");
+    if (sch.jobs !== undefined) {
+      for (const [kind, job] of Object.entries(sch.jobs)) {
+        if (!SCHEDULER_JOB_KINDS.includes(kind)) {
+          details.push(`scheduler.jobs.${kind} is not a registered job kind (expected one of: ${SCHEDULER_JOB_KINDS.join(", ")})`);
+          continue;
+        }
+        if (job === undefined || job === null)
+          continue;
+        if (job.enabled !== undefined && !checkBoolean(job.enabled))
+          details.push(`scheduler.jobs.${kind}.enabled must be a boolean`);
+        if (job.intervalMs !== undefined && !checkNumber(job.intervalMs, 60000))
+          details.push(`scheduler.jobs.${kind}.intervalMs must be a number >= 60000`);
+      }
+    }
+  }
   return details;
 }
 function repairAndPruneBackups(configPath) {
@@ -1048,6 +1161,9 @@ function savePartialConfig(partial) {
     return { success: false, details };
   }
   const merged = { ...current, ...mergedPartial };
+  if (mergedPartial.scheduler !== undefined) {
+    merged.scheduler = mergeSchedulerSection(current.scheduler, mergedPartial.scheduler);
+  }
   const configPath = getConfigPath();
   if (fs2.existsSync(configPath)) {
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
@@ -1067,7 +1183,8 @@ function savePartialConfig(partial) {
 var MASK_SENTINEL = "***", RESTART_SECTIONS, VALID_EMBEDDING_PROVIDERS, VALID_LOG_LEVELS, BACKUP_RETENTION_LIMIT = 10;
 var init_config_writer = __esm(() => {
   init_config_loader();
-  RESTART_SECTIONS = ["database", "embedding", "llm", "security"];
+  init_massa_ai_config();
+  RESTART_SECTIONS = ["database", "embedding", "llm", "security", "scheduler"];
   VALID_EMBEDDING_PROVIDERS = ["ollama", "mistral", "openai", "google", "cohere"];
   VALID_LOG_LEVELS = ["debug", "info", "warn", "error"];
 });
@@ -1210,6 +1327,31 @@ function parsePositiveIntEnv(raw2, defaultValue, opts) {
   return Number.isInteger(n) && n >= floor ? n : defaultValue;
 }
 
+// ../../packages/shared/dist/config/embedding-dimensions.js
+function knownEmbeddingDimensions(model) {
+  if (!model)
+    return;
+  return KNOWN_EMBEDDING_DIMENSIONS[model.trim()];
+}
+function resolveEmbeddingDimensions(model, configured, envValue) {
+  if (envValue !== undefined)
+    return { dimensions: envValue };
+  const known = knownEmbeddingDimensions(model);
+  if (known !== undefined) {
+    return configured !== undefined && configured !== known ? { dimensions: known, correctedFrom: configured } : { dimensions: known };
+  }
+  return { dimensions: configured ?? DEFAULT_EMBEDDING_DIMENSIONS };
+}
+var KNOWN_EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_DIMENSIONS = 2560;
+var init_embedding_dimensions = __esm(() => {
+  KNOWN_EMBEDDING_DIMENSIONS = {
+    "qwen3-embedding:8b": 4096,
+    "qwen3-embedding:4b": 2560,
+    "qwen3-embedding:0.6b": 1024,
+    "bge-m3": 1024
+  };
+});
+
 // ../../packages/shared/dist/config/index.js
 import path6 from "path";
 function envNum(key, fallback) {
@@ -1241,6 +1383,22 @@ function envList(key, fallback) {
   const parsed = s.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
   return parsed.length > 0 ? parsed : fallback;
 }
+function readSchedulerConfig(rawFileConfig) {
+  try {
+    const cfg = rawFileConfig;
+    return cfg?.scheduler ?? {};
+  } catch {
+    return {};
+  }
+}
+function resolveSchedulerJob(kind, fileJobs) {
+  const meta = SCHEDULER_JOB_ENV[kind];
+  const fileJob = fileJobs?.[kind];
+  return {
+    enabled: envBool(meta.enabledVar, fileJob?.enabled ?? false),
+    intervalMs: envNum(meta.intervalVar, fileJob?.intervalMs ?? meta.defaultIntervalMs)
+  };
+}
 function validateCapturePolicyConfig(raw2) {
   if (!raw2 || typeof raw2 !== "object")
     throw new TypeError("capturePolicy must be an object");
@@ -1368,6 +1526,11 @@ class Config {
       rateLimit: { ...defaults.rateLimit, ...overrides.rateLimit },
       security: { ...defaults.security, ...overrides.security },
       logging: { ...defaults.logging, ...overrides.logging },
+      scheduler: {
+        ...defaults.scheduler,
+        ...overrides.scheduler,
+        jobs: { ...defaults.scheduler.jobs, ...overrides.scheduler?.jobs }
+      },
       synapse: {
         ...defaults.synapse,
         ...overrides.synapse,
@@ -1436,15 +1599,45 @@ class Config {
     this.config[key] = value;
   }
 }
-var DEFAULT_LLM_MODEL = "qwen2.5:7b-instruct", DEFAULT_LLM_CODE_MODEL = "qwen2.5-coder:7b", MAX_IGNORE_PATTERNS = 1024, DEFAULT_ALLOWED_EXTENSIONS, fileConfig, fileCacheL1Bytes, fileCacheL2Bytes, defaultConfig, config;
+var DEFAULT_LLM_MODEL = "qwen2.5:7b-instruct", DEFAULT_LLM_CODE_MODEL = "qwen2.5-coder:7b", SCHEDULER_JOB_ENV, DEFAULT_ALLOWED_EXTENSIONS, fileConfig, fileCacheL1Bytes, fileCacheL2Bytes, resolvedDataDir, defaultConfig, config;
 var init_config = __esm(() => {
   init_env();
   init_config_loader();
   init_massa_ai_config();
+  init_massa_ai_config();
+  init_massa_ai_config();
   init_config_loader();
   init_config_writer();
   init_xdg();
   init_api_key();
+  init_embedding_dimensions();
+  SCHEDULER_JOB_ENV = {
+    "memory-consolidation": {
+      enabledVar: "MASSA_AI_SCHEDULER_CONSOLIDATION_ENABLED",
+      intervalVar: "MASSA_AI_SCHEDULER_CONSOLIDATION_INTERVAL_MS",
+      defaultIntervalMs: 30 * 60 * 1000
+    },
+    "decay-sweep": {
+      enabledVar: "MASSA_AI_SCHEDULER_DECAY_ENABLED",
+      intervalVar: "MASSA_AI_SCHEDULER_DECAY_INTERVAL_MS",
+      defaultIntervalMs: 60 * 60 * 1000
+    },
+    "auto-improve": {
+      enabledVar: "MASSA_AI_SCHEDULER_AUTO_IMPROVE_ENABLED",
+      intervalVar: "MASSA_AI_SCHEDULER_AUTO_IMPROVE_INTERVAL_MS",
+      defaultIntervalMs: 30 * 60 * 1000
+    },
+    "observation-bridge": {
+      enabledVar: "MASSA_AI_SCHEDULER_OBSERVATION_BRIDGE_ENABLED",
+      intervalVar: "MASSA_AI_SCHEDULER_OBSERVATION_BRIDGE_INTERVAL_MS",
+      defaultIntervalMs: 30 * 60 * 1000
+    },
+    "checkpoint-purge": {
+      enabledVar: "MASSA_AI_SCHEDULER_CHECKPOINT_PURGE_ENABLED",
+      intervalVar: "MASSA_AI_SCHEDULER_CHECKPOINT_PURGE_INTERVAL_MS",
+      defaultIntervalMs: 60 * 60 * 1000
+    }
+  };
   DEFAULT_ALLOWED_EXTENSIONS = [
     ".ts",
     ".js",
@@ -1483,10 +1676,11 @@ var init_config = __esm(() => {
   fileConfig = loadConfigSafe();
   fileCacheL1Bytes = fileConfig.cache?.l1MaxSizeMB ? fileConfig.cache.l1MaxSizeMB * 1024 * 1024 : undefined;
   fileCacheL2Bytes = fileConfig.cache?.l2MaxSizeMB ? fileConfig.cache.l2MaxSizeMB * 1024 * 1024 : undefined;
+  resolvedDataDir = getGlobalDataDir();
   defaultConfig = {
     name: "massa-ai-server",
     version: "1.0.0",
-    dataDir: getGlobalDataDir(),
+    dataDir: resolvedDataDir,
     cache: {
       l1: {
         maxSize: envNum("L1_CACHE_MAX_SIZE", fileCacheL1Bytes ?? 100 * 1024 * 1024),
@@ -1610,8 +1804,24 @@ var init_config = __esm(() => {
     logging: {
       level: process.env.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 || undefined
-    },
+      file: process.env.MASSA_AI_LOG_FILE || fileConfig.logging?.file || path6.join(resolvedDataDir, "logs", "massa-ai.log"),
+      enableFileSink: envBool("MASSA_AI_LOG_ENABLE_FILE_SINK", fileConfig.logging?.enableFileSink ?? true),
+      bufferSize: envNum("MASSA_AI_LOG_BUFFER_SIZE", fileConfig.logging?.bufferSize ?? 2000),
+      maxFileSizeMb: envNum("MASSA_AI_LOG_MAX_FILE_SIZE_MB", fileConfig.logging?.maxFileSizeMb ?? 32),
+      maxFiles: envNum("MASSA_AI_LOG_MAX_FILES", fileConfig.logging?.maxFiles ?? 5)
+    },
+    scheduler: (() => {
+      const fileScheduler = readSchedulerConfig(fileConfig);
+      return {
+        enabled: envBool("MASSA_AI_SCHEDULER_ENABLED", fileScheduler.enabled ?? false),
+        tickMs: envNum("MASSA_AI_SCHEDULER_TICK_MS", fileScheduler.tickMs ?? 60000),
+        maxConcurrent: envNum("MASSA_AI_SCHEDULER_MAX_CONCURRENT", fileScheduler.maxConcurrent ?? 2),
+        jobs: Object.fromEntries(SCHEDULER_JOB_KINDS.map((kind) => [
+          kind,
+          resolveSchedulerJob(kind, fileScheduler.jobs)
+        ]))
+      };
+    })(),
     synapse: {
       enabled: process.env.SYNAPSE_ENABLED !== "false",
       inhibition: {
@@ -6948,13 +7158,190 @@ var init_types = __esm(() => {
 // ../../packages/shared/dist/types/interfaces.js
 var init_interfaces = () => {};
 
-// ../../packages/shared/dist/utils/logger.js
+// ../../packages/shared/dist/utils/log-sink.js
 import fs4 from "fs";
+import path7 from "path";
+function getState(filePath) {
+  let state = pathState.get(filePath);
+  if (!state) {
+    state = { trackedSize: 0, deltaSinceStat: 0, primed: false };
+    pathState.set(filePath, state);
+  }
+  return state;
+}
+function ensureDir(filePath) {
+  const dir = path7.dirname(filePath);
+  if (ensuredDirs.has(dir))
+    return;
+  fs4.mkdirSync(dir, { recursive: true });
+  ensuredDirs.add(dir);
+}
+function restat(filePath, state) {
+  try {
+    state.trackedSize = fs4.statSync(filePath).size;
+  } catch {
+    state.trackedSize = 0;
+  }
+  state.deltaSinceStat = 0;
+  state.primed = true;
+}
+function rotate(filePath, maxFiles) {
+  if (maxFiles <= 0) {
+    if (fs4.existsSync(filePath))
+      fs4.unlinkSync(filePath);
+    return;
+  }
+  const oldest = `${filePath}.${maxFiles}`;
+  if (fs4.existsSync(oldest))
+    fs4.unlinkSync(oldest);
+  for (let n2 = maxFiles - 1;n2 >= 1; n2--) {
+    const src = `${filePath}.${n2}`;
+    const dest = `${filePath}.${n2 + 1}`;
+    if (fs4.existsSync(src))
+      fs4.renameSync(src, dest);
+  }
+  if (fs4.existsSync(filePath))
+    fs4.renameSync(filePath, `${filePath}.1`);
+}
+function appendLine(opts, line) {
+  const { filePath, maxFileSizeBytes, maxFiles } = opts;
+  try {
+    ensureDir(filePath);
+    const state = getState(filePath);
+    const lineBytes = Buffer.byteLength(line + `
+`, "utf8");
+    if (!state.primed || state.deltaSinceStat >= STAT_DELTA_THRESHOLD_BYTES || state.trackedSize + state.deltaSinceStat >= maxFileSizeBytes) {
+      restat(filePath, state);
+    }
+    if (maxFileSizeBytes > 0 && state.trackedSize >= maxFileSizeBytes) {
+      rotate(filePath, maxFiles);
+      state.trackedSize = 0;
+      state.deltaSinceStat = 0;
+      state.primed = true;
+    }
+    fs4.appendFileSync(filePath, line + `
+`);
+    state.trackedSize += lineBytes;
+    state.deltaSinceStat += lineBytes;
+  } catch (err) {
+    lastError = err;
+  }
+}
+function sinkFiles(filePath, maxFiles) {
+  const files = [];
+  try {
+    if (fs4.existsSync(filePath))
+      files.push(filePath);
+    for (let n2 = 1;n2 <= maxFiles; n2++) {
+      const rotated = `${filePath}.${n2}`;
+      if (fs4.existsSync(rotated))
+        files.push(rotated);
+    }
+  } catch (err) {
+    lastError = err;
+  }
+  return files;
+}
+var STAT_DELTA_THRESHOLD_BYTES, ensuredDirs, pathState, lastError;
+var init_log_sink = __esm(() => {
+  STAT_DELTA_THRESHOLD_BYTES = 1024 * 1024;
+  ensuredDirs = new Set;
+  pathState = new Map;
+});
+
+// ../../packages/shared/dist/utils/log-buffer.js
+class LogBufferImpl {
+  capacity = DEFAULT_CAPACITY;
+  entries = [];
+  subscribers = new Set;
+  nextSeq = 0;
+  dispatching = false;
+  pending = [];
+  push(entry) {
+    if (this.dispatching) {
+      this.pending.push(entry);
+      return;
+    }
+    this.dispatching = true;
+    try {
+      this.pushOne(entry);
+      while (this.pending.length > 0) {
+        const next = this.pending.shift();
+        this.pushOne(next);
+      }
+    } finally {
+      this.dispatching = false;
+    }
+  }
+  pushOne(entry) {
+    const full = { ...entry, seq: this.nextSeq++ };
+    this.entries.push(full);
+    while (this.entries.length > this.capacity) {
+      this.entries.shift();
+    }
+    for (const fn of this.subscribers) {
+      try {
+        fn(full);
+      } catch {}
+    }
+  }
+  snapshot(opts) {
+    const from = opts?.from;
+    const to = opts?.to;
+    const level = opts?.level;
+    const q = opts?.q?.toLowerCase();
+    const result = [];
+    for (let i = this.entries.length - 1;i >= 0; i--) {
+      const e = this.entries[i];
+      if (from !== undefined && e.seq < from)
+        continue;
+      if (to !== undefined && e.seq > to)
+        continue;
+      if (level !== undefined && e.level !== level)
+        continue;
+      if (q !== undefined && !e.message.toLowerCase().includes(q))
+        continue;
+      result.push(e);
+    }
+    return result;
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => {
+      this.subscribers.delete(fn);
+    };
+  }
+  setCapacity(n2) {
+    this.capacity = n2 > 0 ? n2 : 0;
+    while (this.entries.length > this.capacity) {
+      this.entries.shift();
+    }
+  }
+  size() {
+    return this.entries.length;
+  }
+  _resetForTesting() {
+    this.entries = [];
+    this.subscribers.clear();
+    this.nextSeq = 0;
+    this.dispatching = false;
+    this.pending = [];
+    this.capacity = DEFAULT_CAPACITY;
+  }
+}
+var DEFAULT_CAPACITY = 2000, logBuffer;
+var init_log_buffer = __esm(() => {
+  logBuffer = new LogBufferImpl;
+});
 
+// ../../packages/shared/dist/utils/logger.js
 class Logger {
   _level;
   _enableMetrics;
   _logFilePath;
+  _enableFileSink;
+  _maxFileSizeBytes;
+  _maxFiles;
   _initialized = false;
   constructor() {}
   ensureInitialized() {
@@ -6964,10 +7351,18 @@ class Logger {
         this._level = this.parseLogLevel(loggingConfig.level);
         this._enableMetrics = loggingConfig.enableMetrics;
         this._logFilePath = loggingConfig.file;
+        this._enableFileSink = loggingConfig.enableFileSink;
+        this._maxFileSizeBytes = loggingConfig.maxFileSizeMb * 1024 * 1024;
+        this._maxFiles = loggingConfig.maxFiles;
+        logBuffer.setCapacity(loggingConfig.bufferSize);
       } catch {
         this._level = LogLevel.INFO;
         this._enableMetrics = false;
         this._logFilePath = undefined;
+        this._enableFileSink = false;
+        this._maxFileSizeBytes = 32 * 1024 * 1024;
+        this._maxFiles = 5;
+        logBuffer.setCapacity(2000);
       }
       this._initialized = true;
     }
@@ -6984,6 +7379,18 @@ class Logger {
     this.ensureInitialized();
     return this._logFilePath;
   }
+  get enableFileSink() {
+    this.ensureInitialized();
+    return this._enableFileSink;
+  }
+  get maxFileSizeBytes() {
+    this.ensureInitialized();
+    return this._maxFileSizeBytes;
+  }
+  get maxFiles() {
+    this.ensureInitialized();
+    return this._maxFiles;
+  }
   parseLogLevel(level) {
     const levels = {
       debug: LogLevel.DEBUG,
@@ -6996,34 +7403,40 @@ class Logger {
   shouldLog(level) {
     return level >= this.level;
   }
-  formatMessage(level, message, meta) {
-    const timestamp = new Date().toISOString();
+  formatMessage(level, message, meta, timestamp = new Date().toISOString()) {
     const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
     return `[${timestamp}] [${level}] ${message}${metaStr}`;
   }
-  write(message, _level) {
-    console.error(message);
-    const filePath = this.logFilePath;
-    if (filePath) {
-      try {
-        fs4.appendFileSync(filePath, message + `
-`);
-      } catch {}
+  emit(level, message, meta) {
+    const ts = new Date().toISOString();
+    const line = this.formatMessage(LOG_LEVEL_LABELS[level], message, meta, ts);
+    console.error(line);
+    if (this.enableFileSink) {
+      const filePath = this.logFilePath;
+      if (filePath) {
+        appendLine({ filePath, maxFileSizeBytes: this.maxFileSizeBytes, maxFiles: this.maxFiles }, line);
+      }
     }
+    logBuffer.push({
+      ts,
+      level: LOG_LEVEL_BUFFER_TAGS[level],
+      message,
+      ...meta ? { meta } : {}
+    });
   }
   debug(message, meta) {
     if (this.shouldLog(LogLevel.DEBUG)) {
-      this.write(this.formatMessage("DEBUG", message, meta), LogLevel.DEBUG);
+      this.emit(LogLevel.DEBUG, message, meta);
     }
   }
   info(message, meta) {
     if (this.shouldLog(LogLevel.INFO)) {
-      this.write(this.formatMessage("INFO", message, meta), LogLevel.INFO);
+      this.emit(LogLevel.INFO, message, meta);
     }
   }
   warn(message, meta) {
     if (this.shouldLog(LogLevel.WARN)) {
-      this.write(this.formatMessage("WARN", message, meta), LogLevel.WARN);
+      this.emit(LogLevel.WARN, message, meta);
     }
   }
   error(message, error, meta) {
@@ -7036,7 +7449,7 @@ class Logger {
           stack: error.stack
         }
       } : meta;
-      this.write(this.formatMessage("ERROR", message, errorMeta), LogLevel.ERROR);
+      this.emit(LogLevel.ERROR, message, errorMeta);
     }
   }
   metric(name, value, unit) {
@@ -7065,15 +7478,29 @@ class Logger {
     return childLogger;
   }
 }
-var LogLevel, logger;
+var LogLevel, LOG_LEVEL_LABELS, LOG_LEVEL_BUFFER_TAGS, logger;
 var init_logger = __esm(() => {
   init_config();
+  init_log_sink();
+  init_log_buffer();
   (function(LogLevel2) {
     LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
     LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
     LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
     LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   })(LogLevel || (LogLevel = {}));
+  LOG_LEVEL_LABELS = {
+    [LogLevel.DEBUG]: "DEBUG",
+    [LogLevel.INFO]: "INFO",
+    [LogLevel.WARN]: "WARN",
+    [LogLevel.ERROR]: "ERROR"
+  };
+  LOG_LEVEL_BUFFER_TAGS = {
+    [LogLevel.DEBUG]: "debug",
+    [LogLevel.INFO]: "info",
+    [LogLevel.WARN]: "warn",
+    [LogLevel.ERROR]: "error"
+  };
   logger = new Logger;
 });
 
@@ -7356,6 +7783,8 @@ var init_rate_limiter = __esm(() => {
 // ../../packages/shared/dist/utils/index.js
 var init_utils = __esm(() => {
   init_logger();
+  init_log_buffer();
+  init_log_sink();
   init_sanitizer();
   init_metrics();
   init_rate_limiter();
@@ -7363,7 +7792,7 @@ var init_utils = __esm(() => {
 
 // ../../packages/shared/dist/profile-switch/hosts.js
 import os3 from "os";
-import path7 from "path";
+import path8 from "path";
 function isHost(v) {
   return typeof v === "string" && HOSTS.includes(v);
 }
@@ -7374,7 +7803,7 @@ function fileLayout(host, activeDir, activeGlob, variantsRoot) {
     activeDir,
     activeGlob,
     variantsRoot,
-    variantDir: (profile) => path7.join(variantsRoot, profile)
+    variantDir: (profile) => path8.join(variantsRoot, profile)
   };
 }
 function resolveHostLayout(host, opts = {}) {
@@ -7384,25 +7813,37 @@ function resolveHostLayout(host, opts = {}) {
     case "cursor":
       return { host, route: "skip", reason: CURSOR_SKIP_REASON };
     case "claude": {
-      const root = override ?? path7.join(targetHome, ".claude");
-      return fileLayout(host, path7.join(root, "agents"), "massa-ai-*.md", path7.join(root, "massa-ai", "agent-profiles"));
+      const marketplaceRoot = opts.marketplaceRoot?.claude;
+      if (override === undefined && marketplaceRoot !== undefined) {
+        return fileLayout(host, path8.join(marketplaceRoot, "agents"), "massa-ai-*.md", path8.join(marketplaceRoot, "agent-profiles"));
+      }
+      const root = override ?? path8.join(targetHome, ".claude");
+      return fileLayout(host, path8.join(root, "agents"), "massa-ai-*.md", path8.join(root, "massa-ai", "agent-profiles"));
     }
     case "codex": {
-      const root = override ?? path7.join(targetHome, ".codex");
-      return fileLayout(host, path7.join(root, "agents"), "massa-ai-*.toml", path7.join(root, "massa-ai", "agent-profiles"));
+      const root = override ?? path8.join(targetHome, ".codex");
+      return fileLayout(host, path8.join(root, "agents"), "massa-ai-*.toml", path8.join(root, "massa-ai", "agent-profiles"));
     }
     case "opencode": {
-      const root = override ?? path7.join(targetHome, ".config", "opencode");
-      const pluginsDir = path7.join(root, "plugins", "massa-ai");
-      return fileLayout(host, path7.join(root, "agents"), "massa-ai-*.md", path7.join(pluginsDir, "agent-profiles"));
+      const root = override ?? path8.join(targetHome, ".config", "opencode");
+      const pluginsDir = path8.join(root, "plugins", "massa-ai");
+      return fileLayout(host, path8.join(root, "agents"), "massa-ai-*.md", path8.join(pluginsDir, "agent-profiles"));
     }
   }
 }
-function detectRoute(platform) {
+function detectRoute(platform, host) {
   const route = platform?.installRoute;
   if (route === "file")
     return { kind: "proceed" };
   if (route === "marketplace") {
+    if (host === "claude")
+      return { kind: "proceed" };
+    if (host === "codex") {
+      return {
+        kind: "refuse",
+        reason: "codex marketplace-route installs are refused (in-place bundle rewrite would dirty a checkout " + "and break the drift gate) \u2014 use the dev path: MASSA_AI_MODEL_PROFILE + regenerate."
+      };
+    }
     return {
       kind: "refuse",
       reason: "claude/codex marketplace-route installs are refused (in-place bundle rewrite would dirty a checkout " + "and break the drift gate) \u2014 use the dev path: MASSA_AI_MODEL_PROFILE + regenerate."
@@ -7420,7 +7861,7 @@ var init_hosts = __esm(() => {
 
 // ../../packages/shared/dist/profile-switch/state.js
 import fs5 from "fs";
-import path8 from "path";
+import path9 from "path";
 function namedError(name, message) {
   const err = new InstallStateError(message);
   err.name = name;
@@ -7466,7 +7907,7 @@ function writeInstallState(filePath, state) {
   const text = `${JSON.stringify(validated, null, 2)}
 `;
   try {
-    fs5.mkdirSync(path8.dirname(filePath), { recursive: true });
+    fs5.mkdirSync(path9.dirname(filePath), { recursive: true });
     fs5.writeFileSync(filePath, text);
   } catch (err) {
     throw UnwritableInstallStateError(filePath, err.message);
@@ -7495,7 +7936,7 @@ var init_state = __esm(() => {
 
 // ../../packages/shared/dist/profile-switch/lock.js
 import fs6 from "fs";
-import path9 from "path";
+import path10 from "path";
 import os4 from "os";
 import crypto4 from "crypto";
 import { execFileSync } from "child_process";
@@ -7527,7 +7968,7 @@ function releaseIfOwned(lockDir, ownerPath, token) {
 }
 function acquireLock(stateFilePath, options = {}) {
   const lockDir = `${stateFilePath}.switch.lock`;
-  const ownerPath = path9.join(lockDir, "owner.json");
+  const ownerPath = path10.join(lockDir, "owner.json");
   const clock = options.clock ?? DEFAULT_CLOCK;
   const identity = options.identity ?? DEFAULT_IDENTITY;
   const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
@@ -7547,7 +7988,7 @@ function acquireLock(stateFilePath, options = {}) {
       token,
       timestamp: clock.now()
     };
-    fs6.mkdirSync(path9.dirname(ownerPath), { recursive: true });
+    fs6.mkdirSync(path10.dirname(ownerPath), { recursive: true });
     fs6.writeFileSync(ownerPath, JSON.stringify(record));
     return { lockDir, release: () => releaseIfOwned(lockDir, ownerPath, token) };
   };
@@ -7600,10 +8041,59 @@ var init_lock = __esm(() => {
   };
 });
 
-// ../../packages/shared/dist/profile-switch/engine.js
+// ../../packages/shared/dist/profile-switch/claude-marketplace.js
 import fs7 from "fs";
-import path10 from "path";
 import os5 from "os";
+import path11 from "path";
+function selectRecord(records) {
+  if (records.length === 0)
+    return;
+  const userScoped = records.filter((r2) => r2.scope === "user");
+  const pool = userScoped.length > 0 ? userScoped : records;
+  let best;
+  let bestTime = -Infinity;
+  for (const record of pool) {
+    const parsed = record.lastUpdated ? Date.parse(record.lastUpdated) : NaN;
+    if (Number.isFinite(parsed) && parsed >= bestTime) {
+      best = record;
+      bestTime = parsed;
+    }
+  }
+  return best ?? pool[pool.length - 1];
+}
+function resolveClaudeMarketplaceRoot(opts = {}) {
+  const targetHome = opts.targetHome ?? os5.homedir();
+  const pluginKey = opts.pluginKey ?? DEFAULT_PLUGIN_KEY;
+  const registryPath = path11.join(targetHome, ".claude", "plugins", "installed_plugins.json");
+  let records;
+  try {
+    const raw2 = fs7.readFileSync(registryPath, "utf8");
+    const parsed = JSON.parse(raw2);
+    records = parsed?.plugins?.[pluginKey];
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(records) || records.length === 0)
+    return null;
+  const selected = selectRecord(records);
+  const installPath = selected?.installPath;
+  if (!installPath)
+    return null;
+  try {
+    if (!fs7.existsSync(installPath))
+      return null;
+  } catch {
+    return null;
+  }
+  return installPath;
+}
+var DEFAULT_PLUGIN_KEY = "massa-ai@massa-ai";
+var init_claude_marketplace = () => {};
+
+// ../../packages/shared/dist/profile-switch/engine.js
+import fs8 from "fs";
+import path12 from "path";
+import os6 from "os";
 import crypto5 from "crypto";
 function namedError3(name, message) {
   const err = new SwitchEngineError(message);
@@ -7611,19 +8101,39 @@ function namedError3(name, message) {
   return err;
 }
 function defaultStatePath(targetHome) {
-  return path10.join(targetHome, ".config", "massa-ai", "install-state.json");
+  return path12.join(targetHome, ".config", "massa-ai", "install-state.json");
 }
 function resolveCommon(opts) {
-  const targetHome = opts.targetHome ?? os5.homedir();
+  const targetHome = opts.targetHome ?? os6.homedir();
   const stateFilePath = opts.stateFilePath ?? defaultStatePath(targetHome);
   return { targetHome, stateFilePath };
 }
+function marketplaceRoots(targetHome, state) {
+  return state.platforms.claude?.installRoute === "marketplace" ? { claude: resolveClaudeMarketplaceRoot({ targetHome }) ?? undefined } : {};
+}
+function claudeMarketplaceUnresolvedReason(targetHome) {
+  const registryPath = path12.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 = {}) {
   const { targetHome, stateFilePath } = resolveCommon(opts);
   const state = readInstallState(stateFilePath);
+  const roots = marketplaceRoots(targetHome, state);
   const universe = opts.hosts ?? HOSTS;
   const hosts = universe.map((host) => {
-    const layout = resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot });
+    if (host === "claude" && state.platforms.claude?.installRoute === "marketplace" && roots.claude === undefined) {
+      const platform2 = state.platforms.claude;
+      return {
+        host,
+        installed: false,
+        skipped: false,
+        skipReason: null,
+        activeProfile: platform2.modelProfile?.profile ?? opts.hostDefaults?.[host] ?? "balanced",
+        bundleVersion: platform2.plugin?.version ?? null,
+        availableProfiles: []
+      };
+    }
+    const layout = resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot, marketplaceRoot: roots });
     if (layout.route === "skip") {
       return {
         host,
@@ -7635,7 +8145,7 @@ function listProfiles(opts = {}) {
         availableProfiles: []
       };
     }
-    const installed = fs7.existsSync(layout.activeDir);
+    const installed = fs8.existsSync(layout.activeDir);
     const availableProfiles = listVariantProfiles(layout);
     const platform = state.platforms[host];
     return {
@@ -7651,9 +8161,9 @@ function listProfiles(opts = {}) {
   return { hosts };
 }
 function listVariantProfiles(layout) {
-  if (!fs7.existsSync(layout.variantsRoot))
+  if (!fs8.existsSync(layout.variantsRoot))
     return [];
-  return fs7.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  return fs8.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function matchesGlob(filename, glob) {
   const starIdx = glob.indexOf("*");
@@ -7664,50 +8174,50 @@ function matchesGlob(filename, glob) {
   return filename.length >= prefix.length + suffix.length && filename.startsWith(prefix) && filename.endsWith(suffix);
 }
 function assertStateWritable(stateFilePath) {
-  const dir = path10.dirname(stateFilePath);
+  const dir = path12.dirname(stateFilePath);
   try {
-    fs7.mkdirSync(dir, { recursive: true });
+    fs8.mkdirSync(dir, { recursive: true });
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
-  const checkPath = fs7.existsSync(stateFilePath) ? stateFilePath : dir;
+  const checkPath = fs8.existsSync(stateFilePath) ? stateFilePath : dir;
   try {
-    fs7.accessSync(checkPath, fs7.constants.W_OK);
+    fs8.accessSync(checkPath, fs8.constants.W_OK);
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
 }
 function copyFileRouteVariant(layout, variantDir) {
-  fs7.mkdirSync(layout.activeDir, { recursive: true });
+  fs8.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs7.readdirSync(variantDir, { withFileTypes: true })) {
+  for (const entry of fs8.readdirSync(variantDir, { withFileTypes: true })) {
     if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
       continue;
-    fs7.copyFileSync(path10.join(variantDir, entry.name), path10.join(layout.activeDir, entry.name));
+    fs8.copyFileSync(path12.join(variantDir, entry.name), path12.join(layout.activeDir, entry.name));
     changed++;
   }
   return changed;
 }
 function repointOpencodeVariant(layout, variantDir) {
-  fs7.mkdirSync(layout.activeDir, { recursive: true });
+  fs8.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs7.readdirSync(variantDir, { withFileTypes: true })) {
+  for (const entry of fs8.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 = path12.join(layout.activeDir, entry.name);
+    const target = path12.resolve(path12.join(variantDir, entry.name));
     let destExists = true;
     let destIsSymlink = false;
     try {
-      destIsSymlink = fs7.lstatSync(dest).isSymbolicLink();
+      destIsSymlink = fs8.lstatSync(dest).isSymbolicLink();
     } catch {
       destExists = false;
     }
     if (destExists && !destIsSymlink)
       continue;
     const tmp = `${dest}.massa-ai-switch.${crypto5.randomUUID()}`;
-    fs7.symlinkSync(target, tmp);
-    fs7.renameSync(tmp, dest);
+    fs8.symlinkSync(target, tmp);
+    fs8.renameSync(tmp, dest);
     changed++;
   }
   return changed;
@@ -7723,19 +8233,37 @@ function switchProfile(opts) {
   const state = readInstallState(stateFilePath);
   if (!dryRun)
     assertStateWritable(stateFilePath);
-  const layouts = universe.map((host) => ({ host, layout: resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot }) }));
-  const skipRows = layouts.filter((l2) => l2.layout.route === "skip").map((l2) => ({ host: l2.host, status: "skipped", reason: l2.layout.reason }));
+  const roots = marketplaceRoots(targetHome, state);
+  const unresolvedRows = [];
+  const resolvableUniverse = universe.filter((host) => {
+    if (host !== "claude")
+      return true;
+    if (state.platforms.claude?.installRoute !== "marketplace")
+      return true;
+    if (roots.claude !== undefined)
+      return true;
+    unresolvedRows.push({ host, status: "failed", reason: claudeMarketplaceUnresolvedReason(targetHome) });
+    return false;
+  });
+  const layouts = resolvableUniverse.map((host) => ({
+    host,
+    layout: resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot, marketplaceRoot: roots })
+  }));
+  const skipRows = [
+    ...unresolvedRows,
+    ...layouts.filter((l2) => l2.layout.route === "skip").map((l2) => ({ host: l2.host, status: "skipped", reason: l2.layout.reason }))
+  ];
   const fileHosts = layouts.filter((l2) => l2.layout.route === "files");
   if (fileHosts.length === 0) {
     return { profile: opts.profile, dryRun, hosts: orderRows(universe, skipRows), restartRequired: false };
   }
-  const installedFileHosts = fileHosts.filter((h) => fs7.existsSync(h.layout.activeDir));
+  const installedFileHosts = fileHosts.filter((h) => fs8.existsSync(h.layout.activeDir));
   if (installedFileHosts.length === 0)
     throw NoHostsDetectedError();
   const withAvailability = fileHosts.map((h) => {
-    const variantsRootExists = fs7.existsSync(h.layout.variantsRoot);
+    const variantsRootExists = fs8.existsSync(h.layout.variantsRoot);
     const variantDir = h.layout.variantDir(opts.profile);
-    const available = variantsRootExists && fs7.existsSync(variantDir) && fs7.statSync(variantDir).isDirectory();
+    const available = variantsRootExists && fs8.existsSync(variantDir) && fs8.statSync(variantDir).isDirectory();
     return { ...h, variantsRootExists, variantDir, available };
   });
   if (!withAvailability.some((h) => h.available)) {
@@ -7765,7 +8293,7 @@ function switchProfile(opts) {
         });
         continue;
       }
-      const route = detectRoute(state.platforms[h.host]);
+      const route = detectRoute(state.platforms[h.host], h.host);
       if (route.kind === "refuse") {
         rows.push({ host: h.host, status: "failed", reason: route.reason });
         continue;
@@ -7800,6 +8328,7 @@ var init_engine = __esm(() => {
   init_hosts();
   init_state();
   init_lock();
+  init_claude_marketplace();
   SwitchEngineError = class SwitchEngineError extends Error {
     constructor(message) {
       super(message);
@@ -7814,18 +8343,25 @@ function reportSucceeded(report) {
 }
 
 // ../../packages/shared/dist/profile-switch/variant-sync.js
-import fs8 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path13 from "path";
+import os7 from "os";
 import crypto6 from "crypto";
+function defaultStatePath2(targetHome) {
+  return path13.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}.${crypto6.randomBytes(6).toString("hex")}`;
-  const tempFile = path11.join(destDir, `.${destName}.${unique}.tmp`);
+  const tempFile = path13.join(destDir, `.${destName}.${unique}.tmp`);
   try {
-    fs8.writeFileSync(tempFile, content);
-    fs8.renameSync(tempFile, path11.join(destDir, destName));
+    fs9.writeFileSync(tempFile, content);
+    fs9.renameSync(tempFile, path13.join(destDir, destName));
   } catch (error) {
     try {
-      fs8.unlinkSync(tempFile);
+      fs9.unlinkSync(tempFile);
     } catch {}
     throw error;
   }
@@ -7833,20 +8369,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(path13.sep))
     return false;
-  return path11.basename(name) === name;
+  return path13.basename(name) === name;
 }
-function syncHost(host, sourceRoot, targetHome) {
-  const layout = resolveHostLayout(host, { targetHome });
+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 (!fs8.existsSync(srcDir) || !fs8.statSync(srcDir).isDirectory()) {
+  const srcDir = path13.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
+  if (!fs9.existsSync(srcDir) || !fs9.statSync(srcDir).isDirectory()) {
     return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: "no generated variants for this host" };
   }
-  if (!fs8.existsSync(layout.variantsRoot)) {
+  if (!fs9.existsSync(layout.variantsRoot)) {
     return {
       host,
       status: "skipped",
@@ -7858,24 +8394,24 @@ function syncHost(host, sourceRoot, targetHome) {
   }
   const profiles = [];
   let files = 0;
-  for (const entry of fs8.readdirSync(srcDir, { withFileTypes: true })) {
+  for (const entry of fs9.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);
-    fs8.mkdirSync(destProfileDir, { recursive: true });
-    for (const fileEntry of fs8.readdirSync(srcProfileDir, { withFileTypes: true })) {
+    const srcProfileDir = path13.join(srcDir, entry.name);
+    const destProfileDir = path13.join(layout.variantsRoot, entry.name);
+    fs9.mkdirSync(destProfileDir, { recursive: true });
+    for (const fileEntry of fs9.readdirSync(srcProfileDir, { withFileTypes: true })) {
       if (!fileEntry.isFile())
         continue;
-      const content = fs8.readFileSync(path11.join(srcProfileDir, fileEntry.name));
+      const content = fs9.readFileSync(path13.join(srcProfileDir, fileEntry.name));
       writeFileIntoDirAtomically(destProfileDir, fileEntry.name, content);
       files++;
     }
     profiles.push(entry.name);
   }
-  const retained = fs8.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && !profiles.includes(e.name)).map((e) => e.name).sort();
+  const retained = fs9.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) {
@@ -7891,9 +8427,12 @@ function syncGeneratedVariants(opts) {
     }));
   }
   const sourceRoot = opts.sourceRoot;
+  const targetHome = opts.targetHome ?? os7.homedir();
+  const state = readInstallState(defaultStatePath2(targetHome));
+  const roots = marketplaceRoots2(targetHome, state);
   return hosts.map((host) => {
     try {
-      return syncHost(host, sourceRoot, opts.targetHome);
+      return syncHost(host, sourceRoot, opts.targetHome, roots);
     } catch (err) {
       return { host, status: "failed", profiles: [], retained: [], files: 0, error: err.message };
     }
@@ -7902,17 +8441,19 @@ function syncGeneratedVariants(opts) {
 var tempFileCounter2 = 0;
 var init_variant_sync = __esm(() => {
   init_hosts();
+  init_state();
+  init_claude_marketplace();
 });
 
 // ../../packages/shared/dist/profile-switch/repo-root.js
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path14 from "path";
 function findRepoRootWithMarker(startDir, marker, maxLevels) {
   let dir = startDir;
   for (let i = 0;i <= maxLevels; i++) {
-    if (fs9.existsSync(path12.join(dir, marker)))
+    if (fs10.existsSync(path14.join(dir, marker)))
       return dir;
-    const parent = path12.dirname(dir);
+    const parent = path14.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -9452,7 +9993,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path13, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a12, b = {}) => Object.assign({}, a12, b), defaults = (def) => {
+}, defaultPlatform, path15, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a12, b = {}) => Object.assign({}, a12, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -9510,11 +10051,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";
-  path13 = {
+  path15 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep = defaultPlatform === "win32" ? path13.win32.sep : path13.posix.sep;
+  sep = defaultPlatform === "win32" ? path15.win32.sep : path15.posix.sep;
   minimatch.sep = sep;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -11480,12 +12021,12 @@ var init_esm4 = __esm(() => {
     childrenCache() {
       return this.#children;
     }
-    resolve(path14) {
-      if (!path14) {
+    resolve(path16) {
+      if (!path16) {
         return this;
       }
-      const rootPath = this.getRootString(path14);
-      const dir = path14.substring(rootPath.length);
+      const rootPath = this.getRootString(path16);
+      const dir = path16.substring(rootPath.length);
       const dirParts = dir.split(this.splitSep);
       const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
       return result;
@@ -12013,8 +12554,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(path14) {
-      return win32.parse(path14).root;
+    getRootString(path16) {
+      return win32.parse(path16).root;
     }
     getRoot(rootPath) {
       rootPath = uncToDrive(rootPath.toUpperCase());
@@ -12039,8 +12580,8 @@ var init_esm4 = __esm(() => {
     constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
       super(name, type, root, roots, nocase, children, opts);
     }
-    getRootString(path14) {
-      return path14.startsWith("/") ? "/" : "";
+    getRootString(path16) {
+      return path16.startsWith("/") ? "/" : "";
     }
     getRoot(_rootPath) {
       return this.root;
@@ -12059,8 +12600,8 @@ var init_esm4 = __esm(() => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs10 = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs10);
+    constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs11 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs11);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = fileURLToPath(cwd);
       }
@@ -12096,11 +12637,11 @@ var init_esm4 = __esm(() => {
       }
       this.cwd = prev;
     }
-    depth(path14 = this.cwd) {
-      if (typeof path14 === "string") {
-        path14 = this.cwd.resolve(path14);
+    depth(path16 = this.cwd) {
+      if (typeof path16 === "string") {
+        path16 = this.cwd.resolve(path16);
       }
-      return path14.depth();
+      return path16.depth();
     }
     childrenCache() {
       return this.#children;
@@ -12516,9 +13057,9 @@ var init_esm4 = __esm(() => {
       process2();
       return results;
     }
-    chdir(path14 = this.cwd) {
+    chdir(path16 = this.cwd) {
       const oldCwd = this.cwd;
-      this.cwd = typeof path14 === "string" ? this.cwd.resolve(path14) : path14;
+      this.cwd = typeof path16 === "string" ? this.cwd.resolve(path16) : path16;
       this.cwd[setAsCwd](oldCwd);
     }
   };
@@ -12535,8 +13076,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(dir) {
       return win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs10) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs10 });
+    newRoot(fs11) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs11 });
     }
     isAbsolute(p) {
       return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -12552,8 +13093,8 @@ var init_esm4 = __esm(() => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs10) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs10 });
+    newRoot(fs11) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs11 });
     }
     isAbsolute(p) {
       return p.startsWith("/");
@@ -12810,8 +13351,8 @@ class MatchRecord {
     this.store.set(target, current === undefined ? n2 : n2 & current);
   }
   entries() {
-    return [...this.store.entries()].map(([path14, n2]) => [
-      path14,
+    return [...this.store.entries()].map(([path16, n2]) => [
+      path16,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -13015,9 +13556,9 @@ class GlobUtil {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path14, opts) {
+  constructor(patterns, path16, opts) {
     this.patterns = patterns;
-    this.path = path14;
+    this.path = path16;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -13036,11 +13577,11 @@ class GlobUtil {
       });
     }
   }
-  #ignored(path14) {
-    return this.seen.has(path14) || !!this.#ignore?.ignored?.(path14);
+  #ignored(path16) {
+    return this.seen.has(path16) || !!this.#ignore?.ignored?.(path16);
   }
-  #childrenIgnored(path14) {
-    return !!this.#ignore?.childrenIgnored?.(path14);
+  #childrenIgnored(path16) {
+    return !!this.#ignore?.childrenIgnored?.(path16);
   }
   pause() {
     this.paused = true;
@@ -13257,8 +13798,8 @@ var init_walker = __esm(() => {
   init_processor();
   GlobWalker = class GlobWalker extends GlobUtil {
     matches = new Set;
-    constructor(patterns, path14, opts) {
-      super(patterns, path14, opts);
+    constructor(patterns, path16, opts) {
+      super(patterns, path16, opts);
     }
     matchEmit(e) {
       this.matches.add(e);
@@ -13295,8 +13836,8 @@ var init_walker = __esm(() => {
   };
   GlobStream = class GlobStream extends GlobUtil {
     results;
-    constructor(patterns, path14, opts) {
-      super(patterns, path14, opts);
+    constructor(patterns, path16, opts) {
+      super(patterns, path16, opts);
       this.results = new Minipass({
         signal: this.signal,
         objectMode: true
@@ -13724,20 +14265,20 @@ var require_ignore = __commonJS((exports, module) => {
   var throwError = (message, Ctor) => {
     throw new Ctor(message);
   };
-  var checkPath = (path14, originalPath, doThrow) => {
-    if (!isString(path14)) {
+  var checkPath = (path16, originalPath, doThrow) => {
+    if (!isString(path16)) {
       return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
     }
-    if (!path14) {
+    if (!path16) {
       return doThrow(`path must not be empty`, TypeError);
     }
-    if (checkPath.isNotRelative(path14)) {
+    if (checkPath.isNotRelative(path16)) {
       const r2 = "`path.relative()`d";
       return doThrow(`path should be a ${r2} string, but got "${originalPath}"`, RangeError);
     }
     return true;
   };
-  var isNotRelative = (path14) => REGEX_TEST_INVALID_PATH.test(path14);
+  var isNotRelative = (path16) => REGEX_TEST_INVALID_PATH.test(path16);
   checkPath.isNotRelative = isNotRelative;
   checkPath.convert = (p) => p;
 
@@ -13780,7 +14321,7 @@ var require_ignore = __commonJS((exports, module) => {
     addPattern(pattern) {
       return this.add(pattern);
     }
-    _testOne(path14, checkUnignored) {
+    _testOne(path16, checkUnignored) {
       let ignored = false;
       let unignored = false;
       this._rules.forEach((rule) => {
@@ -13788,7 +14329,7 @@ var require_ignore = __commonJS((exports, module) => {
         if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
           return;
         }
-        const matched = rule.regex.test(path14);
+        const matched = rule.regex.test(path16);
         if (matched) {
           ignored = !negative;
           unignored = negative;
@@ -13800,39 +14341,39 @@ var require_ignore = __commonJS((exports, module) => {
       };
     }
     _test(originalPath, cache, checkUnignored, slices) {
-      const path14 = originalPath && checkPath.convert(originalPath);
-      checkPath(path14, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
-      return this._t(path14, cache, checkUnignored, slices);
+      const path16 = originalPath && checkPath.convert(originalPath);
+      checkPath(path16, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path16, cache, checkUnignored, slices);
     }
-    _t(path14, cache, checkUnignored, slices) {
-      if (path14 in cache) {
-        return cache[path14];
+    _t(path16, cache, checkUnignored, slices) {
+      if (path16 in cache) {
+        return cache[path16];
       }
       if (!slices) {
-        slices = path14.split(SLASH);
+        slices = path16.split(SLASH);
       }
       slices.pop();
       if (!slices.length) {
-        return cache[path14] = this._testOne(path14, checkUnignored);
+        return cache[path16] = this._testOne(path16, checkUnignored);
       }
       const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-      return cache[path14] = parent.ignored ? parent : this._testOne(path14, checkUnignored);
+      return cache[path16] = parent.ignored ? parent : this._testOne(path16, checkUnignored);
     }
-    ignores(path14) {
-      return this._test(path14, this._ignoreCache, false).ignored;
+    ignores(path16) {
+      return this._test(path16, this._ignoreCache, false).ignored;
     }
     createFilter() {
-      return (path14) => !this.ignores(path14);
+      return (path16) => !this.ignores(path16);
     }
     filter(paths) {
       return makeArray(paths).filter(this.createFilter());
     }
-    test(path14) {
-      return this._test(path14, this._testCache, true);
+    test(path16) {
+      return this._test(path16, this._testCache, true);
     }
   }
   var factory = (options) => new Ignore2(options);
-  var isPathValid = (path14) => checkPath(path14 && checkPath.convert(path14), path14, RETURN_FALSE);
+  var isPathValid = (path16) => checkPath(path16 && checkPath.convert(path16), path16, RETURN_FALSE);
   factory.isPathValid = isPathValid;
   factory.default = factory;
   module.exports = factory;
@@ -13840,7 +14381,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 = (path14) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path14) || isNotRelative(path14);
+    checkPath.isNotRelative = (path16) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path16) || isNotRelative(path16);
   }
 });
 
@@ -13892,7 +14433,7 @@ function validatePolicy(policy, opts = {}) {
   if (!Array.isArray(p.rules))
     throw new TypeError("policy.rules must be an array");
   const dropCount = p.rules.filter((r2) => r2?.disposition === "Drop").length;
-  const maxIgnore = typeof p.maxIgnorePatterns === "number" ? p.maxIgnorePatterns : MAX_IGNORE_PATTERNS2;
+  const maxIgnore = typeof p.maxIgnorePatterns === "number" ? p.maxIgnorePatterns : MAX_IGNORE_PATTERNS;
   if (dropCount > maxIgnore) {
     throw new TypeError(`policy: ${dropCount} Drop rules exceed maxIgnorePatterns=${maxIgnore}`);
   }
@@ -13902,15 +14443,15 @@ function validatePolicy(policy, opts = {}) {
     }
   }
 }
-function matchesGlob2(path14, pattern) {
+function matchesGlob2(path16, pattern) {
   let re = regexCache.get(pattern);
   if (!re) {
     re = globToRegex(pattern);
     regexCache.set(pattern, re);
   }
-  return re.test(path14);
+  return re.test(path16);
 }
-var MAX_MATCH_WORK = 1e5, MAX_IGNORE_PATTERNS2 = 1024, DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
+var DEFAULT_POLICY, applyPolicy = (filePath, policy) => {
   const normalized = filePath.trim();
   for (const rule of policy.rules) {
     if (matchesGlob2(normalized, rule.pattern))
@@ -13919,48 +14460,14 @@ var MAX_MATCH_WORK = 1e5, MAX_IGNORE_PATTERNS2 = 1024, DEFAULT_POLICY, applyPoli
   return "Keep";
 }, regexCache;
 var init_capture_policy = __esm(() => {
-  DEFAULT_POLICY = {
-    rules: [
-      { pattern: "**/node_modules/**", disposition: "Drop" },
-      { pattern: "**/.git/**", disposition: "Drop" },
-      { pattern: "**/dist/**", disposition: "Drop" },
-      { pattern: "**/build/**", disposition: "Drop" },
-      { pattern: "**/coverage/**", disposition: "Drop" },
-      { pattern: ".env", disposition: "Drop" },
-      { pattern: ".env.*", disposition: "Drop" },
-      { pattern: "**/generated/**", disposition: "Drop" },
-      { pattern: "**/*.generated.*", disposition: "Drop" },
-      { pattern: "**/*.d.ts", disposition: "Drop" },
-      { pattern: "**/__tests__/**", disposition: "Drop" },
-      { pattern: "**/tests/**", disposition: "Drop" },
-      { pattern: "**/*.test.ts", disposition: "Drop" },
-      { pattern: "**/*.test.tsx", disposition: "Drop" },
-      { pattern: "**/*.test.js", disposition: "Drop" },
-      { pattern: "**/*.test.jsx", disposition: "Drop" },
-      { pattern: "**/*.spec.ts", disposition: "Drop" },
-      { pattern: "**/*.spec.tsx", disposition: "Drop" },
-      { pattern: "**/*.spec.js", disposition: "Drop" },
-      { pattern: "**/*.spec.jsx", disposition: "Drop" },
-      { pattern: "**/benchmarks/**", disposition: "Drop" },
-      { pattern: "**/fixtures/**", disposition: "Drop" },
-      { pattern: "**/*.wasm*", disposition: "Drop" },
-      { pattern: "**/*.min.*", disposition: "Drop" },
-      { pattern: "**/*.map", disposition: "Drop" },
-      { pattern: "**/lock.yaml", disposition: "Drop" },
-      { pattern: "**/pnpm-lock.yaml", disposition: "Drop" },
-      { pattern: "**/package-lock.json", disposition: "Drop" },
-      { pattern: "**/bun.lockb", disposition: "Drop" },
-      { pattern: "**/yarn.lock", disposition: "Drop" }
-    ],
-    maxMatchWork: MAX_MATCH_WORK,
-    maxIgnorePatterns: MAX_IGNORE_PATTERNS2
-  };
+  init_dist();
+  DEFAULT_POLICY = DEFAULT_CAPTURE_POLICY;
   regexCache = new Map;
 });
 
 // ../../packages/core/dist/services/search/ignore-patterns.js
-import fs10 from "fs/promises";
-import path14 from "path";
+import fs11 from "fs/promises";
+import path16 from "path";
 function buildExtensionGlob(extensions2) {
   return extensions2.map((ext2) => `**/*${ext2}`);
 }
@@ -13983,8 +14490,8 @@ async function loadProjectIgnore(projectPath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
   try {
-    const gitignorePath = path14.join(projectPath, ".gitignore");
-    const gitignoreContent = await fs10.readFile(gitignorePath, "utf8");
+    const gitignorePath = path16.join(projectPath, ".gitignore");
+    const gitignoreContent = await fs11.readFile(gitignorePath, "utf8");
     const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     ig.add(rules);
@@ -14235,8 +14742,8 @@ var init_alias_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/index-manager.js
-import fs11 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path17 from "path";
 
 class IndexManager {
   metadataCache = new Map;
@@ -14329,9 +14836,9 @@ class IndexManager {
       const fileMetadata = {};
       let totalSize = 0;
       for (const filePath of indexedFiles) {
-        const fullPath = path15.join(projectPath, filePath);
+        const fullPath = path17.join(projectPath, filePath);
         try {
-          const stat2 = await fs11.promises.stat(fullPath);
+          const stat2 = await fs12.promises.stat(fullPath);
           fileMetadata[filePath] = {
             path: filePath,
             mtime: stat2.mtimeMs,
@@ -14382,9 +14889,9 @@ class IndexManager {
         if (ig.ignores(match2)) {
           continue;
         }
-        const fullPath = path15.join(projectPath, match2);
+        const fullPath = path17.join(projectPath, match2);
         try {
-          const stat2 = await fs11.promises.stat(fullPath);
+          const stat2 = await fs12.promises.stat(fullPath);
           files.set(match2, {
             path: match2,
             mtime: stat2.mtimeMs,
@@ -14835,10 +15342,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path16) {
-  if (!path16)
+function getElementAtPath(obj, path18) {
+  if (!path18)
     return obj;
-  return path16.reduce((acc, key) => acc?.[key], obj);
+  return path18.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -15166,11 +15673,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path16, issues) {
+function prefixIssues(path18, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path16);
+    iss.path.unshift(path18);
     return iss;
   });
 }
@@ -15383,16 +15890,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path16 = []) => {
+  const processError = (error2, path18 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -15419,17 +15926,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path16 = []) => {
+  const processError = (error2, path18 = []) => {
     var _a4, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -15461,8 +15968,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path16 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path16) {
+  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path18) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -28465,13 +28972,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path16 = ref.slice(1).split("/").filter(Boolean);
-  if (path16.length === 0) {
+  const path18 = ref.slice(1).split("/").filter(Boolean);
+  if (path18.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path16[0] === defsKey) {
-    const key = path16[1];
+  if (path18[0] === defsKey) {
+    const key = path18[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -29960,8 +30467,8 @@ class ParseStatus2 {
   }
 }
 var makeIssue2 = (params) => {
-  const { data, path: path16, errorMaps, issueData } = params;
-  const fullPath = [...path16, ...issueData.path || []];
+  const { data, path: path18, errorMaps, issueData } = params;
+  const fullPath = [...path18, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -30006,11 +30513,11 @@ var init_errorUtil = __esm(() => {
 
 // ../../node_modules/zod/v3/types.js
 class ParseInputLazyPath2 {
-  constructor(parent, value, path16, key) {
+  constructor(parent, value, path18, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path16;
+    this._path = path18;
     this._key = key;
   }
   get path() {
@@ -36007,19 +36514,19 @@ var require_token_io = __commonJS((exports, module) => {
     getUserDataDir: () => getUserDataDir
   });
   module.exports = __toCommonJS2(token_io_exports);
-  var import_path10 = __toESM2(__require("path"));
-  var import_fs7 = __toESM2(__require("fs"));
+  var import_path11 = __toESM2(__require("path"));
+  var import_fs8 = __toESM2(__require("fs"));
   var import_os3 = __toESM2(__require("os"));
   var import_token_error = require_token_error();
   function findRootDir() {
     try {
       let dir = process.cwd();
-      while (dir !== import_path10.default.dirname(dir)) {
-        const pkgPath = import_path10.default.join(dir, ".vercel");
-        if (import_fs7.default.existsSync(pkgPath)) {
+      while (dir !== import_path11.default.dirname(dir)) {
+        const pkgPath = import_path11.default.join(dir, ".vercel");
+        if (import_fs8.default.existsSync(pkgPath)) {
           return dir;
         }
-        dir = import_path10.default.dirname(dir);
+        dir = import_path11.default.dirname(dir);
       }
     } catch (e) {
       throw new import_token_error.VercelOidcTokenError("Token refresh only supported in node server environments");
@@ -36032,9 +36539,9 @@ var require_token_io = __commonJS((exports, module) => {
     }
     switch (import_os3.default.platform()) {
       case "darwin":
-        return import_path10.default.join(import_os3.default.homedir(), "Library/Application Support");
+        return import_path11.default.join(import_os3.default.homedir(), "Library/Application Support");
       case "linux":
-        return import_path10.default.join(import_os3.default.homedir(), ".local/share");
+        return import_path11.default.join(import_os3.default.homedir(), ".local/share");
       case "win32":
         if (process.env.LOCALAPPDATA) {
           return process.env.LOCALAPPDATA;
@@ -36075,23 +36582,23 @@ var require_auth_config = __commonJS((exports, module) => {
     writeAuthConfig: () => writeAuthConfig
   });
   module.exports = __toCommonJS2(auth_config_exports);
-  var fs12 = __toESM2(__require("fs"));
-  var path16 = __toESM2(__require("path"));
+  var fs13 = __toESM2(__require("fs"));
+  var path18 = __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 path16.join(dataDir, "auth.json");
+    return path18.join(dataDir, "auth.json");
   }
   function readAuthConfig() {
     try {
       const authPath = getAuthConfigPath();
-      if (!fs12.existsSync(authPath)) {
+      if (!fs13.existsSync(authPath)) {
         return null;
       }
-      const content = fs12.readFileSync(authPath, "utf8");
+      const content = fs13.readFileSync(authPath, "utf8");
       if (!content) {
         return null;
       }
@@ -36102,11 +36609,11 @@ var require_auth_config = __commonJS((exports, module) => {
   }
   function writeAuthConfig(config3) {
     const authPath = getAuthConfigPath();
-    const authDir = path16.dirname(authPath);
-    if (!fs12.existsSync(authDir)) {
-      fs12.mkdirSync(authDir, { mode: 504, recursive: true });
+    const authDir = path18.dirname(authPath);
+    if (!fs13.existsSync(authDir)) {
+      fs13.mkdirSync(authDir, { mode: 504, recursive: true });
     }
-    fs12.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
+    fs13.writeFileSync(authPath, JSON.stringify(config3, null, 2), { mode: 384 });
   }
   function isValidAccessToken(authConfig, expirationBufferMs = 0) {
     if (!authConfig.token)
@@ -36281,8 +36788,8 @@ var require_token_util = __commonJS((exports, module) => {
     saveToken: () => saveToken
   });
   module.exports = __toCommonJS2(token_util_exports);
-  var path16 = __toESM2(__require("path"));
-  var fs12 = __toESM2(__require("fs"));
+  var path18 = __toESM2(__require("path"));
+  var fs13 = __toESM2(__require("fs"));
   var import_token_error = require_token_error();
   var import_token_io = require_token_io();
   var import_auth_config = require_auth_config();
@@ -36294,7 +36801,7 @@ var require_token_util = __commonJS((exports, module) => {
     if (!dataDir) {
       return null;
     }
-    return path16.join(dataDir, vercelFolder);
+    return path18.join(dataDir, vercelFolder);
   }
   async function getVercelToken2(options) {
     const authConfig = (0, import_auth_config.readAuthConfig)();
@@ -36362,11 +36869,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 = path16.join(dir, ".vercel", "project.json");
-    if (!fs12.existsSync(prjPath)) {
+    const prjPath = path18.join(dir, ".vercel", "project.json");
+    if (!fs13.existsSync(prjPath)) {
       throw new import_token_error.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");
     }
-    const prj = JSON.parse(fs12.readFileSync(prjPath, "utf8"));
+    const prj = JSON.parse(fs13.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.");
     }
@@ -36377,11 +36884,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 = path16.join(dir, "com.vercel.token", `${projectId}.json`);
+    const tokenPath = path18.join(dir, "com.vercel.token", `${projectId}.json`);
     const tokenJson = JSON.stringify(token);
-    fs12.mkdirSync(path16.dirname(tokenPath), { mode: 504, recursive: true });
-    fs12.writeFileSync(tokenPath, tokenJson);
-    fs12.chmodSync(tokenPath, 432);
+    fs13.mkdirSync(path18.dirname(tokenPath), { mode: 504, recursive: true });
+    fs13.writeFileSync(tokenPath, tokenJson);
+    fs13.chmodSync(tokenPath, 432);
     return;
   }
   function loadToken(projectId) {
@@ -36389,11 +36896,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 = path16.join(dir, "com.vercel.token", `${projectId}.json`);
-    if (!fs12.existsSync(tokenPath)) {
+    const tokenPath = path18.join(dir, "com.vercel.token", `${projectId}.json`);
+    if (!fs13.existsSync(tokenPath)) {
       return null;
     }
-    const token = JSON.parse(fs12.readFileSync(tokenPath, "utf8"));
+    const token = JSON.parse(fs13.readFileSync(tokenPath, "utf8"));
     assertVercelOidcTokenResponse(token);
     return token;
   }
@@ -47235,37 +47742,37 @@ function createOpenAI(options = {}) {
   }, `ai-sdk/openai/${VERSION4}`);
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path16 }) => `${baseURL}${path16}`,
+    url: ({ path: path18 }) => `${baseURL}${path18}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -47278,7 +47785,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path16 }) => `${baseURL}${path16}`,
+      url: ({ path: path18 }) => `${baseURL}${path18}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -63823,26 +64330,26 @@ var require_process = __commonJS((exports, module) => {
 
 // ../../node_modules/detect-libc/lib/filesystem.js
 var require_filesystem = __commonJS((exports, module) => {
-  var fs12 = __require("fs");
+  var fs13 = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync2 = (path16) => {
-    const fd = fs12.openSync(path16, "r");
+  var readFileSync2 = (path18) => {
+    const fd = fs13.openSync(path18, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs12.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs12.close(fd, () => {});
+    const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs13.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile = (path16) => new Promise((resolve4, reject) => {
-    fs12.open(path16, "r", (err, fd) => {
+  var readFile = (path18) => new Promise((resolve4, reject) => {
+    fs13.open(path18, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
-        fs12.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
+        fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_2, bytesRead) => {
           resolve4(buffer.subarray(0, bytesRead));
-          fs12.close(fd, () => {});
+          fs13.close(fd, () => {});
         });
       }
     });
@@ -63947,11 +64454,11 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     return null;
   };
-  var familyFromInterpreterPath = (path16) => {
-    if (path16) {
-      if (path16.includes("/ld-musl-")) {
+  var familyFromInterpreterPath = (path18) => {
+    if (path18) {
+      if (path18.includes("/ld-musl-")) {
         return MUSL;
-      } else if (path16.includes("/ld-linux-")) {
+      } else if (path18.includes("/ld-linux-")) {
         return GLIBC;
       }
     }
@@ -63996,8 +64503,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = await readFile(SELF_PATH);
-      const path16 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path16);
+      const path18 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path18);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -64008,8 +64515,8 @@ var require_detect_libc = __commonJS((exports, module) => {
     cachedFamilyInterpreter = null;
     try {
       const selfContent = readFileSync2(SELF_PATH);
-      const path16 = interpreterPath(selfContent);
-      cachedFamilyInterpreter = familyFromInterpreterPath(path16);
+      const path18 = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path18);
     } catch (e) {}
     return cachedFamilyInterpreter;
   };
@@ -65671,18 +66178,18 @@ var require_sharp = __commonJS((exports, module) => {
     `@img/sharp-${runtimePlatform}/sharp.node`,
     "@img/sharp-wasm32/sharp.node"
   ];
-  var path16;
+  var path18;
   var sharp;
   var errors5 = [];
-  for (path16 of paths) {
+  for (path18 of paths) {
     try {
-      sharp = __require(path16);
+      sharp = __require(path18);
       break;
     } catch (err) {
       errors5.push(err);
     }
   }
-  if (sharp && path16.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
+  if (sharp && path18.startsWith("@img/sharp-linux-x64") && !sharp._isUsingX64V2()) {
     const err = new Error("Prebuilt binaries for linux-x64 require v2 microarchitecture");
     err.code = "Unsupported CPU";
     errors5.push(err);
@@ -65691,7 +66198,7 @@ var require_sharp = __commonJS((exports, module) => {
   if (sharp) {
     module.exports = sharp;
   } else {
-    const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os6) => runtimePlatform.startsWith(os6));
+    const [isLinux, isMacOs, isWindows] = ["linux", "darwin", "win32"].map((os8) => runtimePlatform.startsWith(os8));
     const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
     errors5.forEach((err) => {
       if (err.code !== "MODULE_NOT_FOUND") {
@@ -65704,9 +66211,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 [os6, cpu] = runtimePlatform.split("-");
-      const libc = os6.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=${os6.replace("musl", "")}${libc} --cpu=${cpu} sharp`);
+      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`);
     } else {
       help.push(`- Manually install libvips >= ${minimumLibvipsVersion}`, "- Add experimental WebAssembly-based dependencies:", "    npm install --cpu=wasm32 sharp", "    npm install @img/sharp-wasm32");
     }
@@ -66966,7 +67473,7 @@ var require_operation = __commonJS((exports, module) => {
     float: "float",
     approximate: "approximate"
   };
-  function rotate(angle, options) {
+  function rotate2(angle, options) {
     if (!is.defined(angle)) {
       return this.autoOrient();
     }
@@ -67393,7 +67900,7 @@ var require_operation = __commonJS((exports, module) => {
   module.exports = (Sharp) => {
     Object.assign(Sharp.prototype, {
       autoOrient,
-      rotate,
+      rotate: rotate2,
       flip,
       flop,
       affine,
@@ -68544,15 +69051,15 @@ var require_color = __commonJS((exports, module) => {
     };
   }
   function wrapConversion(toModel, graph) {
-    const path16 = [graph[toModel].parent, toModel];
+    const path18 = [graph[toModel].parent, toModel];
     let fn = conversions_default[graph[toModel].parent][toModel];
     let cur = graph[toModel].parent;
     while (graph[cur].parent) {
-      path16.unshift(graph[cur].parent);
+      path18.unshift(graph[cur].parent);
       fn = link(conversions_default[graph[cur].parent][cur], fn);
       cur = graph[cur].parent;
     }
-    fn.conversion = path16;
+    fn.conversion = path18;
     return fn;
   }
   function route(fromModel) {
@@ -69157,7 +69664,7 @@ var require_output = __commonJS((exports, module) => {
     Copyright 2013 Lovell Fuller and others.
     SPDX-License-Identifier: Apache-2.0
   */
-  var path16 = __require("path");
+  var path18 = __require("path");
   var is = require_is();
   var sharp = require_sharp();
   var formats = new Map([
@@ -69188,9 +69695,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) && path16.resolve(this.options.input.file) === path16.resolve(fileOut)) {
+    } else if (is.string(this.options.input.file) && path18.resolve(this.options.input.file) === path18.resolve(fileOut)) {
       err = new Error("Cannot use same file for input and output");
-    } else if (jp2Regex.test(path16.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
+    } else if (jp2Regex.test(path18.extname(fileOut)) && !this.constructor.format.jp2k.output.file) {
       err = errJp2Save();
     }
     if (err) {
@@ -76437,11 +76944,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 path16 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
-            const fullPath = `${options.subfolder ?? ""}/${path16}`;
+            const path18 = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+            const fullPath = `${options.subfolder ?? ""}/${path18}`;
             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: path16, data } : path16);
+              resolve4(data instanceof Uint8Array ? { path: path18, data } : path18);
             }));
           }
         } else if (session_options.externalData !== undefined) {
@@ -89505,7 +90012,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(path16) {
+        async save(path18) {
           let fn;
           if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_BROWSER_ENV) {
             if (_env_js__WEBPACK_IMPORTED_MODULE_3__.apis.IS_WEBWORKER_ENV) {
@@ -89513,14 +90020,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 (path17, blob) => {
+            fn = async (path19, blob) => {
               let buffer = await blob.arrayBuffer();
-              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path17, Buffer.from(buffer));
+              node_fs__WEBPACK_IMPORTED_MODULE_5__["default"].writeFileSync(path19, Buffer.from(buffer));
             };
           } else {
             throw new Error("Unable to save because filesystem is disabled in this environment.");
           }
-          await fn(path16, this.toBlob());
+          await fn(path18, this.toBlob());
         }
       }
     },
@@ -89616,11 +90123,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(path16, blob) {
+      function saveBlob(path18, blob) {
         const dataURL = URL.createObjectURL(blob);
         const downloadLink = document.createElement("a");
         downloadLink.href = dataURL;
-        downloadLink.download = path16;
+        downloadLink.download = path18;
         downloadLink.click();
         downloadLink.remove();
         URL.revokeObjectURL(dataURL);
@@ -90221,8 +90728,8 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
       }
 
       class FileCache {
-        constructor(path16) {
-          this.path = path16;
+        constructor(path18) {
+          this.path = path18;
         }
         async match(request) {
           let filePath = node_path__WEBPACK_IMPORTED_MODULE_1__["default"].join(this.path, request);
@@ -90978,20 +91485,20 @@ ${fake_token_around_image}` + `${global_img_token}` + image_token.repeat(image_s
           }
           return this;
         }
-        async save(path16) {
+        async save(path18) {
           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 = path16.split(".").pop().toLowerCase();
+            const extension = path18.split(".").pop().toLowerCase();
             const mime2 = CONTENT_TYPE_MAP.get(extension) ?? "image/png";
             const blob = await this.toBlob(mime2);
-            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path16, blob);
+            (0, _core_js__WEBPACK_IMPORTED_MODULE_0__.saveBlob)(path18, 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(path16);
+            return await img.toFile(path18);
           }
         }
         toSharp() {
@@ -94518,20 +95025,20 @@ function getRetryDelay(attempt, config3) {
   return Math.min(delay2, config3.maxDelay);
 }
 async function withRetry(fn, config3, context2) {
-  let lastError;
+  let lastError2;
   for (let attempt = 0;attempt <= config3.maxRetries; attempt++) {
     try {
       return await fn();
     } catch (error51) {
-      lastError = error51;
+      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: lastError.message });
+        logger.warn(`[EmbeddingProvider] ${context2} failed (attempt ${attempt + 1}/${config3.maxRetries + 1}), retrying in ${delay2}ms`, { error: lastError2.message });
         await sleep(delay2);
       }
     }
   }
-  throw new Error(`${context2} failed after ${config3.maxRetries + 1} attempts: ${lastError?.message}`);
+  throw new Error(`${context2} failed after ${config3.maxRetries + 1} attempts: ${lastError2?.message}`);
 }
 async function withTimeout(fn, timeoutMs, context2) {
   let timeoutId;
@@ -100217,7 +100724,7 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a12;
   function ns(e = Yo, t2 = Yo) {
     return (r2) => e(t2(r2));
   }
-  function os6({ dataPath: e, modelName: t2, args: r2, runtimeDataModel: n2 }) {
+  function os8({ dataPath: e, modelName: t2, args: r2, runtimeDataModel: n2 }) {
     let i = { modelName: t2, args: r2 ?? {} }, o = dp(e);
     if (!o || o.length === 0)
       return i;
@@ -100522,10 +101029,10 @@ Note that ${s.bold("include")} statements only accept relation fields.`, a12;
       super(t2, "P2023", r2);
     }
   };
-  var fs12 = new WeakMap;
+  var fs13 = new WeakMap;
   function Ep(e) {
-    let t2 = fs12.get(e);
-    return t2 || (t2 = Object.entries(e), fs12.set(e, t2)), t2;
+    let t2 = fs13.get(e);
+    return t2 || (t2 = Object.entries(e), fs13.set(e, t2)), t2;
   }
   function hs(e, t2, r2) {
     switch (t2.type) {
@@ -104090,7 +104597,7 @@ new PrismaClient({
           let m2 = await es(this, d);
           if (!d.model)
             return m2;
-          let g = os6({ dataPath: d.dataPath, modelName: d.model, args: d.args, runtimeDataModel: this._runtimeDataModel });
+          let g = os8({ dataPath: d.dataPath, modelName: d.model, args: d.args, runtimeDataModel: this._runtimeDataModel });
           return Wo({ result: m2, 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(() => a12(o)));
@@ -104493,7 +105000,7 @@ var require_prisma = __commonJS((exports) => {
   Prisma.JsonNull = JsonNull2;
   Prisma.AnyNull = AnyNull2;
   Prisma.NullTypes = NullTypes2;
-  var path16 = __require("path");
+  var path18 = __require("path");
   exports.Prisma.TransactionIsolationLevel = makeStrictEnum2({
     ReadUncommitted: "ReadUncommitted",
     ReadCommitted: "ReadCommitted",
@@ -106102,11 +106609,17 @@ var init_config2 = __esm(() => {
     ollama: (() => {
       const file3 = fileFor("ollama");
       const model = process.env.OLLAMA_EMBEDDING_MODEL || file3?.model || "qwen3-embedding:4b";
+      const rawEnvDimensions = Number(process.env.OLLAMA_EMBEDDING_DIMENSIONS);
+      const envDimensions = Number.isInteger(rawEnvDimensions) && rawEnvDimensions > 0 ? rawEnvDimensions : undefined;
+      const resolvedDimensions = resolveEmbeddingDimensions(model, file3?.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.");
+      }
       return {
         provider: "ollama",
         model,
         baseURL: process.env.OLLAMA_BASE_URL || file3?.baseURL || "http://localhost:11434",
-        dimensions: process.env.OLLAMA_EMBEDDING_DIMENSIONS ? Number(process.env.OLLAMA_EMBEDDING_DIMENSIONS) : file3?.dimensions ?? 2560,
+        dimensions: resolvedDimensions.dimensions,
         priority: selectedProvider === "ollama" ? 1 : 50,
         timeout: 300000,
         maxRetries: 2,
@@ -110641,7 +111154,7 @@ async function upsertWorkspace(ws) {
   }, { timeout: 60000, maxWait: 1e4 });
 }
 async function updateWorkspaceStatus(projectId, status2, opts) {
-  const lastError = typeof opts === "string" ? opts : opts?.lastError ?? null;
+  const lastError2 = typeof opts === "string" ? opts : opts?.lastError ?? null;
   const filesCount = typeof opts === "object" ? opts?.filesCount : undefined;
   const chunksCount = typeof opts === "object" ? opts?.chunksCount : undefined;
   const symbolsCount = typeof opts === "object" ? opts?.symbolsCount : undefined;
@@ -110651,7 +111164,7 @@ async function updateWorkspaceStatus(projectId, status2, opts) {
     await tx.$executeRaw`
       UPDATE workspaces SET
         status          = ${status2},
-        last_error      = ${lastError},
+        last_error      = ${lastError2},
         last_indexed_at = ${lastIndexedAt ?? null},
         files_count     = COALESCE(${filesCount ?? null}, files_count),
         chunks_count    = COALESCE(${chunksCount ?? null}, chunks_count),
@@ -115995,10 +116508,10 @@ var init_chunker_code = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/smart-chunker.js
-import path16 from "path";
+import path18 from "path";
 function smartChunk(content, filePath, config3 = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config3 };
-  const ext2 = path16.extname(filePath).toLowerCase();
+  const ext2 = path18.extname(filePath).toLowerCase();
   const relativePath = filePath;
   const fileImports = isCodeFile(ext2) ? extractFileImports(content, ext2) : undefined;
   let chunks;
@@ -116305,8 +116818,8 @@ var init_managed_run_repository_pg = __esm(() => {
 });
 
 // ../../packages/core/dist/services/search/project-indexer.js
-import fs12 from "fs/promises";
-import path17 from "path";
+import fs13 from "fs/promises";
+import path19 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function runWithIndexLock(lockMap, projectId, work) {
   const prevLock = lockMap.get(projectId);
@@ -116349,7 +116862,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
       dot: false
     });
     const filteredFiles = files.filter((file3) => {
-      const relativePath = path17.relative(projectPath, file3);
+      const relativePath = path19.relative(projectPath, file3);
       const shouldIgnore = ig.ignores(relativePath);
       if (shouldIgnore) {
         logger.debug("Ignoring file per .gitignore during indexing", {
@@ -116389,7 +116902,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
         });
       }
     }
-    const indexedFilesList = filteredFiles.map((f) => path17.relative(projectPath, f));
+    const indexedFilesList = filteredFiles.map((f) => path19.relative(projectPath, f));
     await deps.indexManager.updateIndexMetadata(projectId, projectPath, indexedFilesList);
     logger.info("Project indexing completed", {
       projectId,
@@ -116514,7 +117027,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
   let errors5 = 0;
   for (const relativeFilePath of filesToReindex) {
     try {
-      const fullPath = path17.join(projectPath, relativeFilePath);
+      const fullPath = path19.join(projectPath, relativeFilePath);
       const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
       filesIndexed++;
       chunksIndexed += result.chunks;
@@ -116565,8 +117078,8 @@ async function checkSearchAdmission(deps, projectId, projectPath) {
 }
 async function indexFile(deps, filePath, projectId, projectRoot, centralityMap) {
   projectId = await getProjectIdentityAliasResolver().resolve(projectId);
-  const content = await fs12.readFile(filePath, "utf-8");
-  const relativePath = path17.relative(projectRoot, filePath);
+  const content = await fs13.readFile(filePath, "utf-8");
+  const relativePath = path19.relative(projectRoot, filePath);
   const maxFileSize = config.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -116586,7 +117099,7 @@ async function indexFile(deps, filePath, projectId, projectRoot, centralityMap)
       chunkIndex: i,
       totalChunks: chunks.length,
       type: chunk.type,
-      language: path17.extname(filePath).slice(1),
+      language: path19.extname(filePath).slice(1),
       lineStart: chunk.lineStart,
       lineEnd: chunk.lineEnd,
       label: chunk.label,
@@ -117431,8 +117944,8 @@ function stripNul(content) {
 }
 
 // ../../packages/core/dist/services/etl/stages/discover.js
-import fs13 from "fs/promises";
-import path18 from "path";
+import fs14 from "fs/promises";
+import path20 from "path";
 import { createHash as createHash5 } from "crypto";
 
 class DiscoverStage {
@@ -117458,7 +117971,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path18.isAbsolute(p) ? path18.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path20.isAbsolute(p) ? path20.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -117517,10 +118030,10 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path18.join(ctx.projectPath, relativePath);
+    const absolutePath = path20.join(ctx.projectPath, relativePath);
     try {
-      const stat2 = await fs13.stat(absolutePath);
-      const content = stripNul(await fs13.readFile(absolutePath, "utf-8"));
+      const stat2 = await fs14.stat(absolutePath);
+      const content = stripNul(await fs14.readFile(absolutePath, "utf-8"));
       const contentHash = createHash5("sha256").update(content).digest("hex");
       let needsReparse = forceReindex;
       if (!forceReindex) {
@@ -117563,8 +118076,8 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path18.join(projectPath, ".gitignore");
-      const gitignoreContent = await fs13.readFile(gitignorePath, "utf8");
+      const gitignorePath = path20.join(projectPath, ".gitignore");
+      const gitignoreContent = await fs14.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       ig.add(rules);
@@ -118919,8 +119432,8 @@ function rustUseLeaves(node2, source, prefix = []) {
   }
   if (node2.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path19 = rustPathSegments(node2, source);
-  return path19.length ? [{ path: [...prefix, ...path19] }] : [];
+  const path21 = rustPathSegments(node2, source);
+  return path21.length ? [{ path: [...prefix, ...path21] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -119892,8 +120405,8 @@ var init_structural_runtime = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path19 from "path";
-import fs14 from "fs/promises";
+import path21 from "path";
+import fs15 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
   if (Number.isFinite(global2) && global2 > 0)
@@ -119921,8 +120434,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file3) => path19.extname(file3.relativePath).toLowerCase() !== ".h"),
-      files.filter((file3) => path19.extname(file3.relativePath).toLowerCase() === ".h")
+      files.filter((file3) => path21.extname(file3.relativePath).toLowerCase() !== ".h"),
+      files.filter((file3) => path21.extname(file3.relativePath).toLowerCase() === ".h")
     ];
     const batches = phases.flatMap((phase) => Array.from({ length: Math.ceil(phase.length / BATCH_SIZE) }, (_2, index) => phase.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE)));
     for (const batch of batches) {
@@ -119960,19 +120473,19 @@ class ParseStage {
     return files.map((file3) => results.get(file3.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file3) => path19.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path19.posix.normalize(file3.relativePath)));
+    const knownHeaders = new Set(files.filter((file3) => path21.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path21.posix.normalize(file3.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path19.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path21.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 = path19.posix.normalize(path19.posix.join(path19.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path21.posix.normalize(path21.posix.join(path21.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -119983,9 +120496,9 @@ class ParseStage {
   }
   async parseFile(ctx, file3) {
     if (!file3.needsReparse) {
-      const extension = path19.extname(file3.relativePath).toLowerCase();
+      const extension = path21.extname(file3.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
-        const content = file3.snapshotContent ?? await fs14.readFile(file3.absolutePath, "utf8");
+        const content = file3.snapshotContent ?? await fs15.readFile(file3.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
         if (outcome.status === "failed")
           throw new StructuralEtlParseError(file3.relativePath, outcome.failureKind, `Structural evidence parse failed (${outcome.failureKind})`, outcome.diagnosticCount, outcome.diagnostics.slice(0, 10));
@@ -119997,8 +120510,8 @@ class ParseStage {
       return { file: file3, chunks: [], symbols: [], rawImports: [], rawEdges: [] };
     }
     try {
-      const content = file3.snapshotContent ?? await fs14.readFile(file3.absolutePath, "utf-8");
-      const ext2 = path19.extname(file3.relativePath).toLowerCase();
+      const content = file3.snapshotContent ?? await fs15.readFile(file3.absolutePath, "utf-8");
+      const ext2 = path21.extname(file3.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file3.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -120552,7 +121065,7 @@ var init_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path20 from "path";
+import path22 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -120647,7 +121160,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 = path20.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path22.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -120656,7 +121169,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(path20.posix.join(path20.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path22.posix.join(path22.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -120920,7 +121433,7 @@ var init_scripting2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path21 from "path";
+import path23 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -120939,7 +121452,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 = file3.file.startsWith("src/") ? "src" : "";
-            return { ...item, bindings, specifier: `./${path21.posix.relative(path21.posix.dirname(file3.file), path21.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path23.posix.relative(path23.posix.dirname(file3.file), path23.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, "")}` };
@@ -121037,8 +121550,8 @@ var init_data_document2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path22 from "path";
-import fs15 from "fs";
+import path24 from "path";
+import fs16 from "fs";
 
 class ResolveStage {
   symbolRepository;
@@ -121062,7 +121575,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file3) => {
       if (!file3.structure)
         return [];
-      const language = resolveStructuralLanguage(path22.extname(file3.file.relativePath));
+      const language = resolveStructuralLanguage(path24.extname(file3.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file3.file.relativePath}`);
       return [{
@@ -121074,13 +121587,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(path22.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path24.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
     const pathAliasesByFile = Object.fromEntries([...knownRelPaths].map((file3) => [
       file3,
       this.structuralAliasesFor(file3, rootAliases, monorepoPackages)
     ]));
     const buildMetadata = { knownFiles: [...knownRelPaths], pathAliasesByFile };
-    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path22.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(path24.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))
@@ -121173,7 +121686,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path22.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path24.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -121225,7 +121738,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path22.dirname(path22.join(projectPath, parsed.file.relativePath));
+    const fromDir = path24.dirname(path24.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -121296,7 +121809,7 @@ class ResolveStage {
         index.set(def.name, `${def.file_path}#${def.name}`);
       }
     } catch (err) {
-      const skippedStructural = files.some((file3) => !file3.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path22.extname(file3.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file3) => !file3.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path24.extname(file3.file.relativePath).toLowerCase()));
       if (skippedStructural)
         throw new Error("structural_repository_seed_failed", { cause: err });
       logger.warn("buildSymbolIndex: repo seed failed, in-batch only", {
@@ -121320,7 +121833,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path22.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path24.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -121328,8 +121841,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path22.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path22.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path24.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path24.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -121345,7 +121858,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path22.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path24.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -121353,9 +121866,9 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path22.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path24.join(projectPath, "tsconfig.json");
     try {
-      const raw2 = fs15.readFileSync(tsconfigPath, "utf-8");
+      const raw2 = fs16.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
       const tsconfig = JSON.parse(stripped);
       const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -121384,7 +121897,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path22.join(projectPath, packageRelPath);
+      const absPackagePath = path24.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -121414,7 +121927,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 ? path22.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path24.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -121478,7 +121991,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/load.js
-import path23 from "path";
+import path25 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -121755,7 +122268,7 @@ class LoadStage {
     const filePath = file3.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file3);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path23.extname(filePath));
+      const manifest = getLanguageManifestEntry(path25.extname(filePath));
       const diagnostics2 = (file3.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -122212,9 +122725,9 @@ var init_graph_generation_coordinator = __esm(() => {
 // ../../packages/core/dist/services/etl/pipeline.js
 import { createHash as createHash7 } from "crypto";
 import { setTimeout as delay2 } from "timers/promises";
-import path24 from "path";
+import path26 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file3) => path24.posix.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path24.posix.normalize(file3.relativePath)));
+  const headers = new Set(files.filter((file3) => path26.posix.extname(file3.relativePath).toLowerCase() === ".h").map((file3) => path26.posix.normalize(file3.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -122225,7 +122738,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file3 of files) {
-    if (path24.posix.basename(file3.relativePath) !== "compile_commands.json" || file3.snapshotContent === undefined)
+    if (path26.posix.basename(file3.relativePath) !== "compile_commands.json" || file3.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -122241,11 +122754,11 @@ function buildHeaderLanguageEvidence(files) {
       const record2 = command;
       if (typeof record2.file !== "string")
         continue;
-      const projectRoot = path24.resolve(file3.absolutePath, ...file3.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record2.directory === "string" ? path24.resolve(projectRoot, record2.directory) : projectRoot;
-      const absoluteInput = path24.resolve(commandDirectory, record2.file);
-      const relative2 = path24.relative(projectRoot, absoluteInput);
-      const header = path24.posix.normalize(relative2.replaceAll(path24.sep, "/"));
+      const projectRoot = path26.resolve(file3.absolutePath, ...file3.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record2.directory === "string" ? path26.resolve(projectRoot, record2.directory) : projectRoot;
+      const absoluteInput = path26.resolve(commandDirectory, record2.file);
+      const relative2 = path26.relative(projectRoot, absoluteInput);
+      const header = path26.posix.normalize(relative2.replaceAll(path26.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record2.command === "string" ? record2.command : Array.isArray(record2.arguments) ? record2.arguments.join(" ") : "";
@@ -123404,16 +123917,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path26 = e.route;
-    if (!path26)
+    const path28 = e.route;
+    if (!path28)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path26;
+    const key = method + " " + path28;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path26,
+      path: path28,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -123424,12 +123937,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path26 = parsed?.path ?? d.name;
-    const key = method + " " + path26;
+    const path28 = parsed?.path ?? d.name;
+    const key = method + " " + path28;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path26, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path28, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -123650,8 +124163,8 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path26 from "path";
-import fs16 from "fs/promises";
+import path28 from "path";
+import fs17 from "fs/promises";
 
 class SymbolGraphService {
   identityLookup;
@@ -123979,7 +124492,7 @@ class SymbolGraphService {
   async readSnippet(relativePath, lineStart, lineEnd, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs16.readFile(absolutePath, "utf-8");
+      const content = await fs17.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       return lines.slice(Math.max(0, lineStart - 1), Math.min(lines.length, lineEnd)).join(`
@@ -123991,7 +124504,7 @@ class SymbolGraphService {
   async readContext(relativePath, lineNumber, contextLines, projectId) {
     try {
       const absolutePath = await this.resolveToAbsolute(relativePath, projectId);
-      const content = await fs16.readFile(absolutePath, "utf-8");
+      const content = await fs17.readFile(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const start = Math.max(0, lineNumber - contextLines - 1);
@@ -124004,7 +124517,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path26.resolve(root, relativePath) : relativePath;
+    return root ? path28.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -127998,31 +128511,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path29) => {
+    const walk = (fqn, path31) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path29.join("\u2192");
+      const key = path31.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path29.length > 1)
-          chains.push(path29.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
+        if (path31.length > 1)
+          chains.push(path31.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path29.includes(child)) {
-          const cycled = [...path29, `${this.fqnToName(child)}\u21BA`];
+        if (path31.includes(child)) {
+          const cycled = [...path31, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n2) => n2).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path29, child]);
+        walk(child, [...path31, child]);
       }
     };
     for (const seed of seeds) {
@@ -131164,9 +131677,9 @@ var init_l1_memory_cache = __esm(() => {
 });
 
 // ../../packages/core/dist/services/health/local-health-checker.js
-import fs19 from "fs/promises";
+import fs20 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path31 from "path";
+import path33 from "path";
 
 class LocalHealthChecker {
   ollamaBaseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
@@ -131200,10 +131713,10 @@ class LocalHealthChecker {
     const start = Date.now();
     try {
       if (!existsSync3(this.dataDir))
-        await fs19.mkdir(this.dataDir, { recursive: true });
-      const probe2 = path31.join(this.dataDir, ".health-check-test");
-      await fs19.writeFile(probe2, "ok");
-      await fs19.unlink(probe2);
+        await fs20.mkdir(this.dataDir, { recursive: true });
+      const probe2 = path33.join(this.dataDir, ".health-check-test");
+      await fs20.writeFile(probe2, "ok");
+      await fs20.unlink(probe2);
       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}` };
@@ -131599,10 +132112,18 @@ var init_scheduler_store_factory = __esm(() => {
 });
 
 // ../../packages/core/dist/services/scheduler/scheduler.js
-function readEnabled() {
+function readEnabledEnv() {
   const raw2 = process.env.MASSA_AI_SCHEDULER_ENABLED;
+  if (raw2 === undefined)
+    return;
   return raw2 === "true" || raw2 === "1";
 }
+function envPositiveInt(raw2) {
+  if (raw2 === undefined || raw2 === "")
+    return;
+  const parsed = parsePositiveIntEnv(raw2, NaN);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
 
 class Scheduler {
   store;
@@ -131616,9 +132137,10 @@ class Scheduler {
   started = false;
   constructor(opts = {}) {
     this.store = opts.store ?? getScheduledJobStore();
-    this.tickIntervalMs = opts.tickIntervalMs ?? parsePositiveIntEnv(process.env.MASSA_AI_SCHEDULER_TICK_MS, DEFAULTS.tickMs);
-    this.maxConcurrent = opts.maxConcurrent ?? parsePositiveIntEnv(process.env.MASSA_AI_SCHEDULER_MAX_CONCURRENT, DEFAULTS.maxConcurrent);
-    this.enabled = opts.enabled ?? readEnabled();
+    const schedulerConfig = config.get("scheduler");
+    this.tickIntervalMs = opts.tickIntervalMs ?? envPositiveInt(process.env.MASSA_AI_SCHEDULER_TICK_MS) ?? schedulerConfig?.tickMs ?? DEFAULTS.tickMs;
+    this.maxConcurrent = opts.maxConcurrent ?? envPositiveInt(process.env.MASSA_AI_SCHEDULER_MAX_CONCURRENT) ?? schedulerConfig?.maxConcurrent ?? DEFAULTS.maxConcurrent;
+    this.enabled = opts.enabled ?? readEnabledEnv() ?? schedulerConfig?.enabled ?? false;
   }
   registerHandler(jobKind, handler) {
     this.handlers.set(jobKind, handler);
@@ -132982,21 +133504,31 @@ var init_observation_consolidation_job = __esm(() => {
 });
 
 // ../../packages/core/dist/services/scheduler/scheduler-defaults.js
-function envBool2(key, fallback) {
+function envBool2(key, fileValue, fallback) {
   const raw2 = process.env[key];
   if (raw2 === undefined)
-    return fallback;
+    return fileValue ?? fallback;
   return raw2 === "true" || raw2 === "1";
 }
-function envNum2(key, fallback) {
+function envNum2(key, fileValue, fallback) {
   const raw2 = process.env[key];
-  if (raw2 === undefined || raw2 === "")
-    return fallback;
-  const n2 = Number(raw2);
-  return Number.isFinite(n2) && n2 > 0 ? n2 : fallback;
+  if (raw2 !== undefined && raw2 !== "") {
+    const n2 = Number(raw2);
+    if (Number.isFinite(n2) && n2 > 0)
+      return n2;
+  }
+  return fileValue ?? fallback;
+}
+function readFileSchedulerJobs() {
+  try {
+    const raw2 = loadRawUserConfig().scheduler?.jobs;
+    return raw2;
+  } catch {
+    return;
+  }
 }
 function applySafeDefaults(job) {
-  if (!envBool2("MASSA_AI_SCHEDULER_SAFE_DEFAULTS", false)) {
+  if (!envBool2("MASSA_AI_SCHEDULER_SAFE_DEFAULTS", undefined, false)) {
     return job;
   }
   if (job.jobKind === "memory-consolidation") {
@@ -133043,10 +133575,12 @@ function registerDefaultJobs(scheduler) {
     const count = CheckpointManager2.getInstance().purgeExpired();
     logger.info("Scheduled checkpoint purge completed", { count });
   });
+  const fileJobs = readFileSchedulerJobs();
   for (const rawDef of DEFAULT_SCHEDULED_JOBS) {
     const def = applySafeDefaults(rawDef);
-    const enabled2 = envBool2(def.enableEnvVar, def.defaultEnabled);
-    const intervalMs = envNum2(def.intervalEnvVar, def.schedule.intervalMs ?? THIRTY_MIN);
+    const fileJob = fileJobs?.[def.jobKind];
+    const enabled2 = envBool2(def.enableEnvVar, fileJob?.enabled, def.defaultEnabled);
+    const intervalMs = envNum2(def.intervalEnvVar, fileJob?.intervalMs, def.schedule.intervalMs ?? THIRTY_MIN);
     const schedule = { type: "interval", intervalMs };
     scheduler.registerOrResumeJob({
       id: def.id,
@@ -133127,9 +133661,9 @@ var init_scheduler2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/pricing/models-dev-client.js
-import fs20 from "fs/promises";
+import fs21 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path32 from "path";
+import path34 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -133149,7 +133683,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path32.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path34.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -133157,7 +133691,7 @@ var init_models_dev_client = __esm(() => {
         if (!existsSync4(cachePath)) {
           return null;
         }
-        const content = await fs20.readFile(cachePath, "utf-8");
+        const content = await fs21.readFile(cachePath, "utf-8");
         const data = JSON.parse(content);
         const age = Date.now() - data.timestamp;
         if (age > ModelsDevClient.LOCAL_CACHE_TTL) {
@@ -133184,14 +133718,14 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path32.dirname(cachePath);
-        await fs20.mkdir(dir, { recursive: true });
+        const dir = path34.dirname(cachePath);
+        await fs21.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
           version: "1.0.0",
           models: Object.fromEntries(models)
         };
-        await fs20.writeFile(cachePath, JSON.stringify(data), "utf-8");
+        await fs21.writeFile(cachePath, JSON.stringify(data), "utf-8");
         logger.debug("Saved pricing to local cache", {
           models: models.size,
           path: cachePath
@@ -133520,7 +134054,7 @@ var init_models_dev_client = __esm(() => {
       const cachePath = this.getLocalCachePath();
       try {
         if (existsSync4(cachePath)) {
-          await fs20.unlink(cachePath);
+          await fs21.unlink(cachePath);
           logger.debug("Local pricing cache file deleted");
         }
       } catch (error51) {
@@ -139075,33 +139609,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path33) {
-        if (!path33)
-          return path33;
+      function remove_dot_segments(path35) {
+        if (!path35)
+          return path35;
         var output = "";
-        while (path33.length > 0) {
-          if (path33 === "." || path33 === "..") {
-            path33 = "";
+        while (path35.length > 0) {
+          if (path35 === "." || path35 === "..") {
+            path35 = "";
             break;
           }
-          var twochars = path33.substring(0, 2);
-          var threechars = path33.substring(0, 3);
-          var fourchars = path33.substring(0, 4);
+          var twochars = path35.substring(0, 2);
+          var threechars = path35.substring(0, 3);
+          var fourchars = path35.substring(0, 4);
           if (threechars === "../") {
-            path33 = path33.substring(3);
+            path35 = path35.substring(3);
           } else if (twochars === "./") {
-            path33 = path33.substring(2);
+            path35 = path35.substring(2);
           } else if (threechars === "/./") {
-            path33 = "/" + path33.substring(3);
-          } else if (twochars === "/." && path33.length === 2) {
-            path33 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path33.length === 3) {
-            path33 = "/" + path33.substring(4);
+            path35 = "/" + path35.substring(3);
+          } else if (twochars === "/." && path35.length === 2) {
+            path35 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path35.length === 3) {
+            path35 = "/" + path35.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path33.match(/(\/?([^\/]*))/)[0];
+            var segment = path35.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path33 = path33.substring(segment.length);
+            path35 = path35.substring(segment.length);
           }
         }
         return output;
@@ -151171,21 +151705,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path33, out) {
+function walk(val, path35, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path33, content: `**${path33}** = _[]_` });
+      out.push({ path: path35, content: `**${path35}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path33}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path35}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path33, content: `**${path33}**
+    out.push({ path: path35, content: `**${path35}**
 
 ${items}` });
     return;
@@ -151193,16 +151727,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path33, content: `**${path33}** = _{}_` });
+      out.push({ path: path35, content: `**${path35}** = _{}_` });
       return;
     }
     for (const [k2, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k2) ? k2 : JSON.stringify(k2);
-      walk(v, `${path33}.${safeKey}`, out);
+      walk(v, `${path35}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path33, content: `**${path33}** = \`${String(val)}\`` });
+  out.push({ path: path35, content: `**${path35}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -174193,9 +174727,9 @@ async function acquireIndexingLease(request) {
 
 // ../../packages/core/dist/services/project-identity/project-root-identity.js
 import { realpath as realpath2 } from "fs/promises";
-import path25 from "path";
+import path27 from "path";
 async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path25.resolve(projectPath));
+  return canonicalize(path27.resolve(projectPath));
 }
 async function assertProjectRootReuse(options) {
   if (!options.storedProjectPath || options.forceReindex)
@@ -174203,9 +174737,9 @@ async function assertProjectRootReuse(options) {
   const canonicalize = options.canonicalize ?? realpath2;
   let storedCanonical;
   try {
-    storedCanonical = await canonicalize(path25.resolve(options.storedProjectPath));
+    storedCanonical = await canonicalize(path27.resolve(options.storedProjectPath));
   } catch {
-    storedCanonical = path25.resolve(options.storedProjectPath);
+    storedCanonical = path27.resolve(options.storedProjectPath);
   }
   if (storedCanonical !== options.canonicalProjectPath) {
     throw new Error(`Project ID "${options.projectId}" already indexes canonical root ` + `"${storedCanonical}", not "${options.canonicalProjectPath}"; ` + "use forceReindex only after verifying ownership of the existing project");
@@ -174215,7 +174749,7 @@ async function assertProjectRootReuse(options) {
 // ../../packages/core/dist/tools/index_project.js
 init_workspace_manager();
 init_parser_readiness();
-import path27 from "path";
+import path29 from "path";
 
 class IndexProjectTool {
   name = "index_project";
@@ -174263,7 +174797,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path27.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path29.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -174817,17 +175351,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path28) {
+function transformChildren(value, replacer, path30) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path28);
+    return transformObject(value, replacer, path30);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path28);
+    return transformArray(value, replacer, path30);
   return value;
 }
-function transformObject(obj, replacer, path28) {
+function transformObject(obj, replacer, path30) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path28, key];
+    const childPath = [...path30, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -174835,11 +175369,11 @@ function transformObject(obj, replacer, path28) {
   }
   return result;
 }
-function transformArray(arr, replacer, path28) {
+function transformArray(arr, replacer, path30) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path28, i];
+    const childPath = [...path30, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -176220,9 +176754,9 @@ init_dist();
 init_db_connection();
 init_alias_resolver();
 init_safe_error_summary();
-import fs17 from "fs";
-import os6 from "os";
-import path28 from "path";
+import fs18 from "fs";
+import os8 from "os";
+import path30 from "path";
 
 // ../../packages/core/dist/services/hooks/session-pin-store.js
 var DEFAULT_MAX_SIZE = 1000;
@@ -176321,8 +176855,8 @@ class AttributionResolver {
     this.aliasResolver = options.aliasResolver ?? getProjectIdentityAliasResolver();
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
-    this.homedir = options.homedir ?? os6.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path28.parse(path28.sep).root);
+    this.homedir = options.homedir ?? os8.homedir;
+    this.fsRoot = options.fsRoot ?? (() => path30.parse(path30.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -176373,7 +176907,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path28.sep) ? candidate2 : candidate2 + path28.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path30.sep) ? candidate2 : candidate2 + path30.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -176396,7 +176930,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path28.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path30.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -176404,10 +176938,10 @@ class AttributionResolver {
 }
 function defaultCanonicalize(cwd) {
   try {
-    return fs17.realpathSync(cwd);
+    return fs18.realpathSync(cwd);
   } catch {
     try {
-      return path28.resolve(cwd);
+      return path30.resolve(cwd);
     } catch {
       return;
     }
@@ -176944,7 +177478,7 @@ init_code_compressor();
 
 // ../../packages/core/dist/services/file-read/file-content-cache.js
 init_dist();
-import fs18 from "fs/promises";
+import fs19 from "fs/promises";
 
 class FileContentCache {
   extractMetadata;
@@ -176977,7 +177511,7 @@ class FileContentCache {
         metadata: cached2.metadata
       };
     }
-    const content = await fs18.readFile(filePath, "utf-8");
+    const content = await fs19.readFile(filePath, "utf-8");
     const metadata = await this.extractMetadata(content, filePath, options);
     evictOldest(this.fileCache, this.FILE_CACHE_MAX_ENTRIES - 1);
     this.fileCache.set(cacheKey, {
@@ -176992,7 +177526,7 @@ class FileContentCache {
 
 // ../../packages/core/dist/services/file-read/file-metadata.js
 init_dist();
-import path29 from "path";
+import path31 from "path";
 
 class FileMetadataExtractor {
   symbolGraph;
@@ -177028,7 +177562,7 @@ class FileMetadataExtractor {
     return metadata;
   }
   detectLanguage(filePath) {
-    const ext2 = path29.extname(filePath).toLowerCase();
+    const ext2 = path31.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -177145,7 +177679,7 @@ function selectLines(lines, range) {
 
 // ../../packages/core/dist/services/file-read/path-containment.js
 init_dist();
-import path30 from "path";
+import path32 from "path";
 
 class PathContainment {
   projectRoots;
@@ -177153,14 +177687,14 @@ class PathContainment {
     this.projectRoots = projectRoots;
   }
   async resolveFilePath(filePath, projectId) {
-    if (path30.isAbsolute(filePath)) {
-      return path30.resolve(filePath);
+    if (path32.isAbsolute(filePath)) {
+      return path32.resolve(filePath);
     }
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root) {
         const cleaned = sanitizeFilePath(filePath);
-        return path30.resolve(root, cleaned);
+        return path32.resolve(root, cleaned);
       }
       return null;
     }
@@ -177171,17 +177705,17 @@ class PathContainment {
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root)
-        roots.push(path30.resolve(root));
+        roots.push(path32.resolve(root));
     }
-    roots.push(path30.resolve(process.cwd()));
+    roots.push(path32.resolve(process.cwd()));
     const envRoots = (process.env.MASSA_AI_READ_FILE_ROOTS ?? "").split(":").map((s) => s.trim()).filter((s) => s.length > 0);
     for (const extra of envRoots) {
-      roots.push(path30.resolve(extra));
+      roots.push(path32.resolve(extra));
     }
-    const target = path30.resolve(absoluteFilePath);
+    const target = path32.resolve(absoluteFilePath);
     for (const root of roots) {
-      const rel = path30.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path30.isAbsolute(rel)) {
+      const rel = path32.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path32.isAbsolute(rel)) {
         return { allowed: true };
       }
       if (rel === "")
@@ -178018,8 +178552,8 @@ init_event_bus();
 init_llm_client();
 init_symbol_graph_service();
 import { randomUUID as randomUUID9 } from "crypto";
-import fs21 from "fs";
-import path33 from "path";
+import fs22 from "fs";
+import path35 from "path";
 import { spawn as spawn2 } from "child_process";
 var FALLBACK_BOOTSTRAP = {
   enabled: true,
@@ -178203,9 +178737,9 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path33.join(projectRoot, name26);
-      if (fs21.existsSync(p) && fs21.statSync(p).isFile()) {
-        const buf = fs21.readFileSync(p);
+      const p = path35.join(projectRoot, name26);
+      if (fs22.existsSync(p) && fs22.statSync(p).isFile()) {
+        const buf = fs22.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
         break;
       }
@@ -178214,14 +178748,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path33.join(projectRoot, "docs");
-    if (fs21.existsSync(docsDir) && fs21.statSync(docsDir).isDirectory()) {
+    const docsDir = path35.join(projectRoot, "docs");
+    if (fs22.existsSync(docsDir) && fs22.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
-          const buf = fs21.readFileSync(rel);
+          const buf = fs22.readFileSync(rel);
           signals.docs.push({
-            path: path33.relative(projectRoot, rel),
+            path: path35.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -178232,10 +178766,10 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path33.join(projectRoot, name26);
-      if (!fs21.existsSync(p) || !fs21.statSync(p).isFile())
+      const p = path35.join(projectRoot, name26);
+      if (!fs22.existsSync(p) || !fs22.statSync(p).isFile())
         continue;
-      const raw2 = fs21.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
+      const raw2 = fs22.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
       const kind = name26;
       if (name26 === "package.json") {
         try {
@@ -178275,12 +178809,12 @@ function walkMarkdown(dir) {
     const cur = stack.pop();
     let entries;
     try {
-      entries = fs21.readdirSync(cur, { withFileTypes: true });
+      entries = fs22.readdirSync(cur, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const full = path33.join(cur, e.name);
+      const full = path35.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -179349,8 +179883,8 @@ var checkpointRoutes = new Elysia({ prefix: "/api/v1/checkpoints" }).post("/list
 
 // src/routes/project.ts
 init_dist();
-import fs22 from "fs/promises";
-import path34 from "path";
+import fs23 from "fs/promises";
+import path36 from "path";
 function isDimensionMismatchError(error51) {
   const message = error51 instanceof Error ? error51.message : String(error51);
   return /dimension mismatch/i.test(message);
@@ -179570,22 +180104,22 @@ var projectRoutes = new Elysia({ prefix: "/api/v1/project" }).get("/list", async
 }).post("/upload-and-index", async ({ body }) => {
   const rawBase = body.projectId || body.projectPath.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "default";
   const finalProjectId = rawBase.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 128);
-  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path34.join(getGlobalDataDir(), "uploads");
-  const stagingDir = path34.resolve(uploadRoot, finalProjectId);
-  await fs22.rm(stagingDir, { recursive: true, force: true });
-  await fs22.mkdir(stagingDir, { recursive: true });
+  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path36.join(getGlobalDataDir(), "uploads");
+  const stagingDir = path36.resolve(uploadRoot, finalProjectId);
+  await fs23.rm(stagingDir, { recursive: true, force: true });
+  await fs23.mkdir(stagingDir, { recursive: true });
   const WRITE_BATCH = 20;
   for (let i = 0;i < body.files.length; i += WRITE_BATCH) {
     await Promise.all(body.files.slice(i, i + WRITE_BATCH).map(async (file3) => {
-      if (path34.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
+      if (path36.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
         throw new Error(`Invalid file path: ${file3.relativePath}`);
       }
-      const dest = path34.resolve(stagingDir, file3.relativePath.replace(/\//g, path34.sep));
-      if (!dest.startsWith(stagingDir + path34.sep)) {
+      const dest = path36.resolve(stagingDir, file3.relativePath.replace(/\//g, path36.sep));
+      if (!dest.startsWith(stagingDir + path36.sep)) {
         throw new Error(`Path escapes staging directory: ${file3.relativePath}`);
       }
-      await fs22.mkdir(path34.dirname(dest), { recursive: true });
-      await fs22.writeFile(dest, file3.content, "utf-8");
+      await fs23.mkdir(path36.dirname(dest), { recursive: true });
+      await fs23.writeFile(dest, file3.content, "utf-8");
     }));
   }
   return await getIndexProjectTool().handle({
@@ -179739,9 +180273,9 @@ var analyticsRoutes = new Elysia({ prefix: "/api/v1/analytics" }).post("/", asyn
 
 // src/routes/system.ts
 init_dist();
-import path35 from "path";
-import fs23 from "fs";
-import os7 from "os";
+import path37 from "path";
+import fs24 from "fs";
+import os9 from "os";
 function databaseUrlParts() {
   const url2 = new URL(process.env.DATABASE_URL);
   return {
@@ -179772,13 +180306,13 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
     version: "1.0.0",
     service: "massa-ai-tools-api",
     node: process.version,
-    platform: os7.platform(),
-    arch: os7.arch(),
+    platform: os9.platform(),
+    arch: os9.arch(),
     uptime: process.uptime(),
     memory: {
-      total: os7.totalmem(),
-      free: os7.freemem(),
-      used: os7.totalmem() - os7.freemem(),
+      total: os9.totalmem(),
+      free: os9.freemem(),
+      used: os9.totalmem() - os9.freemem(),
       process: process.memoryUsage()
     },
     dataDir: config.get("dataDir"),
@@ -179814,11 +180348,11 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
     description: "Check PostgreSQL, pgvector, Ollama, and local artifact directory health"
   }
 }).get("/metrics", async () => {
-  const metricsPath = path35.join(process.cwd(), "data", "metrics.json");
+  const metricsPath = path37.join(process.cwd(), "data", "metrics.json");
   let metrics2 = {};
-  if (fs23.existsSync(metricsPath)) {
+  if (fs24.existsSync(metricsPath)) {
     try {
-      metrics2 = JSON.parse(fs23.readFileSync(metricsPath, "utf-8"));
+      metrics2 = JSON.parse(fs24.readFileSync(metricsPath, "utf-8"));
     } catch {}
   }
   const database = await getDatabaseInfo();
@@ -179968,8 +180502,8 @@ var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ que
 });
 
 // src/routes/workspace.ts
-import fs24 from "fs/promises";
-import path36 from "path";
+import fs25 from "fs/promises";
+import path38 from "path";
 import { realpathSync as realpathSync4 } from "fs";
 var indexProjectTool2 = null;
 function getIndexProjectTool2() {
@@ -180011,7 +180545,7 @@ function realpathSafe(p) {
   try {
     return realpathSync4(p);
   } catch {
-    return path36.resolve(p);
+    return path38.resolve(p);
   }
 }
 var graphController = null;
@@ -180362,8 +180896,8 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     }
     const registeredRoot = realpathSafe(workspace.project_path);
     const callerRoot = realpathSafe(projectPath2);
-    const rel = path36.relative(registeredRoot, callerRoot);
-    const escapes = rel.startsWith("..") || path36.isAbsolute(rel);
+    const rel = path38.relative(registeredRoot, callerRoot);
+    const escapes = rel.startsWith("..") || path38.isAbsolute(rel);
     if (registeredRoot !== callerRoot && escapes) {
       return {
         success: false,
@@ -180493,8 +181027,8 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     } else {
       end = start + 20;
     }
-    const absolutePath = path36.join(workspace.project_path, file3);
-    const content = await fs24.readFile(absolutePath, "utf-8");
+    const absolutePath = path38.join(workspace.project_path, file3);
+    const content = await fs25.readFile(absolutePath, "utf-8");
     const lines = content.split(/\r?\n/);
     const slice = lines.slice(start - 1, Math.min(lines.length, end));
     const formatted = slice.map((text3, idx) => ({
@@ -181419,8 +181953,8 @@ var webRoutes = new Elysia({ prefix: "/api/v1/web" }).post("/fetch_and_index", a
 });
 
 // src/routes/web-ui.ts
-import fs25 from "fs/promises";
-import path37 from "path";
+import fs26 from "fs/promises";
+import path39 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/web-ui-trust.ts
@@ -181464,9 +181998,9 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   for (const root2 of [moduleDir, cwd]) {
     let dir = root2;
     for (let i = 0;i < 10; i++) {
-      candidates2.push(path37.resolve(dir, "apps/web-ui/src/static"));
-      candidates2.push(path37.resolve(dir, "web-ui/src/static"));
-      const parent = path37.dirname(dir);
+      candidates2.push(path39.resolve(dir, "apps/web-ui/src/static"));
+      candidates2.push(path39.resolve(dir, "web-ui/src/static"));
+      const parent = path39.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -181474,11 +182008,11 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   }
   return [...new Set(candidates2)];
 }
-var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path37.dirname(fileURLToPath3(import.meta.url)), process.cwd());
+var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path39.dirname(fileURLToPath3(import.meta.url)), process.cwd());
 async function resolveStaticDir() {
   for (const dir of STATIC_DIR_CANDIDATES) {
     try {
-      const st = await fs25.stat(dir);
+      const st = await fs26.stat(dir);
       if (st.isDirectory())
         return dir;
     } catch {}
@@ -181499,7 +182033,7 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filePath) {
-  const ext2 = path37.extname(filePath).toLowerCase();
+  const ext2 = path39.extname(filePath).toLowerCase();
   return CONTENT_TYPES[ext2] ?? "application/octet-stream";
 }
 function webUiDisabled() {
@@ -181510,13 +182044,13 @@ function webUiDisabled() {
 }
 async function resolveSafePath(staticDir, sub) {
   const cleaned = sub.replace(/^\/+/, "");
-  const abs = path37.resolve(staticDir, cleaned);
-  const rel = path37.relative(staticDir, abs);
-  if (rel.startsWith("..") || path37.isAbsolute(rel)) {
+  const abs = path39.resolve(staticDir, cleaned);
+  const rel = path39.relative(staticDir, abs);
+  if (rel.startsWith("..") || path39.isAbsolute(rel)) {
     return null;
   }
   try {
-    await fs25.stat(abs);
+    await fs26.stat(abs);
     return { abs, exists: true };
   } catch {
     return { abs, exists: false };
@@ -181539,7 +182073,7 @@ function injectAccessMarkup(html, apiKey, trusted) {
   return out;
 }
 async function readShell(indexPath, remoteAddress) {
-  const raw2 = await fs25.readFile(indexPath, "utf-8");
+  const raw2 = await fs26.readFile(indexPath, "utf-8");
   const trusted = isTrustedWebUiCaller(remoteAddress);
   return Buffer.from(injectAccessMarkup(raw2, getConfiguredApiKey(), trusted), "utf-8");
 }
@@ -181556,7 +182090,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     set3.status = 500;
     return { status: 500, error: "web ui static dir not found" };
   }
-  const indexPath = path37.join(dir, "index.html");
+  const indexPath = path39.join(dir, "index.html");
   try {
     const body = await readShell(indexPath, remoteAddressOf(request));
     set3.headers["content-type"] = contentTypeFor(indexPath);
@@ -181589,7 +182123,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
   }
   if (resolved.exists) {
     try {
-      const body = await fs25.readFile(resolved.abs);
+      const body = await fs26.readFile(resolved.abs);
       set3.headers["content-type"] = contentTypeFor(resolved.abs);
       return body;
     } catch {
@@ -181598,7 +182132,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     }
   }
   try {
-    const body = await readShell(path37.join(dir, "index.html"), remoteAddressOf(request));
+    const body = await readShell(path39.join(dir, "index.html"), remoteAddressOf(request));
     set3.headers["content-type"] = "text/html; charset=utf-8";
     return body;
   } catch {
@@ -181746,8 +182280,8 @@ init_dist();
 
 // src/routes/model-registry-deployment.ts
 init_dist();
-import path38 from "path";
-var MARKER = path38.join("scripts", "generate-subagent-artifacts.ts");
+import path40 from "path";
+var MARKER = path40.join("scripts", "generate-subagent-artifacts.ts");
 var MAX_LEVELS2 = 6;
 var cachedRoot;
 function findDeploymentRoot(startDir) {
@@ -181765,8 +182299,8 @@ function deploymentUnavailableMessage(what) {
 
 // src/routes/model-registry.ts
 init_config();
-import fs26 from "fs";
-import path39 from "path";
+import fs27 from "fs";
+import path41 from "path";
 import { spawnSync } from "child_process";
 var _profilesLib = null;
 function profilesLib() {
@@ -181775,7 +182309,7 @@ function profilesLib() {
     if (!root2) {
       throw new Error(deploymentUnavailableMessage("scripts/lib/model-profiles.ts"));
     }
-    const libPath = path39.join(root2, "scripts", "lib", "model-profiles.ts");
+    const libPath = path41.join(root2, "scripts", "lib", "model-profiles.ts");
     _profilesLib = __require(libPath);
   }
   return _profilesLib;
@@ -181800,7 +182334,7 @@ function generatorLib() {
     if (!root2) {
       throw new Error(deploymentUnavailableMessage("scripts/generate-subagent-artifacts.ts"));
     }
-    const libPath = path39.join(root2, "scripts", "generate-subagent-artifacts.ts");
+    const libPath = path41.join(root2, "scripts", "generate-subagent-artifacts.ts");
     _generatorLib = __require(libPath);
   }
   return _generatorLib;
@@ -181817,7 +182351,7 @@ async function loadAgentsInventory() {
 var REGISTRY_DETAIL = {
   tags: ["model-registry"]
 };
-var OVERLAY_PATH = path39.join(configDir("massa-ai"), "model-profiles.json");
+var OVERLAY_PATH = path41.join(configDir("massa-ai"), "model-profiles.json");
 var modelRegistryRoutes = new Elysia({ prefix: "/api/v1/model-registry" }).get("/", async ({ set: set3 }) => {
   const root2 = getDeploymentRoot();
   if (!root2) {
@@ -181900,7 +182434,7 @@ var modelRegistryRoutes = new Elysia({ prefix: "/api/v1/model-registry" }).get("
     set3.status = 501;
     return { success: false, error: deploymentUnavailableMessage("scripts/generate-subagent-artifacts.ts") };
   }
-  const generateScript = path39.join(root2, "scripts", "generate-subagent-artifacts.ts");
+  const generateScript = path41.join(root2, "scripts", "generate-subagent-artifacts.ts");
   try {
     const child = spawnSync("bun", [generateScript], {
       env: { ...process.env },
@@ -181939,8 +182473,8 @@ var modelRegistryRoutes = new Elysia({ prefix: "/api/v1/model-registry" }).get("
   }
   const lib = profilesLib();
   try {
-    if (fs26.existsSync(OVERLAY_PATH)) {
-      fs26.unlinkSync(OVERLAY_PATH);
+    if (fs27.existsSync(OVERLAY_PATH)) {
+      fs27.unlinkSync(OVERLAY_PATH);
     }
     const builtin = lib.loadRegistry(lib.DEFAULT_REGISTRY_PATH);
     set3.status = 200;
@@ -181966,17 +182500,17 @@ var modelRegistryRoutes = new Elysia({ prefix: "/api/v1/model-registry" }).get("
   }
 });
 function writeOverlayAtomically(overlayPath, data) {
-  const dir = path39.dirname(overlayPath);
-  if (!fs26.existsSync(dir)) {
-    fs26.mkdirSync(dir, { recursive: true });
+  const dir = path41.dirname(overlayPath);
+  if (!fs27.existsSync(dir)) {
+    fs27.mkdirSync(dir, { recursive: true });
   }
   const tmp = `${overlayPath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    fs26.writeFileSync(tmp, JSON.stringify(data, null, 2));
-    fs26.renameSync(tmp, overlayPath);
+    fs27.writeFileSync(tmp, JSON.stringify(data, null, 2));
+    fs27.renameSync(tmp, overlayPath);
   } catch (e) {
     try {
-      fs26.unlinkSync(tmp);
+      fs27.unlinkSync(tmp);
     } catch {}
     throw e;
   }
@@ -182166,7 +182700,7 @@ var configRoutes = new Elysia({ prefix: "/api/v1/config" }).get("/", ({ set: set
 // src/routes/model-registry-stream.ts
 init_config();
 init_dist();
-import path40 from "path";
+import path42 from "path";
 import { spawn as spawn3 } from "child_process";
 var encoder3 = new TextEncoder;
 function sseFrame(data) {
@@ -182248,7 +182782,7 @@ function createRegenerateStreamHandler() {
           closedRef.closed = true;
           return;
         }
-        const generateScript = path40.join(root2, "scripts", "generate-subagent-artifacts.ts");
+        const generateScript = path42.join(root2, "scripts", "generate-subagent-artifacts.ts");
         try {
           child = spawn3("bun", [generateScript], {
             env: { ...process.env },
@@ -182440,13 +182974,390 @@ var restartRoutes = new Elysia({ prefix: "/api/v1/system" }).onAfterResponse(()
   }
 });
 
+// src/routes/logs.ts
+init_dist();
+import fs28 from "fs";
+var LOGS_DETAIL = { tags: ["logs"] };
+var MAX_SCAN_BYTES = 64 * 1024 * 1024;
+var MAX_LIMIT = 1000;
+var DEFAULT_LIMIT = 200;
+function isQueryValidationError(v) {
+  return "param" in v;
+}
+function parseRangeQuery(query) {
+  const fromRaw = query.from;
+  const toRaw = query.to;
+  const fromMs = fromRaw !== undefined ? Date.parse(fromRaw) : -Infinity;
+  if (fromRaw !== undefined && Number.isNaN(fromMs)) {
+    return { param: "from", message: `"from" is not a parseable ISO-8601 timestamp: "${fromRaw}"` };
+  }
+  const toMs = toRaw !== undefined ? Date.parse(toRaw) : Infinity;
+  if (toRaw !== undefined && Number.isNaN(toMs)) {
+    return { param: "to", message: `"to" is not a parseable ISO-8601 timestamp: "${toRaw}"` };
+  }
+  if (fromMs > toMs) {
+    return { param: "from", message: `"from" (${fromRaw}) is after "to" (${toRaw})` };
+  }
+  let limit = DEFAULT_LIMIT;
+  if (query.limit !== undefined) {
+    const n2 = Number(query.limit);
+    if (!Number.isFinite(n2) || n2 < 0) {
+      return { param: "limit", message: `"limit" must be a non-negative number: "${query.limit}"` };
+    }
+    if (n2 > MAX_LIMIT) {
+      return { param: "limit", message: `"limit" exceeds the maximum of ${MAX_LIMIT}: "${query.limit}"` };
+    }
+    limit = Math.floor(n2);
+  }
+  let offset = 0;
+  if (query.offset !== undefined) {
+    const n2 = Number(query.offset);
+    if (!Number.isFinite(n2) || n2 < 0) {
+      return { param: "offset", message: `"offset" must be a non-negative number: "${query.offset}"` };
+    }
+    offset = Math.floor(n2);
+  }
+  return { fromMs, toMs, fromRaw, toRaw, level: query.level, q: query.q, limit, offset };
+}
+var LINE_RE = /^\[(?<ts>[^\]]+)\] \[(?<level>[A-Z]+)\] (?<rest>[\s\S]*)$/;
+function normalizeLevel(raw2) {
+  const lower2 = raw2.toLowerCase();
+  return lower2 === "debug" || lower2 === "info" || lower2 === "warn" || lower2 === "error" ? lower2 : "raw";
+}
+function splitMessageAndMeta(rest) {
+  if (!rest.endsWith("}"))
+    return { message: rest };
+  let searchFrom = rest.length;
+  for (;; ) {
+    const idx = rest.lastIndexOf(" {", searchFrom - 1);
+    if (idx === -1)
+      break;
+    const candidate2 = rest.slice(idx + 1);
+    try {
+      const parsed = JSON.parse(candidate2);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return { message: rest.slice(0, idx), meta: parsed };
+      }
+    } catch {}
+    searchFrom = idx;
+  }
+  return { message: rest };
+}
+function parseLine(line, prevTs) {
+  const match2 = LINE_RE.exec(line);
+  if (!match2 || !match2.groups) {
+    return { entry: { seq: 0, ts: prevTs, level: "raw", message: line }, ts: prevTs };
+  }
+  const { ts, level, rest } = match2.groups;
+  const { message, meta: meta3 } = splitMessageAndMeta(rest);
+  const entry2 = { seq: 0, ts, level: normalizeLevel(level), message, ...meta3 ? { meta: meta3 } : {} };
+  return { entry: entry2, ts };
+}
+function realReadTail(filePath, maxBytes) {
+  let size;
+  try {
+    size = fs28.statSync(filePath).size;
+  } catch {
+    return { content: "", truncated: false };
+  }
+  if (size === 0)
+    return { content: "", truncated: false };
+  if (size <= maxBytes) {
+    try {
+      return { content: fs28.readFileSync(filePath, "utf8"), truncated: false };
+    } catch {
+      return { content: "", truncated: false };
+    }
+  }
+  try {
+    const fd = fs28.openSync(filePath, "r");
+    try {
+      const start = size - maxBytes;
+      const buf = Buffer.alloc(maxBytes);
+      fs28.readSync(fd, buf, 0, maxBytes, start);
+      let text3 = buf.toString("utf8");
+      const firstNewline = text3.indexOf(`
+`);
+      text3 = firstNewline !== -1 ? text3.slice(firstNewline + 1) : "";
+      return { content: text3, truncated: true };
+    } finally {
+      fs28.closeSync(fd);
+    }
+  } catch {
+    return { content: "", truncated: true };
+  }
+}
+var realReader = {
+  listFiles(filePath, maxFiles) {
+    return sinkFiles(filePath, maxFiles).filter((f) => {
+      try {
+        fs28.accessSync(f, fs28.constants.R_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  },
+  readTail: realReadTail
+};
+var activeReader = realReader;
+function scanEntries() {
+  const loggingConfig = config.get("logging");
+  const filePath = loggingConfig.file;
+  const files = filePath ? activeReader.listFiles(filePath, loggingConfig.maxFiles) : [];
+  if (files.length === 0) {
+    return { entries: logBuffer.snapshot(), source: "buffer", truncated: false };
+  }
+  const readFiles = [];
+  let budgetLeft = MAX_SCAN_BYTES;
+  let truncated = false;
+  for (const file3 of files) {
+    if (budgetLeft <= 0) {
+      truncated = true;
+      break;
+    }
+    const { content, truncated: fileTruncated } = activeReader.readTail(file3, budgetLeft);
+    if (fileTruncated)
+      truncated = true;
+    readFiles.push(content);
+    budgetLeft -= Buffer.byteLength(content, "utf8");
+    if (fileTruncated)
+      break;
+  }
+  let prevTs = new Date().toISOString();
+  const chronoEntries = [];
+  for (let i = readFiles.length - 1;i >= 0; i--) {
+    const lines = readFiles[i].split(`
+`).filter((l2) => l2.length > 0);
+    for (const line of lines) {
+      const { entry: entry2, ts } = parseLine(line, prevTs);
+      prevTs = ts;
+      chronoEntries.push(entry2);
+    }
+  }
+  const entries = chronoEntries.reverse();
+  for (let i = 0;i < entries.length; i++) {
+    entries[i].seq = entries.length - 1 - i;
+  }
+  return { entries, source: "file", truncated };
+}
+function matchesFilter(entry2, parsed) {
+  const tsMs = Date.parse(entry2.ts);
+  if (Number.isNaN(tsMs) || tsMs < parsed.fromMs || tsMs > parsed.toMs)
+    return false;
+  if (parsed.level !== undefined && entry2.level !== parsed.level)
+    return false;
+  if (parsed.q !== undefined && !entry2.message.toLowerCase().includes(parsed.q.toLowerCase()))
+    return false;
+  return true;
+}
+function filteredEntries(parsed) {
+  const scan = scanEntries();
+  return { ...scan, entries: scan.entries.filter((e) => matchesFilter(e, parsed)) };
+}
+function sanitizeForFilename(s) {
+  return s.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+function exportFilename(parsed, ext2) {
+  const fromPart = sanitizeForFilename(parsed.fromRaw ?? "all");
+  const toPart = sanitizeForFilename(parsed.toRaw ?? "all");
+  return `massa-ai-logs-${fromPart}_${toPart}.${ext2}`;
+}
+function renderTxtLine(entry2) {
+  const metaStr = entry2.meta ? ` ${JSON.stringify(entry2.meta)}` : "";
+  return `[${entry2.ts}] [${entry2.level.toUpperCase()}] ${entry2.message}${metaStr}`;
+}
+var SSE_HEARTBEAT_MS_DEFAULT = 15000;
+var SSE_MAX_DURATION_MS_DEFAULT = 10 * 60 * 1000;
+var SINK_POLL_MS_DEFAULT = 1000;
+var SINK_POLL_MAX_BYTES = 1024 * 1024;
+function startSinkTail(enqueue) {
+  const loggingConfig = config.get("logging");
+  const filePath = loggingConfig.file;
+  if (!filePath)
+    return;
+  const initial = activeReader.listFiles(filePath, loggingConfig.maxFiles);
+  if (initial.length === 0)
+    return;
+  let currentFile = initial[0];
+  let offset;
+  try {
+    offset = fs28.statSync(currentFile).size;
+  } catch {
+    return;
+  }
+  let carry = "";
+  let prevTs = new Date().toISOString();
+  let seq = 0;
+  const pollMs = Number(process.env.MASSA_AI_SSE_SINK_POLL_MS) || SINK_POLL_MS_DEFAULT;
+  const timer = setInterval(() => {
+    try {
+      const newest = activeReader.listFiles(filePath, loggingConfig.maxFiles)[0];
+      if (newest && newest !== currentFile) {
+        currentFile = newest;
+        offset = 0;
+        carry = "";
+      }
+      const size = fs28.statSync(currentFile).size;
+      if (size < offset) {
+        offset = 0;
+        carry = "";
+      }
+      if (size === offset)
+        return;
+      const length = Math.min(size - offset, SINK_POLL_MAX_BYTES);
+      const buf = Buffer.alloc(length);
+      const fd = fs28.openSync(currentFile, "r");
+      try {
+        fs28.readSync(fd, buf, 0, length, offset);
+      } finally {
+        fs28.closeSync(fd);
+      }
+      offset += length;
+      const text3 = carry + buf.toString("utf8");
+      const lines = text3.split(`
+`);
+      carry = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.trim() === "")
+          continue;
+        const parsed = parseLine(line, prevTs);
+        prevTs = parsed.ts;
+        enqueue({ ...parsed.entry, seq: ++seq });
+      }
+    } catch {}
+  }, pollMs);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+var logsRoutes = new Elysia({ prefix: "/api/v1/logs" }).get("/", ({ query, set: set3 }) => {
+  const parsed = parseRangeQuery(query);
+  if (isQueryValidationError(parsed)) {
+    set3.status = 400;
+    return { success: false, error: `invalid "${parsed.param}": ${parsed.message}` };
+  }
+  const { entries, source, truncated } = filteredEntries(parsed);
+  const total = entries.length;
+  const page = entries.slice(parsed.offset, parsed.offset + parsed.limit);
+  set3.status = 200;
+  return { success: true, data: { entries: page, total, source, truncated } };
+}, {
+  detail: {
+    ...LOGS_DETAIL,
+    summary: "Range/level/substring query over the log sink (or the ring buffer)",
+    description: 'Query params: from, to (ISO-8601, closed interval), level, q (substring), limit (<=1000), offset. Reads the file sink newest-first within a 64 MB scan bound (truncated:true if the bound was hit); falls back to the in-process ring buffer (source:"buffer") when no sink file is present or readable. Validates from/to/limit before any read.'
+  }
+}).get("/export", ({ query, set: set3 }) => {
+  const parsed = parseRangeQuery(query);
+  if (isQueryValidationError(parsed)) {
+    set3.status = 400;
+    return { success: false, error: `invalid "${parsed.param}": ${parsed.message}` };
+  }
+  const { entries } = filteredEntries(parsed);
+  const format = query.format === "txt" ? "txt" : "jsonl";
+  const ext2 = format === "txt" ? "txt" : "jsonl";
+  const contentType = format === "txt" ? "text/plain" : "application/x-ndjson";
+  const body = format === "txt" ? entries.map(renderTxtLine).join(`
+`) : entries.map((e) => JSON.stringify(e)).join(`
+`);
+  const filename = exportFilename(parsed, ext2);
+  return new Response(body, {
+    status: 200,
+    headers: {
+      "Content-Type": contentType,
+      "Content-Disposition": `attachment; filename="${filename}"`
+    }
+  });
+}, {
+  detail: {
+    ...LOGS_DETAIL,
+    summary: "Download the queried log range as jsonl or txt",
+    description: "Same query surface as GET /api/v1/logs (minus limit/offset \u2014 the full matching range is returned) plus format=jsonl|txt. Responds with Content-Disposition: attachment and a filename carrying the range. A range matching zero entries still returns an empty (200) download."
+  }
+}).get("/stream", () => {
+  const HEARTBEAT_MS = Number(process.env.MASSA_AI_SSE_HEARTBEAT_MS) || SSE_HEARTBEAT_MS_DEFAULT;
+  const MAX_DURATION_MS = Number(process.env.MASSA_AI_SSE_MAX_DURATION_MS) || SSE_MAX_DURATION_MS_DEFAULT;
+  const encoder4 = new TextEncoder;
+  let closed = false;
+  let unsubscribe;
+  let heartbeatTimer;
+  let closeTimer;
+  const stream2 = new ReadableStream({
+    start(controller2) {
+      const enqueue = (data) => {
+        if (closed)
+          return;
+        try {
+          controller2.enqueue(encoder4.encode(`data: ${JSON.stringify(data)}
+
+`));
+        } catch {
+          closed = true;
+        }
+      };
+      const tail = startSinkTail(enqueue);
+      if (tail) {
+        unsubscribe = tail;
+      } else {
+        unsubscribe = logBuffer.subscribe((entry2) => {
+          enqueue(entry2);
+        });
+      }
+      heartbeatTimer = setInterval(() => {
+        if (closed) {
+          clearInterval(heartbeatTimer);
+          return;
+        }
+        try {
+          controller2.enqueue(encoder4.encode(`: heartbeat
+
+`));
+        } catch {
+          closed = true;
+          clearInterval(heartbeatTimer);
+        }
+      }, HEARTBEAT_MS);
+      closeTimer = setTimeout(() => {
+        closed = true;
+        unsubscribe?.();
+        clearInterval(heartbeatTimer);
+        try {
+          controller2.close();
+        } catch {}
+      }, MAX_DURATION_MS);
+    },
+    cancel() {
+      closed = true;
+      unsubscribe?.();
+      if (heartbeatTimer)
+        clearInterval(heartbeatTimer);
+      if (closeTimer)
+        clearTimeout(closeTimer);
+    }
+  });
+  return new Response(stream2, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    }
+  });
+}, {
+  detail: {
+    ...LOGS_DETAIL,
+    summary: "SSE tail of newly buffered log entries",
+    description: "Server-Sent Events stream emitting `data: <LogEntry JSON>` for every entry subsequently pushed into the in-process ring buffer, plus `: heartbeat` comments. Same heartbeat and max-duration auto-close behavior as GET /api/v1/events. Scoped to this server process \u2014 a separate range query over the file sink may contain entries this stream never showed (e.g. from the stdio MCP server)."
+  }
+});
+
 // src/middleware/error.ts
 init_dist();
-var errorHandler = new Elysia({ name: "error-handler" }).onError(({ code, error: error51, set: set3, path: path41, request }) => {
+var errorHandler = new Elysia({ name: "error-handler" }).onError(({ code, error: error51, set: set3, path: path43, request }) => {
   logger.error("[massa-ai-api] Request failed", undefined, {
     ...safeErrorSummary(error51),
     code,
-    path: path41,
+    path: path43,
     method: request.method
   });
   if (error51 instanceof SearchServiceError) {
@@ -182548,7 +183459,8 @@ var app = new Elysia({ adapter: node() }).use(cors(buildCorsOptions(config.get("
       { name: "executor", description: "Polyglot sandbox: execute code, run code over files, batch shell commands" },
       { name: "web", description: "SSRF-guarded web fetch + HTML\u2192md + index (fetch_and_index)" },
       { name: "webUi", description: "Read-only memory/search web browser (Phase 8)" },
-      { name: "profiles", description: "Model-profile switch: list shipped profiles, switch installed agents" }
+      { name: "profiles", description: "Model-profile switch: list shipped profiles, switch installed agents" },
+      { name: "logs", description: "Log read: range/level/substring query, export, live SSE tail" }
     ],
     components: {
       securitySchemes: {
@@ -182562,15 +183474,26 @@ var app = new Elysia({ adapter: node() }).use(cors(buildCorsOptions(config.get("
     },
     security: [{ ApiKeyAuth: [] }]
   }
-})).use(errorHandler).use(authMiddleware).use(searchRoutes).use(memoryRoutes).use(checkpointRoutes).use(projectRoutes).use(contextRoutes).use(analyticsRoutes).use(systemRoutes).use(eventsRoutes).use(workspaceRoutes).use(fileRoutes).use(synapseRoutes).use(hookRoutes).use(bootstrapRoutes).use(handoffRoutes).use(proposalRoutes).use(executorRoutes).use(webRoutes).use(webUiRoutes).use(architectureRoutes).use(dashboardRoutes).use(profileRoutes).use(configRoutes).use(modelRegistryRoutes).use(modelRegistryStreamRoutes).use(restartRoutes).get("/health", () => buildHealthResponse(getParserReadiness()));
+})).use(errorHandler).use(authMiddleware).use(searchRoutes).use(memoryRoutes).use(checkpointRoutes).use(projectRoutes).use(contextRoutes).use(analyticsRoutes).use(systemRoutes).use(eventsRoutes).use(workspaceRoutes).use(fileRoutes).use(synapseRoutes).use(hookRoutes).use(bootstrapRoutes).use(handoffRoutes).use(proposalRoutes).use(executorRoutes).use(webRoutes).use(webUiRoutes).use(architectureRoutes).use(dashboardRoutes).use(profileRoutes).use(configRoutes).use(modelRegistryRoutes).use(modelRegistryStreamRoutes).use(restartRoutes).use(logsRoutes).get("/health", () => buildHealthResponse(getParserReadiness()));
 initAuthOrExit();
 warnIfTrustOverrideEnabled();
 await listenAfterParserValidation({
   validate: validateAllGrammars,
   listen: () => {
-    app.listen(PORT, (server) => {
-      setServerStopper(() => void server.stop());
-    });
+    try {
+      app.listen({ port: Number(PORT), reusePort: false }, (server) => {
+        setServerStopper(() => void server.stop());
+      });
+    } catch (error51) {
+      if (error51?.code === "EADDRINUSE") {
+        console.error(`Port ${PORT} is already in use \u2014 another massa-ai Tools API is running.
+` + `Stop it first, or start this one on another port:
+` + `  lsof -nP -iTCP:${PORT} -sTCP:LISTEN
+` + `  MASSA_AI_API_PORT=<other> bun run dev:api`);
+        process.exit(1);
+      }
+      throw error51;
+    }
   },
   onValidationFailure: (error51) => {
     console.error("Structural parser readiness failed; indexing is unavailable:", error51 instanceof Error ? error51.message : error51);