@massa-ai/opencode-plugin 1.46.0 → 1.48.0

package/dist/config-cli.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();
@@ -734,11 +822,14 @@ try {
 // ../../packages/shared/dist/config/index.js
 init_config_loader();
 init_massa_ai_config();
+init_massa_ai_config();
+init_massa_ai_config();
 init_config_loader();
 import path4 from "path";
 
 // ../../packages/shared/dist/config/config-writer.js
 init_config_loader();
+init_massa_ai_config();
 
 // ../../packages/shared/dist/config/index.js
 init_xdg();
@@ -778,7 +869,49 @@ function envList(key, fallback) {
   const parsed = s.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
   return parsed.length > 0 ? parsed : fallback;
 }
-var MAX_IGNORE_PATTERNS = 1024;
+function readSchedulerConfig(rawFileConfig) {
+  try {
+    const cfg = rawFileConfig;
+    return cfg?.scheduler ?? {};
+  } catch {
+    return {};
+  }
+}
+var 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
+  }
+};
+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(raw) {
   if (!raw || typeof raw !== "object")
     throw new TypeError("capturePolicy must be an object");
@@ -881,10 +1014,11 @@ var DEFAULT_ALLOWED_EXTENSIONS = [
 var fileConfig = loadConfigSafe();
 var fileCacheL1Bytes = fileConfig.cache?.l1MaxSizeMB ? fileConfig.cache.l1MaxSizeMB * 1024 * 1024 : undefined;
 var fileCacheL2Bytes = fileConfig.cache?.l2MaxSizeMB ? fileConfig.cache.l2MaxSizeMB * 1024 * 1024 : undefined;
+var resolvedDataDir = getGlobalDataDir();
 var 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),
@@ -1008,8 +1142,24 @@ var defaultConfig = {
   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 || path4.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: {
@@ -1124,6 +1274,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,
@@ -1288,8 +1443,165 @@ var TaskStatus;
   TaskStatus2["FAILED"] = "failed";
   TaskStatus2["PAUSED"] = "paused";
 })(TaskStatus || (TaskStatus = {}));
-// ../../packages/shared/dist/utils/logger.js
+// ../../packages/shared/dist/utils/log-sink.js
 import fs2 from "fs";
+import path5 from "path";
+var STAT_DELTA_THRESHOLD_BYTES = 1024 * 1024;
+var ensuredDirs = new Set;
+var pathState = new Map;
+var lastError;
+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 = path5.dirname(filePath);
+  if (ensuredDirs.has(dir))
+    return;
+  fs2.mkdirSync(dir, { recursive: true });
+  ensuredDirs.add(dir);
+}
+function restat(filePath, state) {
+  try {
+    state.trackedSize = fs2.statSync(filePath).size;
+  } catch {
+    state.trackedSize = 0;
+  }
+  state.deltaSinceStat = 0;
+  state.primed = true;
+}
+function rotate(filePath, maxFiles) {
+  if (maxFiles <= 0) {
+    if (fs2.existsSync(filePath))
+      fs2.unlinkSync(filePath);
+    return;
+  }
+  const oldest = `${filePath}.${maxFiles}`;
+  if (fs2.existsSync(oldest))
+    fs2.unlinkSync(oldest);
+  for (let n = maxFiles - 1;n >= 1; n--) {
+    const src = `${filePath}.${n}`;
+    const dest = `${filePath}.${n + 1}`;
+    if (fs2.existsSync(src))
+      fs2.renameSync(src, dest);
+  }
+  if (fs2.existsSync(filePath))
+    fs2.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;
+    }
+    fs2.appendFileSync(filePath, line + `
+`);
+    state.trackedSize += lineBytes;
+    state.deltaSinceStat += lineBytes;
+  } catch (err) {
+    lastError = err;
+  }
+}
+
+// ../../packages/shared/dist/utils/log-buffer.js
+var DEFAULT_CAPACITY = 2000;
+
+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(n) {
+    this.capacity = n > 0 ? n : 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 logBuffer = new LogBufferImpl;
+
+// ../../packages/shared/dist/utils/logger.js
 var LogLevel;
 (function(LogLevel2) {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
@@ -1297,11 +1609,26 @@ var LogLevel;
   LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
 })(LogLevel || (LogLevel = {}));
+var LOG_LEVEL_LABELS = {
+  [LogLevel.DEBUG]: "DEBUG",
+  [LogLevel.INFO]: "INFO",
+  [LogLevel.WARN]: "WARN",
+  [LogLevel.ERROR]: "ERROR"
+};
+var LOG_LEVEL_BUFFER_TAGS = {
+  [LogLevel.DEBUG]: "debug",
+  [LogLevel.INFO]: "info",
+  [LogLevel.WARN]: "warn",
+  [LogLevel.ERROR]: "error"
+};
 
 class Logger {
   _level;
   _enableMetrics;
   _logFilePath;
+  _enableFileSink;
+  _maxFileSizeBytes;
+  _maxFiles;
   _initialized = false;
   constructor() {}
   ensureInitialized() {
@@ -1311,10 +1638,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;
     }
@@ -1331,6 +1666,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,
@@ -1343,34 +1690,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 {
-        fs2.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) {
@@ -1383,7 +1736,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) {
@@ -1507,7 +1860,7 @@ class SmartRateLimiter {
 var rateLimiter = new SmartRateLimiter;
 // ../../packages/shared/dist/profile-switch/hosts.js
 import os3 from "os";
-import path5 from "path";
+import path6 from "path";
 var HOSTS = ["claude", "codex", "cursor", "opencode"];
 function isHost(v) {
   return typeof v === "string" && HOSTS.includes(v);
@@ -1520,7 +1873,7 @@ function fileLayout(host, activeDir, activeGlob, variantsRoot) {
     activeDir,
     activeGlob,
     variantsRoot,
-    variantDir: (profile) => path5.join(variantsRoot, profile)
+    variantDir: (profile) => path6.join(variantsRoot, profile)
   };
 }
 function resolveHostLayout(host, opts = {}) {
@@ -1530,25 +1883,37 @@ function resolveHostLayout(host, opts = {}) {
     case "cursor":
       return { host, route: "skip", reason: CURSOR_SKIP_REASON };
     case "claude": {
-      const root = override ?? path5.join(targetHome, ".claude");
-      return fileLayout(host, path5.join(root, "agents"), "massa-ai-*.md", path5.join(root, "massa-ai", "agent-profiles"));
+      const marketplaceRoot = opts.marketplaceRoot?.claude;
+      if (override === undefined && marketplaceRoot !== undefined) {
+        return fileLayout(host, path6.join(marketplaceRoot, "agents"), "massa-ai-*.md", path6.join(marketplaceRoot, "agent-profiles"));
+      }
+      const root = override ?? path6.join(targetHome, ".claude");
+      return fileLayout(host, path6.join(root, "agents"), "massa-ai-*.md", path6.join(root, "massa-ai", "agent-profiles"));
     }
     case "codex": {
-      const root = override ?? path5.join(targetHome, ".codex");
-      return fileLayout(host, path5.join(root, "agents"), "massa-ai-*.toml", path5.join(root, "massa-ai", "agent-profiles"));
+      const root = override ?? path6.join(targetHome, ".codex");
+      return fileLayout(host, path6.join(root, "agents"), "massa-ai-*.toml", path6.join(root, "massa-ai", "agent-profiles"));
     }
     case "opencode": {
-      const root = override ?? path5.join(targetHome, ".config", "opencode");
-      const pluginsDir = path5.join(root, "plugins", "massa-ai");
-      return fileLayout(host, path5.join(root, "agents"), "massa-ai-*.md", path5.join(pluginsDir, "agent-profiles"));
+      const root = override ?? path6.join(targetHome, ".config", "opencode");
+      const pluginsDir = path6.join(root, "plugins", "massa-ai");
+      return fileLayout(host, path6.join(root, "agents"), "massa-ai-*.md", path6.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."
@@ -1561,7 +1926,7 @@ function detectRoute(platform) {
 }
 // ../../packages/shared/dist/profile-switch/state.js
 import fs3 from "fs";
-import path6 from "path";
+import path7 from "path";
 
 class InstallStateError extends Error {
   constructor(message) {
@@ -1617,7 +1982,7 @@ function writeInstallState(filePath, state) {
   const text = `${JSON.stringify(validated, null, 2)}
 `;
   try {
-    fs3.mkdirSync(path6.dirname(filePath), { recursive: true });
+    fs3.mkdirSync(path7.dirname(filePath), { recursive: true });
     fs3.writeFileSync(filePath, text);
   } catch (err) {
     throw UnwritableInstallStateError(filePath, err.message);
@@ -1636,7 +2001,7 @@ function updatePlatform(filePath, host, patch) {
 }
 // ../../packages/shared/dist/profile-switch/lock.js
 import fs4 from "fs";
-import path7 from "path";
+import path8 from "path";
 import os4 from "os";
 import crypto2 from "crypto";
 import { execFileSync } from "child_process";
@@ -1693,7 +2058,7 @@ function releaseIfOwned(lockDir, ownerPath, token) {
 }
 function acquireLock(stateFilePath, options = {}) {
   const lockDir = `${stateFilePath}.switch.lock`;
-  const ownerPath = path7.join(lockDir, "owner.json");
+  const ownerPath = path8.join(lockDir, "owner.json");
   const clock = options.clock ?? DEFAULT_CLOCK;
   const identity = options.identity ?? DEFAULT_IDENTITY;
   const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
@@ -1713,7 +2078,7 @@ function acquireLock(stateFilePath, options = {}) {
       token,
       timestamp: clock.now()
     };
-    fs4.mkdirSync(path7.dirname(ownerPath), { recursive: true });
+    fs4.mkdirSync(path8.dirname(ownerPath), { recursive: true });
     fs4.writeFileSync(ownerPath, JSON.stringify(record));
     return { lockDir, release: () => releaseIfOwned(lockDir, ownerPath, token) };
   };
@@ -1741,10 +2106,60 @@ function acquireLock(stateFilePath, options = {}) {
   }
 }
 // ../../packages/shared/dist/profile-switch/engine.js
+import fs6 from "fs";
+import path10 from "path";
+import os6 from "os";
+import crypto3 from "crypto";
+
+// ../../packages/shared/dist/profile-switch/claude-marketplace.js
 import fs5 from "fs";
-import path8 from "path";
 import os5 from "os";
-import crypto3 from "crypto";
+import path9 from "path";
+var DEFAULT_PLUGIN_KEY = "massa-ai@massa-ai";
+function selectRecord(records) {
+  if (records.length === 0)
+    return;
+  const userScoped = records.filter((r) => r.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 = path9.join(targetHome, ".claude", "plugins", "installed_plugins.json");
+  let records;
+  try {
+    const raw = fs5.readFileSync(registryPath, "utf8");
+    const parsed = JSON.parse(raw);
+    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 (!fs5.existsSync(installPath))
+      return null;
+  } catch {
+    return null;
+  }
+  return installPath;
+}
+
+// ../../packages/shared/dist/profile-switch/engine.js
 class SwitchEngineError extends Error {
   constructor(message) {
     super(message);
@@ -1759,19 +2174,39 @@ function namedError3(name, message) {
 var UnknownProfileError = (profile, known) => namedError3("UnknownProfileError", `unknown profile "${profile}" \u2014 installed: ${known.length > 0 ? known.join(", ") : "none"}`);
 var NoHostsDetectedError = () => namedError3("NoHostsDetectedError", "no installed hosts found");
 function defaultStatePath(targetHome) {
-  return path8.join(targetHome, ".config", "massa-ai", "install-state.json");
+  return path10.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 = path10.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,
@@ -1783,7 +2218,7 @@ function listProfiles(opts = {}) {
         availableProfiles: []
       };
     }
-    const installed = fs5.existsSync(layout.activeDir);
+    const installed = fs6.existsSync(layout.activeDir);
     const availableProfiles = listVariantProfiles(layout);
     const platform = state.platforms[host];
     return {
@@ -1799,9 +2234,9 @@ function listProfiles(opts = {}) {
   return { hosts };
 }
 function listVariantProfiles(layout) {
-  if (!fs5.existsSync(layout.variantsRoot))
+  if (!fs6.existsSync(layout.variantsRoot))
     return [];
-  return fs5.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  return fs6.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function matchesGlob(filename, glob) {
   const starIdx = glob.indexOf("*");
@@ -1812,50 +2247,50 @@ function matchesGlob(filename, glob) {
   return filename.length >= prefix.length + suffix.length && filename.startsWith(prefix) && filename.endsWith(suffix);
 }
 function assertStateWritable(stateFilePath) {
-  const dir = path8.dirname(stateFilePath);
+  const dir = path10.dirname(stateFilePath);
   try {
-    fs5.mkdirSync(dir, { recursive: true });
+    fs6.mkdirSync(dir, { recursive: true });
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
-  const checkPath = fs5.existsSync(stateFilePath) ? stateFilePath : dir;
+  const checkPath = fs6.existsSync(stateFilePath) ? stateFilePath : dir;
   try {
-    fs5.accessSync(checkPath, fs5.constants.W_OK);
+    fs6.accessSync(checkPath, fs6.constants.W_OK);
   } catch (err) {
     throw UnwritableInstallStateError(stateFilePath, err.message);
   }
 }
 function copyFileRouteVariant(layout, variantDir) {
-  fs5.mkdirSync(layout.activeDir, { recursive: true });
+  fs6.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs5.readdirSync(variantDir, { withFileTypes: true })) {
+  for (const entry of fs6.readdirSync(variantDir, { withFileTypes: true })) {
     if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
       continue;
-    fs5.copyFileSync(path8.join(variantDir, entry.name), path8.join(layout.activeDir, entry.name));
+    fs6.copyFileSync(path10.join(variantDir, entry.name), path10.join(layout.activeDir, entry.name));
     changed++;
   }
   return changed;
 }
 function repointOpencodeVariant(layout, variantDir) {
-  fs5.mkdirSync(layout.activeDir, { recursive: true });
+  fs6.mkdirSync(layout.activeDir, { recursive: true });
   let changed = 0;
-  for (const entry of fs5.readdirSync(variantDir, { withFileTypes: true })) {
+  for (const entry of fs6.readdirSync(variantDir, { withFileTypes: true })) {
     if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
       continue;
-    const dest = path8.join(layout.activeDir, entry.name);
-    const target = path8.resolve(path8.join(variantDir, entry.name));
+    const dest = path10.join(layout.activeDir, entry.name);
+    const target = path10.resolve(path10.join(variantDir, entry.name));
     let destExists = true;
     let destIsSymlink = false;
     try {
-      destIsSymlink = fs5.lstatSync(dest).isSymbolicLink();
+      destIsSymlink = fs6.lstatSync(dest).isSymbolicLink();
     } catch {
       destExists = false;
     }
     if (destExists && !destIsSymlink)
       continue;
     const tmp = `${dest}.massa-ai-switch.${crypto3.randomUUID()}`;
-    fs5.symlinkSync(target, tmp);
-    fs5.renameSync(tmp, dest);
+    fs6.symlinkSync(target, tmp);
+    fs6.renameSync(tmp, dest);
     changed++;
   }
   return changed;
@@ -1871,19 +2306,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((l) => l.layout.route === "skip").map((l) => ({ host: l.host, status: "skipped", reason: l.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((l) => l.layout.route === "skip").map((l) => ({ host: l.host, status: "skipped", reason: l.layout.reason }))
+  ];
   const fileHosts = layouts.filter((l) => l.layout.route === "files");
   if (fileHosts.length === 0) {
     return { profile: opts.profile, dryRun, hosts: orderRows(universe, skipRows), restartRequired: false };
   }
-  const installedFileHosts = fileHosts.filter((h) => fs5.existsSync(h.layout.activeDir));
+  const installedFileHosts = fileHosts.filter((h) => fs6.existsSync(h.layout.activeDir));
   if (installedFileHosts.length === 0)
     throw NoHostsDetectedError();
   const withAvailability = fileHosts.map((h) => {
-    const variantsRootExists = fs5.existsSync(h.layout.variantsRoot);
+    const variantsRootExists = fs6.existsSync(h.layout.variantsRoot);
     const variantDir = h.layout.variantDir(opts.profile);
-    const available = variantsRootExists && fs5.existsSync(variantDir) && fs5.statSync(variantDir).isDirectory();
+    const available = variantsRootExists && fs6.existsSync(variantDir) && fs6.statSync(variantDir).isDirectory();
     return { ...h, variantsRootExists, variantDir, available };
   });
   if (!withAvailability.some((h) => h.available)) {
@@ -1913,7 +2366,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;
@@ -1948,19 +2401,26 @@ function reportSucceeded(report) {
   return report.hosts.every((h) => h.status === "switched" || h.status === "skipped");
 }
 // ../../packages/shared/dist/profile-switch/variant-sync.js
-import fs6 from "fs";
-import path9 from "path";
+import fs7 from "fs";
+import path11 from "path";
+import os7 from "os";
 import crypto4 from "crypto";
+function defaultStatePath2(targetHome) {
+  return path11.join(targetHome, ".config", "massa-ai", "install-state.json");
+}
+function marketplaceRoots2(targetHome, state) {
+  return state.platforms.claude?.installRoute === "marketplace" ? { claude: resolveClaudeMarketplaceRoot({ targetHome }) ?? undefined } : {};
+}
 var tempFileCounter2 = 0;
 function writeFileIntoDirAtomically(destDir, destName, content) {
   const unique = `${process.pid}.${++tempFileCounter2}.${crypto4.randomBytes(6).toString("hex")}`;
-  const tempFile = path9.join(destDir, `.${destName}.${unique}.tmp`);
+  const tempFile = path11.join(destDir, `.${destName}.${unique}.tmp`);
   try {
-    fs6.writeFileSync(tempFile, content);
-    fs6.renameSync(tempFile, path9.join(destDir, destName));
+    fs7.writeFileSync(tempFile, content);
+    fs7.renameSync(tempFile, path11.join(destDir, destName));
   } catch (error) {
     try {
-      fs6.unlinkSync(tempFile);
+      fs7.unlinkSync(tempFile);
     } catch {}
     throw error;
   }
@@ -1968,20 +2428,20 @@ function writeFileIntoDirAtomically(destDir, destName, content) {
 function isSafeDirName(name) {
   if (name === "." || name === "..")
     return false;
-  if (name.includes("/") || name.includes("\\") || name.includes(path9.sep))
+  if (name.includes("/") || name.includes("\\") || name.includes(path11.sep))
     return false;
-  return path9.basename(name) === name;
+  return path11.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 = path9.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
-  if (!fs6.existsSync(srcDir) || !fs6.statSync(srcDir).isDirectory()) {
+  const srcDir = path11.join(sourceRoot, "apps", `${host}-plugin`, "agent-profiles");
+  if (!fs7.existsSync(srcDir) || !fs7.statSync(srcDir).isDirectory()) {
     return { host, status: "skipped", profiles: [], retained: [], files: 0, reason: "no generated variants for this host" };
   }
-  if (!fs6.existsSync(layout.variantsRoot)) {
+  if (!fs7.existsSync(layout.variantsRoot)) {
     return {
       host,
       status: "skipped",
@@ -1993,24 +2453,24 @@ function syncHost(host, sourceRoot, targetHome) {
   }
   const profiles = [];
   let files = 0;
-  for (const entry of fs6.readdirSync(srcDir, { withFileTypes: true })) {
+  for (const entry of fs7.readdirSync(srcDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     if (!isSafeDirName(entry.name))
       continue;
-    const srcProfileDir = path9.join(srcDir, entry.name);
-    const destProfileDir = path9.join(layout.variantsRoot, entry.name);
-    fs6.mkdirSync(destProfileDir, { recursive: true });
-    for (const fileEntry of fs6.readdirSync(srcProfileDir, { withFileTypes: true })) {
+    const srcProfileDir = path11.join(srcDir, entry.name);
+    const destProfileDir = path11.join(layout.variantsRoot, entry.name);
+    fs7.mkdirSync(destProfileDir, { recursive: true });
+    for (const fileEntry of fs7.readdirSync(srcProfileDir, { withFileTypes: true })) {
       if (!fileEntry.isFile())
         continue;
-      const content = fs6.readFileSync(path9.join(srcProfileDir, fileEntry.name));
+      const content = fs7.readFileSync(path11.join(srcProfileDir, fileEntry.name));
       writeFileIntoDirAtomically(destProfileDir, fileEntry.name, content);
       files++;
     }
     profiles.push(entry.name);
   }
-  const retained = fs6.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && !profiles.includes(e.name)).map((e) => e.name).sort();
+  const retained = fs7.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) {
@@ -2026,23 +2486,26 @@ 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 };
     }
   });
 }
 // ../../packages/shared/dist/profile-switch/repo-root.js
-import fs7 from "fs";
-import path10 from "path";
+import fs8 from "fs";
+import path12 from "path";
 function findRepoRootWithMarker(startDir, marker, maxLevels) {
   let dir = startDir;
   for (let i = 0;i <= maxLevels; i++) {
-    if (fs7.existsSync(path10.join(dir, marker)))
+    if (fs8.existsSync(path12.join(dir, marker)))
       return dir;
-    const parent = path10.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -2050,11 +2513,11 @@ function findRepoRootWithMarker(startDir, marker, maxLevels) {
   return null;
 }
 // src/config-cli.ts
-import { promises as fs8 } from "fs";
-import path11 from "path";
-import os6 from "os";
+import { promises as fs9 } from "fs";
+import path13 from "path";
+import os8 from "os";
 import { fileURLToPath } from "url";
-var __dirname2 = path11.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path13.dirname(fileURLToPath(import.meta.url));
 var GENERATOR_MARKER = "scripts/generate-subagent-artifacts.ts";
 var GENERATOR_MARKER_MAX_LEVELS = 6;
 function formatVariantSync(results) {
@@ -2097,7 +2560,7 @@ Commands:
 Examples:
   massa-ai-config init
   massa-ai-config init --mistral your-api-key
-  massa-ai-config use ollama --model nomic-embed-text:latest
+  massa-ai-config use ollama --model qwen3-embedding:4b
   massa-ai-config use mistral --api-key your-key
   massa-ai-config set embedding.dimensions 1024
   massa-ai-config agents install --user
@@ -2226,9 +2689,9 @@ Using defaults:`);
       if (provider === "ollama") {
         config2.embedding = {
           provider: "ollama",
-          model: options.model || "nomic-embed-text:latest",
+          model: options.model || "qwen3-embedding:4b",
           baseURL: options["base-url"] || "http://localhost:11434",
-          dimensions: 768
+          dimensions: 2560
         };
       } else if (provider === "mistral") {
         if (!options["api-key"]) {
@@ -2265,18 +2728,18 @@ Using defaults:`);
         return 1;
       }
       const scope = typeof options.project === "boolean" ? "project" : "user";
-      const agentsDir = scope === "project" ? path11.join(process.cwd(), ".opencode/agents") : path11.join(process.env.XDG_CONFIG_HOME && process.env.XDG_CONFIG_HOME.trim() || path11.join(os6.homedir(), ".config"), "opencode", "agents");
-      const sourceAgentsDir = path11.resolve(__dirname2, "..", "agents");
+      const agentsDir = scope === "project" ? path13.join(process.cwd(), ".opencode/agents") : path13.join(process.env.XDG_CONFIG_HOME && process.env.XDG_CONFIG_HOME.trim() || path13.join(os8.homedir(), ".config"), "opencode", "agents");
+      const sourceAgentsDir = path13.resolve(__dirname2, "..", "agents");
       if (subcommand === "install") {
-        await fs8.mkdir(agentsDir, { recursive: true });
+        await fs9.mkdir(agentsDir, { recursive: true });
         let count = 0;
-        const entries = await fs8.readdir(sourceAgentsDir);
+        const entries = await fs9.readdir(sourceAgentsDir);
         for (const entry of entries) {
           if (!entry.startsWith("massa-ai-") || !entry.endsWith(".md"))
             continue;
-          const src = path11.join(sourceAgentsDir, entry);
-          const dest = path11.join(agentsDir, entry);
-          await fs8.copyFile(src, dest);
+          const src = path13.join(sourceAgentsDir, entry);
+          const dest = path13.join(agentsDir, entry);
+          await fs9.copyFile(src, dest);
           count++;
         }
         console.log(`+ ${count} subagent specialists (generated from skills/agents/*/SKILL.md)`);
@@ -2284,14 +2747,14 @@ Using defaults:`);
       } else {
         let removed = 0;
         try {
-          const entries = await fs8.readdir(agentsDir);
+          const entries = await fs9.readdir(agentsDir);
           for (const entry of entries) {
             if (!entry.startsWith("massa-ai-") || !entry.endsWith(".md"))
               continue;
-            const filePath = path11.join(agentsDir, entry);
-            const content = await fs8.readFile(filePath, "utf8");
+            const filePath = path13.join(agentsDir, entry);
+            const content = await fs9.readFile(filePath, "utf8");
             if (content.includes("massa-ai-owned: true")) {
-              await fs8.unlink(filePath);
+              await fs9.unlink(filePath);
               removed++;
             }
           }