@massa-ai/opencode-plugin 1.2.1

package/dist/config-cli.js

@@ -0,0 +1,1353 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// ../../node_modules/dotenv/lib/main.js
+var require_main = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var path = __require("path");
+  var os = __require("os");
+  var crypto = __require("crypto");
+  var TIPS = [
+    "\u25C8 encrypted .env [www.dotenvx.com]",
+    "\u25C8 secrets for agents [www.dotenvx.com]",
+    "\u2301 auth for agents [www.vestauth.com]",
+    "\u2318 custom filepath { path: '/custom/path/.env' }",
+    "\u2318 enable debugging { debug: true }",
+    "\u2318 override existing { override: true }",
+    "\u2318 suppress logs { quiet: true }",
+    "\u2318 multiple files { path: ['.env.local', '.env'] }"
+  ];
+  function _getRandomTip() {
+    return TIPS[Math.floor(Math.random() * TIPS.length)];
+  }
+  function parseBoolean(value) {
+    if (typeof value === "string") {
+      return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+    }
+    return Boolean(value);
+  }
+  function supportsAnsi() {
+    return process.stdout.isTTY;
+  }
+  function dim(text) {
+    return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+  }
+  var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+  function parse(src) {
+    const obj = {};
+    let lines = src.toString();
+    lines = lines.replace(/\r\n?/mg, `
+`);
+    let match;
+    while ((match = LINE.exec(lines)) != null) {
+      const key = match[1];
+      let value = match[2] || "";
+      value = value.trim();
+      const maybeQuote = value[0];
+      value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+      if (maybeQuote === '"') {
+        value = value.replace(/\\n/g, `
+`);
+        value = value.replace(/\\r/g, "\r");
+      }
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _parseVault(options) {
+    options = options || {};
+    const vaultPath = _vaultPath(options);
+    options.path = vaultPath;
+    const result = DotenvModule.configDotenv(options);
+    if (!result.parsed) {
+      const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+      err.code = "MISSING_DATA";
+      throw err;
+    }
+    const keys = _dotenvKey(options).split(",");
+    const length = keys.length;
+    let decrypted;
+    for (let i = 0;i < length; i++) {
+      try {
+        const key = keys[i].trim();
+        const attrs = _instructions(result, key);
+        decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+        break;
+      } catch (error) {
+        if (i + 1 >= length) {
+          throw error;
+        }
+      }
+    }
+    return DotenvModule.parse(decrypted);
+  }
+  function _warn(message) {
+    console.error(`\u26A0 ${message}`);
+  }
+  function _debug(message) {
+    console.log(`\u2506 ${message}`);
+  }
+  function _log(message) {
+    console.log(`\u25C7 ${message}`);
+  }
+  function _dotenvKey(options) {
+    if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+      return options.DOTENV_KEY;
+    }
+    if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+      return process.env.DOTENV_KEY;
+    }
+    return "";
+  }
+  function _instructions(result, dotenvKey) {
+    let uri;
+    try {
+      uri = new URL(dotenvKey);
+    } catch (error) {
+      if (error.code === "ERR_INVALID_URL") {
+        const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      throw error;
+    }
+    const key = uri.password;
+    if (!key) {
+      const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+      err.code = "INVALID_DOTENV_KEY";
+      throw err;
+    }
+    const environment = uri.searchParams.get("environment");
+    if (!environment) {
+      const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+      err.code = "INVALID_DOTENV_KEY";
+      throw err;
+    }
+    const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+    const ciphertext = result.parsed[environmentKey];
+    if (!ciphertext) {
+      const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+      err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+      throw err;
+    }
+    return { ciphertext, key };
+  }
+  function _vaultPath(options) {
+    let possibleVaultPath = null;
+    if (options && options.path && options.path.length > 0) {
+      if (Array.isArray(options.path)) {
+        for (const filepath of options.path) {
+          if (fs.existsSync(filepath)) {
+            possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+          }
+        }
+      } else {
+        possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+      }
+    } else {
+      possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+    }
+    if (fs.existsSync(possibleVaultPath)) {
+      return possibleVaultPath;
+    }
+    return null;
+  }
+  function _resolveHome(envPath) {
+    return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+  }
+  function _configVault(options) {
+    const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+    const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+    if (debug || !quiet) {
+      _log("loading env from encrypted .env.vault");
+    }
+    const parsed = DotenvModule._parseVault(options);
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    DotenvModule.populate(processEnv, parsed, options);
+    return { parsed };
+  }
+  function configDotenv(options) {
+    const dotenvPath = path.resolve(process.cwd(), ".env");
+    let encoding = "utf8";
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+    let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+    if (options && options.encoding) {
+      encoding = options.encoding;
+    } else {
+      if (debug) {
+        _debug("no encoding is specified (UTF-8 is used by default)");
+      }
+    }
+    let optionPaths = [dotenvPath];
+    if (options && options.path) {
+      if (!Array.isArray(options.path)) {
+        optionPaths = [_resolveHome(options.path)];
+      } else {
+        optionPaths = [];
+        for (const filepath of options.path) {
+          optionPaths.push(_resolveHome(filepath));
+        }
+      }
+    }
+    let lastError;
+    const parsedAll = {};
+    for (const path2 of optionPaths) {
+      try {
+        const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
+        DotenvModule.populate(parsedAll, parsed, options);
+      } catch (e) {
+        if (debug) {
+          _debug(`failed to load ${path2} ${e.message}`);
+        }
+        lastError = e;
+      }
+    }
+    const populated = DotenvModule.populate(processEnv, parsedAll, options);
+    debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+    quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+    if (debug || !quiet) {
+      const keysCount = Object.keys(populated).length;
+      const shortPaths = [];
+      for (const filePath of optionPaths) {
+        try {
+          const relative = path.relative(process.cwd(), filePath);
+          shortPaths.push(relative);
+        } catch (e) {
+          if (debug) {
+            _debug(`failed to load ${filePath} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+    }
+    if (lastError) {
+      return { parsed: parsedAll, error: lastError };
+    } else {
+      return { parsed: parsedAll };
+    }
+  }
+  function config(options) {
+    if (_dotenvKey(options).length === 0) {
+      return DotenvModule.configDotenv(options);
+    }
+    const vaultPath = _vaultPath(options);
+    if (!vaultPath) {
+      _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+      return DotenvModule.configDotenv(options);
+    }
+    return DotenvModule._configVault(options);
+  }
+  function decrypt(encrypted, keyStr) {
+    const key = Buffer.from(keyStr.slice(-64), "hex");
+    let ciphertext = Buffer.from(encrypted, "base64");
+    const nonce = ciphertext.subarray(0, 12);
+    const authTag = ciphertext.subarray(-16);
+    ciphertext = ciphertext.subarray(12, -16);
+    try {
+      const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+      aesgcm.setAuthTag(authTag);
+      return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+    } catch (error) {
+      const isRange = error instanceof RangeError;
+      const invalidKeyLength = error.message === "Invalid key length";
+      const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+      if (isRange || invalidKeyLength) {
+        const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      } else if (decryptionFailed) {
+        const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+        err.code = "DECRYPTION_FAILED";
+        throw err;
+      } else {
+        throw error;
+      }
+    }
+  }
+  function populate(processEnv, parsed, options = {}) {
+    const debug = Boolean(options && options.debug);
+    const override = Boolean(options && options.override);
+    const populated = {};
+    if (typeof parsed !== "object") {
+      const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+      err.code = "OBJECT_REQUIRED";
+      throw err;
+    }
+    for (const key of Object.keys(parsed)) {
+      if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+        if (override === true) {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+        if (debug) {
+          if (override === true) {
+            _debug(`"${key}" is already defined and WAS overwritten`);
+          } else {
+            _debug(`"${key}" is already defined and was NOT overwritten`);
+          }
+        }
+      } else {
+        processEnv[key] = parsed[key];
+        populated[key] = parsed[key];
+      }
+    }
+    return populated;
+  }
+  var DotenvModule = {
+    configDotenv,
+    _configVault,
+    _parseVault,
+    config,
+    decrypt,
+    parse,
+    populate
+  };
+  exports.configDotenv = DotenvModule.configDotenv;
+  exports._configVault = DotenvModule._configVault;
+  exports._parseVault = DotenvModule._parseVault;
+  exports.config = DotenvModule.config;
+  exports.decrypt = DotenvModule.decrypt;
+  exports.parse = DotenvModule.parse;
+  exports.populate = DotenvModule.populate;
+  module.exports = DotenvModule;
+});
+
+// ../../packages/shared/dist/config/xdg.js
+import path from "path";
+import os from "os";
+function xdgEnv(name, fallback) {
+  const v = process.env[name];
+  return v && v.trim() ? v : fallback;
+}
+function xdgConfigHome() {
+  return xdgEnv("XDG_CONFIG_HOME", path.join(os.homedir(), ".config"));
+}
+function configDir(app) {
+  return path.join(xdgConfigHome(), app);
+}
+var init_xdg = () => {};
+
+// ../../packages/shared/dist/config/massa-ai-config.js
+import path2 from "path";
+var defaultMassaAiConfig;
+var init_massa_ai_config = __esm(() => {
+  init_xdg();
+  defaultMassaAiConfig = {
+    database: {
+      url: ""
+    },
+    embedding: {
+      provider: "ollama",
+      model: "nomic-embed-text:latest",
+      baseURL: "http://localhost:11434",
+      dimensions: 768
+    },
+    compression: {
+      defaultStrategy: "code_structure",
+      minTokensForCompression: 100,
+      targetCompressionRatio: 0.7
+    },
+    impact: {
+      bfsCteEnabled: false
+    },
+    capturePolicy: undefined,
+    cache: {
+      enabled: true,
+      l1MaxSizeMB: 100,
+      l2MaxSizeMB: 500,
+      defaultTTLSeconds: 3600
+    },
+    dataDir: path2.join(configDir("massa-ai"), "data"),
+    logging: {
+      level: "info",
+      enableMetrics: false
+    },
+    search: {
+      autoReindexMaxFiles: 200,
+      queryUnderstanding: {
+        enabled: false,
+        hydeEnabled: true,
+        cacheTtlMs: 300000,
+        cacheMaxSize: 256
+      },
+      rerank: {
+        enabled: false,
+        rerankWindow: 50
+      }
+    },
+    llm: {
+      enabled: false,
+      baseUrl: "http://localhost:11434/v1",
+      apiKey: "ollama",
+      model: "qwen2.5:7b-instruct",
+      codeModel: "qwen2.5-coder:7b",
+      temperature: 0.2,
+      maxOutputTokens: 8000,
+      timeoutMs: 90000,
+      disableThink: true
+    },
+    memory: {
+      decay: {
+        lambda: 0.02,
+        sigma: 0.6,
+        mu: 0.04,
+        coldThreshold: 0.2
+      },
+      bootstrap: {
+        enabled: true,
+        maxSeedMemories: 8,
+        centralityLimit: 10,
+        gitLogLimit: 20,
+        refreshEnabled: true
+      },
+      autoImprove: {
+        enabled: true,
+        reviewGate: false,
+        minObservations: 8,
+        minIntervalMs: 300000,
+        maxWindow: 16,
+        minQueryHits: 3,
+        minFileHits: 3,
+        minFixHits: 2
+      },
+      autoImportance: {
+        enabled: false
+      }
+    },
+    hooks: {
+      enabled: true,
+      maxPayloadBytes: 65536,
+      queue: {
+        maxPending: 256
+      },
+      bridge: {
+        enabled: true,
+        minObservations: 8,
+        minIntervalMs: 300000,
+        maxWindow: 8
+      }
+    },
+    synapse: {
+      enabled: true,
+      inhibition: {
+        diversityPenalty: { enabled: true, threshold: 0.85, lambda: 0.4, samePathPenalty: 0.15 },
+        temporalInhibition: { enabled: true, penaltyAgeMs: 3600000, penalty: 0.15 },
+        confidenceGate: {
+          enabled: true,
+          thresholds: { specific: 0.55, focused: 0.4, broad: 0.25 }
+        },
+        chainInhibition: { enabled: true }
+      },
+      scoring: {
+        attention: {
+          enabled: false,
+          rerankWindow: 50,
+          recencyHalfLifeMs: 7 * 24 * 60 * 60 * 1000,
+          semanticScale: 1,
+          weights: {
+            semantic: 0.25,
+            recency: 0.15,
+            accessHeat: 0.15,
+            taskAlign: 0.2,
+            agentAffinity: 0.1,
+            confidence: 0.15
+          }
+        }
+      },
+      metacognition: {
+        enabled: true,
+        lowConfidenceThreshold: 0.15,
+        definitiveTopScore: 0.8,
+        definitiveGap: 0.2
+      },
+      buffer: {
+        enabled: true,
+        maxSize: 20,
+        ttlMs: 900000,
+        hitBoost: 1.3,
+        matchThreshold: 0.4
+      }
+    },
+    handoffs: {
+      enabled: true
+    }
+  };
+});
+
+// ../../packages/shared/dist/config/config-loader.js
+var exports_config_loader = {};
+__export(exports_config_loader, {
+  saveConfig: () => saveConfig,
+  migrateDataDirOnce: () => migrateDataDirOnce,
+  loadConfigSafe: () => loadConfigSafe,
+  loadConfig: () => loadConfig,
+  initConfig: () => initConfig,
+  getConfigPath: () => getConfigPath,
+  getConfigForEnv: () => getConfigForEnv,
+  getConfigDir: () => getConfigDir,
+  configExists: () => configExists
+});
+import fs from "fs";
+import path3 from "path";
+import os2 from "os";
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function configExists() {
+  return fs.existsSync(CONFIG_FILE);
+}
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return defaultMassaAiConfig;
+  }
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+    const userConfig = JSON.parse(content);
+    return {
+      ...defaultMassaAiConfig,
+      ...userConfig,
+      database: { ...defaultMassaAiConfig.database, ...userConfig.database },
+      embedding: { ...defaultMassaAiConfig.embedding, ...userConfig.embedding },
+      compression: { ...defaultMassaAiConfig.compression, ...userConfig.compression },
+      cache: { ...defaultMassaAiConfig.cache, ...userConfig.cache },
+      logging: { ...defaultMassaAiConfig.logging, ...userConfig.logging },
+      search: { ...defaultMassaAiConfig.search, ...userConfig.search },
+      llm: { ...defaultMassaAiConfig.llm, ...userConfig.llm },
+      memory: { ...defaultMassaAiConfig.memory, ...userConfig.memory },
+      hooks: { ...defaultMassaAiConfig.hooks, ...userConfig.hooks },
+      handoffs: { ...defaultMassaAiConfig.handoffs, ...userConfig.handoffs }
+    };
+  } catch (error) {
+    console.error(`Error loading config from ${CONFIG_FILE}:`, error);
+    return defaultMassaAiConfig;
+  }
+}
+function loadConfigSafe() {
+  try {
+    return loadConfig();
+  } catch {
+    return defaultMassaAiConfig;
+  }
+}
+function migrateDataDirOnce() {
+  if (migrationAttempted)
+    return;
+  migrationAttempted = true;
+  try {
+    const oldDir = path3.join(os2.homedir(), ".massa-ai-data");
+    const newDir = path3.join(getConfigDir(), "data");
+    if (fs.existsSync(newDir))
+      return;
+    if (!fs.existsSync(oldDir))
+      return;
+    fs.mkdirSync(path3.dirname(newDir), { recursive: true });
+    try {
+      fs.renameSync(oldDir, newDir);
+      console.warn(`[massa-ai] Migrated data directory: ${oldDir} -> ${newDir}`);
+    } catch (renameErr) {
+      console.error(`[massa-ai] Could not move data directory ${oldDir} -> ${newDir} ` + `(rename failed: ${renameErr?.code || renameErr?.message}). ` + `Move it manually, e.g.:
+` + `  mv "${oldDir}" "${newDir}"`);
+    }
+  } catch (err) {
+    console.error(`[massa-ai] Data directory migration skipped:`, err);
+  }
+}
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function initConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    saveConfig(defaultMassaAiConfig);
+    console.log(`Created default config at ${CONFIG_FILE}`);
+  }
+}
+function getConfigForEnv() {
+  const config = loadConfig();
+  const env = {};
+  if (config.embedding.provider === "ollama") {
+    env.OLLAMA_EMBEDDING_MODEL = config.embedding.model;
+    env.OLLAMA_BASE_URL = config.embedding.baseURL || "http://localhost:11434";
+    if (config.embedding.dimensions) {
+      env.OLLAMA_EMBEDDING_DIMENSIONS = String(config.embedding.dimensions);
+    }
+  } else if (config.embedding.provider === "mistral") {
+    env.MISTRAL_API_KEY = config.embedding.apiKey || "";
+    env.MISTRAL_TEXT_EMBEDDING_MODEL = config.embedding.model;
+  } else if (config.embedding.provider === "openai") {
+    env.OPENAI_API_KEY = config.embedding.apiKey || "";
+    env.OPENAI_EMBEDDING_MODEL = config.embedding.model;
+  }
+  env.LOG_LEVEL = config.logging.level;
+  env.ENABLE_METRICS = String(config.logging.enableMetrics);
+  return env;
+}
+var CONFIG_DIR, CONFIG_FILE, migrationAttempted = false;
+var init_config_loader = __esm(() => {
+  init_massa_ai_config();
+  init_xdg();
+  CONFIG_DIR = configDir("massa-ai");
+  CONFIG_FILE = path3.join(CONFIG_DIR, "config.json");
+});
+
+// ../../packages/shared/dist/env.js
+var import_dotenv = __toESM(require_main(), 1);
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+function findEnvFile() {
+  let dir = process.cwd();
+  while (true) {
+    const envPath = resolve(dir, ".env");
+    if (existsSync(envPath)) {
+      return envPath;
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return;
+}
+var envPath = findEnvFile();
+import_dotenv.config({ path: envPath });
+try {
+  const { loadConfigSafe: loadConfigSafe2, migrateDataDirOnce: migrateDataDirOnce2 } = (init_config_loader(), __toCommonJS(exports_config_loader));
+  migrateDataDirOnce2();
+  const cfg = loadConfigSafe2();
+  if (cfg.database?.url && !process.env.DATABASE_URL) {
+    process.env.DATABASE_URL = cfg.database.url;
+  }
+  if (cfg.llm?.apiKey && !process.env.RLM_LLM_API_KEY) {
+    process.env.RLM_LLM_API_KEY = cfg.llm.apiKey;
+  }
+  if (cfg.embedding?.apiKey && !process.env.OLLAMA_API_KEY) {
+    process.env.OLLAMA_API_KEY = cfg.embedding.apiKey;
+  }
+} catch {}
+
+// ../../packages/shared/dist/config/index.js
+init_config_loader();
+init_massa_ai_config();
+init_config_loader();
+import path4 from "path";
+var DEFAULT_LLM_MODEL = "qwen2.5:7b-instruct";
+var DEFAULT_LLM_CODE_MODEL = "qwen2.5-coder:7b";
+function envNum(key, fallback) {
+  const s = process.env[key];
+  if (s === undefined || s === "")
+    return fallback;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : fallback;
+}
+function envBool(key, fallback) {
+  const s = process.env[key];
+  if (s === undefined || s === "")
+    return fallback;
+  const lower = s.toLowerCase();
+  if (lower === "true" || lower === "1")
+    return true;
+  if (lower === "false" || lower === "0")
+    return false;
+  return fallback;
+}
+function envString(key, fallback) {
+  const s = process.env[key];
+  return s === undefined || s === "" ? fallback : s;
+}
+var MAX_IGNORE_PATTERNS = 1024;
+function validateCapturePolicyConfig(raw) {
+  if (!raw || typeof raw !== "object")
+    throw new TypeError("capturePolicy must be an object");
+  const p = raw;
+  const allowedKeys = new Set(["rules", "maxMatchWork", "maxIgnorePatterns"]);
+  for (const key of Object.keys(p)) {
+    if (!allowedKeys.has(key)) {
+      throw new TypeError(`capturePolicy: unknown field "${key}" (denyUnknownFields=true)`);
+    }
+  }
+  if (!Array.isArray(p.rules))
+    throw new TypeError("capturePolicy.rules must be an array");
+  const validDispositions = new Set(["Keep", "Drop", "MetadataOnly"]);
+  let dropCount = 0;
+  for (const rule of p.rules) {
+    if (!rule || typeof rule !== "object")
+      throw new TypeError("capturePolicy.rules[] must be objects");
+    if (typeof rule.pattern !== "string" || !rule.pattern) {
+      throw new TypeError("capturePolicy.rules[].pattern must be a non-empty string");
+    }
+    if (typeof rule.disposition !== "string" || !validDispositions.has(rule.disposition)) {
+      throw new TypeError(`capturePolicy.rules[].disposition must be Keep|Drop|MetadataOnly (got ${String(rule.disposition)})`);
+    }
+    if (rule.disposition === "Drop")
+      dropCount++;
+  }
+  const maxIgnore = typeof p.maxIgnorePatterns === "number" ? p.maxIgnorePatterns : MAX_IGNORE_PATTERNS;
+  if (dropCount > maxIgnore) {
+    throw new TypeError(`capturePolicy: ${dropCount} Drop rules exceed maxIgnorePatterns=${maxIgnore}`);
+  }
+  if (p.maxMatchWork !== undefined) {
+    if (typeof p.maxMatchWork !== "number" || p.maxMatchWork < 0) {
+      throw new TypeError("capturePolicy.maxMatchWork must be a non-negative number");
+    }
+  }
+  return {
+    rules: p.rules,
+    ...p.maxMatchWork !== undefined && { maxMatchWork: p.maxMatchWork },
+    ...p.maxIgnorePatterns !== undefined && { maxIgnorePatterns: p.maxIgnorePatterns }
+  };
+}
+function getGlobalDataDir() {
+  const envOverride = process.env.MASSA_AI_DATA_DIR;
+  if (envOverride && envOverride.trim())
+    return envOverride;
+  const fileConfig = loadConfigSafe();
+  if (fileConfig.dataDir)
+    return fileConfig.dataDir;
+  return path4.join(getConfigDir(), "data");
+}
+var DEFAULT_ALLOWED_EXTENSIONS = [
+  ".ts",
+  ".js",
+  ".tsx",
+  ".jsx",
+  ".vue",
+  ".dart",
+  ".py",
+  ".php",
+  ".java",
+  ".go",
+  ".rs",
+  ".cpp",
+  ".c",
+  ".h",
+  ".md",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".hpp",
+  ".cs",
+  ".rb",
+  ".swift",
+  ".kt",
+  ".kts",
+  ".scala",
+  ".lua",
+  ".zig",
+  ".ex",
+  ".exs",
+  ".erl",
+  ".clj",
+  ".ml",
+  ".hs"
+];
+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 defaultConfig = {
+  name: "massa-ai-server",
+  version: "1.0.0",
+  dataDir: getGlobalDataDir(),
+  cache: {
+    l1: {
+      maxSize: envNum("L1_CACHE_MAX_SIZE", fileCacheL1Bytes ?? 100 * 1024 * 1024),
+      defaultTTL: envNum("L1_CACHE_TTL", fileConfig.cache?.defaultTTLSeconds ?? 300)
+    },
+    l2: {
+      maxSize: envNum("L2_CACHE_MAX_SIZE", fileCacheL2Bytes ?? 500 * 1024 * 1024),
+      defaultTTL: envNum("L2_CACHE_TTL", fileConfig.cache?.defaultTTLSeconds ?? 3600)
+    },
+    embedding: {
+      maxAgeHours: 168
+    }
+  },
+  search: {
+    autoReindexMaxFiles: envNum("AUTOREINDEX_MAX_FILES", fileConfig.search?.autoReindexMaxFiles ?? 200),
+    queryUnderstanding: {
+      enabled: envBool("SEARCH_QUERY_UNDERSTANDING_ENABLED", fileConfig.search?.queryUnderstanding?.enabled ?? false),
+      hydeEnabled: envBool("SEARCH_QUERY_UNDERSTANDING_HYDE_ENABLED", fileConfig.search?.queryUnderstanding?.hydeEnabled ?? true),
+      cacheTtlMs: envNum("SEARCH_QUERY_UNDERSTANDING_CACHE_TTL_MS", fileConfig.search?.queryUnderstanding?.cacheTtlMs ?? 300000),
+      cacheMaxSize: envNum("SEARCH_QUERY_UNDERSTANDING_CACHE_MAX_SIZE", fileConfig.search?.queryUnderstanding?.cacheMaxSize ?? 256)
+    },
+    rerank: {
+      enabled: envBool("SEARCH_RERANK_ENABLED", fileConfig.search?.rerank?.enabled ?? false),
+      rerankWindow: envNum("SEARCH_RERANK_WINDOW", fileConfig.search?.rerank?.rerankWindow ?? 50)
+    }
+  },
+  llm: {
+    enabled: envBool("RLM_LLM_ENABLED", fileConfig.llm?.enabled ?? false),
+    baseUrl: envString("RLM_LLM_BASE_URL", fileConfig.llm?.baseUrl ?? "http://localhost:11434/v1"),
+    apiKey: envString("RLM_LLM_API_KEY", fileConfig.llm?.apiKey ?? "ollama"),
+    model: envString("RLM_LLM_MODEL", fileConfig.llm?.model ?? DEFAULT_LLM_MODEL),
+    codeModel: envString("RLM_LLM_CODE_MODEL", fileConfig.llm?.codeModel ?? DEFAULT_LLM_CODE_MODEL),
+    temperature: envNum("RLM_LLM_TEMPERATURE", fileConfig.llm?.temperature ?? 0.2),
+    maxOutputTokens: envNum("RLM_LLM_MAX_OUTPUT_TOKENS", fileConfig.llm?.maxOutputTokens ?? 8000),
+    timeoutMs: envNum("RLM_LLM_TIMEOUT_MS", fileConfig.llm?.timeoutMs ?? 90000),
+    disableThink: envBool("RLM_LLM_DISABLE_THINK", fileConfig.llm?.disableThink ?? true)
+  },
+  memory: {
+    decay: {
+      lambda: fileConfig.memory?.decay?.lambda ?? 0.02,
+      sigma: fileConfig.memory?.decay?.sigma ?? 0.6,
+      mu: fileConfig.memory?.decay?.mu ?? 0.04,
+      coldThreshold: fileConfig.memory?.decay?.coldThreshold ?? 0.2
+    },
+    bootstrap: {
+      enabled: envBool("BOOTSTRAP_ENABLED", fileConfig.memory?.bootstrap?.enabled ?? true),
+      maxSeedMemories: envNum("BOOTSTRAP_MAX_SEED_MEMORIES", fileConfig.memory?.bootstrap?.maxSeedMemories ?? 8),
+      centralityLimit: envNum("BOOTSTRAP_CENTRALITY_LIMIT", fileConfig.memory?.bootstrap?.centralityLimit ?? 10),
+      gitLogLimit: envNum("BOOTSTRAP_GIT_LOG_LIMIT", fileConfig.memory?.bootstrap?.gitLogLimit ?? 20),
+      refreshEnabled: envBool("BOOTSTRAP_REFRESH_ENABLED", fileConfig.memory?.bootstrap?.refreshEnabled ?? true)
+    },
+    autoImprove: {
+      enabled: envBool("AUTO_IMPROVE_ENABLED", fileConfig.memory?.autoImprove?.enabled ?? true),
+      reviewGate: envBool("AUTO_IMPROVE_REVIEW_GATE", fileConfig.memory?.autoImprove?.reviewGate ?? false),
+      minObservations: envNum("AUTO_IMPROVE_MIN_OBS", fileConfig.memory?.autoImprove?.minObservations ?? 8),
+      minIntervalMs: envNum("AUTO_IMPROVE_MIN_INTERVAL_MS", fileConfig.memory?.autoImprove?.minIntervalMs ?? 5 * 60 * 1000),
+      maxWindow: envNum("AUTO_IMPROVE_MAX_WINDOW", fileConfig.memory?.autoImprove?.maxWindow ?? 16),
+      minQueryHits: envNum("AUTO_IMPROVE_MIN_QUERY_HITS", fileConfig.memory?.autoImprove?.minQueryHits ?? 3),
+      minFileHits: envNum("AUTO_IMPROVE_MIN_FILE_HITS", fileConfig.memory?.autoImprove?.minFileHits ?? 3),
+      minFixHits: envNum("AUTO_IMPROVE_MIN_FIX_HITS", fileConfig.memory?.autoImprove?.minFixHits ?? 2)
+    },
+    autoImportance: {
+      enabled: envBool("AUTO_IMPORTANCE_ENABLED", fileConfig.memory?.autoImportance?.enabled ?? false)
+    }
+  },
+  hooks: {
+    enabled: envBool("HOOKS_ENABLED", fileConfig.hooks?.enabled ?? true),
+    maxPayloadBytes: envNum("HOOKS_MAX_PAYLOAD_BYTES", fileConfig.hooks?.maxPayloadBytes ?? 65536),
+    queue: {
+      maxPending: envNum("HOOKS_QUEUE_MAX_PENDING", fileConfig.hooks?.queue?.maxPending ?? 256)
+    },
+    bridge: {
+      enabled: envBool("HOOKS_BRIDGE_ENABLED", fileConfig.hooks?.bridge?.enabled ?? true),
+      minObservations: envNum("HOOKS_BRIDGE_MIN_OBS", fileConfig.hooks?.bridge?.minObservations ?? 8),
+      minIntervalMs: envNum("HOOKS_BRIDGE_MIN_INTERVAL_MS", fileConfig.hooks?.bridge?.minIntervalMs ?? 5 * 60 * 1000),
+      maxWindow: envNum("HOOKS_BRIDGE_MAX_WINDOW", fileConfig.hooks?.bridge?.maxWindow ?? 8)
+    }
+  },
+  handoffs: {
+    enabled: envBool("HANDOFFS_ENABLED", true)
+  },
+  compression: {
+    defaultStrategy: fileConfig.compression?.defaultStrategy ?? "code_structure",
+    minTokensForCompression: envNum("MIN_TOKENS_FOR_COMPRESSION", fileConfig.compression?.minTokensForCompression ?? 100),
+    targetCompressionRatio: envNum("TARGET_COMPRESSION_RATIO", fileConfig.compression?.targetCompressionRatio ?? 0.7),
+    prompt: process.env.RLM_LLM_PROMPT || fileConfig.compression?.prompt || undefined
+  },
+  impact: {
+    bfsCteEnabled: envBool("MASSA_AI_IMPACT_BFS_CTE", fileConfig.impact?.bfsCteEnabled ?? false)
+  },
+  capturePolicy: fileConfig.capturePolicy ? validateCapturePolicyConfig(fileConfig.capturePolicy) : undefined,
+  readFile: {
+    extraRoots: envString("MASSA_AI_READ_FILE_ROOTS", "").split(":").map((s) => s.trim()).filter((s) => s.length > 0)
+  },
+  filterValidation: {
+    maxFilterPatterns: envNum("MAX_FILTER_PATTERNS", 32)
+  },
+  rateLimit: {
+    requestsPerMinute: envNum("REQUESTS_PER_MINUTE", 60),
+    tokensPerMinute: envNum("TOKENS_PER_MINUTE", 1e5)
+  },
+  security: {
+    maxInputLength: envNum("MAX_INPUT_LENGTH", 1e5),
+    sanitizeInputs: process.env.SANITIZE_INPUTS !== "false",
+    maxIndexSize: 1e5,
+    maxFileSize: 1024 * 1024,
+    allowedExtensions: [...DEFAULT_ALLOWED_EXTENSIONS],
+    excludePatterns: [
+      "node_modules/**",
+      ".git/**",
+      "dist/**",
+      "build/**",
+      ".next/**",
+      "coverage/**",
+      "**/generated/**",
+      "*.min.js",
+      "*.min.css"
+    ]
+  },
+  logging: {
+    level: process.env.LOG_LEVEL || fileConfig.logging?.level || "info",
+    enableMetrics: process.env.ENABLE_METRICS === "true" || process.env.ENABLE_METRICS === undefined && !!fileConfig.logging?.enableMetrics
+  },
+  synapse: {
+    enabled: process.env.SYNAPSE_ENABLED !== "false",
+    inhibition: {
+      diversityPenalty: {
+        enabled: true,
+        threshold: 0.85,
+        lambda: 0.4,
+        samePathPenalty: 0.15
+      },
+      temporalInhibition: {
+        enabled: true,
+        penaltyAgeMs: 3600000,
+        penalty: 0.15
+      },
+      confidenceGate: {
+        enabled: true,
+        thresholds: { specific: 0.55, focused: 0.4, broad: 0.25 }
+      },
+      chainInhibition: { enabled: true }
+    },
+    scoring: {
+      attention: {
+        enabled: process.env.SYNAPSE_ATTENTION_ENABLED === "true",
+        rerankWindow: 50,
+        recencyHalfLifeMs: 7 * 24 * 60 * 60 * 1000,
+        semanticScale: 1,
+        weights: {
+          semantic: 0.25,
+          recency: 0.15,
+          accessHeat: 0.15,
+          taskAlign: 0.2,
+          agentAffinity: 0.1,
+          confidence: 0.15
+        }
+      }
+    },
+    metacognition: {
+      enabled: true,
+      lowConfidenceThreshold: 0.15,
+      definitiveTopScore: 0.8,
+      definitiveGap: 0.2
+    },
+    buffer: {
+      enabled: true,
+      maxSize: 20,
+      ttlMs: 900000,
+      hitBoost: 1.3,
+      matchThreshold: 0.4
+    }
+  }
+};
+
+class Config {
+  config;
+  constructor(overrides) {
+    this.config = this.mergeConfig(defaultConfig, overrides);
+    this.validate();
+  }
+  mergeConfig(defaults, overrides) {
+    if (!overrides)
+      return defaults;
+    return {
+      ...defaults,
+      ...overrides,
+      cache: {
+        l1: { ...defaults.cache.l1, ...overrides.cache?.l1 },
+        l2: { ...defaults.cache.l2, ...overrides.cache?.l2 },
+        embedding: {
+          ...defaults.cache.embedding,
+          ...overrides.cache?.embedding
+        }
+      },
+      search: {
+        ...defaults.search,
+        ...overrides.search,
+        queryUnderstanding: {
+          ...defaults.search.queryUnderstanding,
+          ...overrides.search?.queryUnderstanding
+        },
+        rerank: {
+          ...defaults.search.rerank,
+          ...overrides.search?.rerank
+        }
+      },
+      llm: { ...defaults.llm, ...overrides.llm },
+      memory: {
+        ...defaults.memory,
+        ...overrides.memory,
+        decay: { ...defaults.memory.decay, ...overrides.memory?.decay },
+        bootstrap: { ...defaults.memory.bootstrap, ...overrides.memory?.bootstrap },
+        autoImprove: { ...defaults.memory.autoImprove, ...overrides.memory?.autoImprove },
+        autoImportance: { ...defaults.memory.autoImportance, ...overrides.memory?.autoImportance }
+      },
+      hooks: {
+        ...defaults.hooks,
+        ...overrides.hooks,
+        queue: { ...defaults.hooks.queue, ...overrides.hooks?.queue },
+        bridge: { ...defaults.hooks.bridge, ...overrides.hooks?.bridge }
+      },
+      handoffs: {
+        ...defaults.handoffs,
+        ...overrides.handoffs
+      },
+      compression: {
+        ...defaults.compression,
+        ...overrides.compression
+      },
+      impact: {
+        ...defaults.impact,
+        ...overrides.impact
+      },
+      rateLimit: { ...defaults.rateLimit, ...overrides.rateLimit },
+      security: { ...defaults.security, ...overrides.security },
+      logging: { ...defaults.logging, ...overrides.logging },
+      synapse: {
+        ...defaults.synapse,
+        ...overrides.synapse,
+        inhibition: {
+          ...defaults.synapse.inhibition,
+          ...overrides.synapse?.inhibition,
+          diversityPenalty: {
+            ...defaults.synapse.inhibition.diversityPenalty,
+            ...overrides.synapse?.inhibition?.diversityPenalty
+          },
+          temporalInhibition: {
+            ...defaults.synapse.inhibition.temporalInhibition,
+            ...overrides.synapse?.inhibition?.temporalInhibition
+          },
+          confidenceGate: {
+            ...defaults.synapse.inhibition.confidenceGate,
+            ...overrides.synapse?.inhibition?.confidenceGate,
+            thresholds: {
+              ...defaults.synapse.inhibition.confidenceGate.thresholds,
+              ...overrides.synapse?.inhibition?.confidenceGate?.thresholds
+            }
+          },
+          chainInhibition: {
+            ...defaults.synapse.inhibition.chainInhibition,
+            ...overrides.synapse?.inhibition?.chainInhibition
+          }
+        },
+        scoring: {
+          ...defaults.synapse.scoring,
+          ...overrides.synapse?.scoring,
+          attention: {
+            ...defaults.synapse.scoring.attention,
+            ...overrides.synapse?.scoring?.attention,
+            weights: {
+              ...defaults.synapse.scoring.attention.weights,
+              ...overrides.synapse?.scoring?.attention?.weights
+            }
+          }
+        },
+        metacognition: {
+          ...defaults.synapse.metacognition,
+          ...overrides.synapse?.metacognition
+        },
+        buffer: {
+          ...defaults.synapse.buffer,
+          ...overrides.synapse?.buffer
+        }
+      }
+    };
+  }
+  validate() {
+    if (this.config.compression.targetCompressionRatio < 0 || this.config.compression.targetCompressionRatio > 1) {
+      throw new Error("targetCompressionRatio must be between 0 and 1");
+    }
+  }
+  get(key) {
+    return this.config[key];
+  }
+  getNested(path5) {
+    return path5.split(".").reduce((obj, key) => obj?.[key], this.config);
+  }
+  getAll() {
+    return { ...this.config };
+  }
+  set(key, value) {
+    this.config[key] = value;
+  }
+}
+var config = new Config;
+
+// src/config-cli.ts
+import { promises as fs2 } from "fs";
+import path5 from "path";
+import os3 from "os";
+import { fileURLToPath } from "url";
+var args = process.argv.slice(2);
+var command = args[0];
+var __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
+function help() {
+  console.log(`
+massa-ai-config - Configuration manager for massa-ai
+
+Usage:
+  massa-ai-config <command> [options]
+
+Commands:
+  init              Initialize massa-ai configuration
+    --ollama          Use Ollama (local, default)
+    --mistral <key>   Use Mistral with API key
+    --openai <key>    Use OpenAI with API key
+
+  path              Show config file path
+  show              Show current configuration
+  set <key> <val>   Set a configuration value
+  use <provider>    Switch embedding provider
+    --api-key <key>   API key (required for mistral/openai)
+    --model <name>    Model name
+    --base-url <url>  Base URL (for ollama)
+
+  agents            Manage the 12 subagent specialist definitions
+    agents install [--user|--project]   Write 12 agent .md files
+    agents uninstall [--user|--project] Remove only massa-ai-owned agents
+
+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 mistral --api-key your-key
+  massa-ai-config set embedding.dimensions 1024
+  massa-ai-config agents install --user
+`);
+}
+function parseOptions(args2) {
+  const options = {};
+  for (let i = 0;i < args2.length; i++) {
+    if (args2[i].startsWith("--")) {
+      const key = args2[i].slice(2);
+      if (i + 1 < args2.length && !args2[i + 1].startsWith("--")) {
+        options[key] = args2[i + 1];
+        i++;
+      } else {
+        options[key] = true;
+      }
+    }
+  }
+  return options;
+}
+if (!command || command === "--help" || command === "-h") {
+  help();
+  process.exit(0);
+}
+var options = parseOptions(args.slice(1));
+switch (command) {
+  case "init": {
+    initConfig();
+    if (options.mistral && typeof options.mistral === "string") {
+      const config2 = loadConfig();
+      config2.embedding = {
+        provider: "mistral",
+        model: "mistral-embed",
+        apiKey: options.mistral,
+        dimensions: 1024
+      };
+      saveConfig(config2);
+      console.log("\u2713 Configured for Mistral embeddings");
+    } else if (options.openai && typeof options.openai === "string") {
+      const config2 = loadConfig();
+      config2.embedding = {
+        provider: "openai",
+        model: "text-embedding-3-small",
+        apiKey: options.openai,
+        dimensions: 1536
+      };
+      saveConfig(config2);
+      console.log("\u2713 Configured for OpenAI embeddings");
+    } else {
+      console.log("\u2713 Configured for Ollama (local) embeddings");
+    }
+    console.log(`
+Config file: ${getConfigPath()}`);
+    break;
+  }
+  case "path": {
+    console.log(getConfigPath());
+    break;
+  }
+  case "show": {
+    if (!configExists()) {
+      console.log("No config file found. Run `massa-ai-config init` to create one.");
+      console.log(`
+Using defaults:`);
+      console.log(JSON.stringify(defaultMassaAiConfig, null, 2));
+      process.exit(0);
+    }
+    const config2 = loadConfig();
+    console.log(JSON.stringify(config2, null, 2));
+    break;
+  }
+  case "set": {
+    const key = args[1];
+    const value = args[2];
+    if (!key || !value) {
+      console.error("Usage: massa-ai-config set <key> <value>");
+      process.exit(1);
+    }
+    const config2 = loadConfig();
+    const keys = key.split(".");
+    let obj = config2;
+    for (let i = 0;i < keys.length - 1; i++) {
+      obj = obj[keys[i]];
+    }
+    const parsedValue = isNaN(Number(value)) ? value : Number(value);
+    obj[keys[keys.length - 1]] = parsedValue;
+    saveConfig(config2);
+    console.log(`\u2713 Set ${key} = ${value}`);
+    break;
+  }
+  case "use": {
+    const provider = args[1];
+    if (!provider || !["ollama", "mistral", "openai"].includes(provider)) {
+      console.error("Provider must be: ollama, mistral, or openai");
+      process.exit(1);
+    }
+    const config2 = loadConfig();
+    if (provider === "ollama") {
+      config2.embedding = {
+        provider: "ollama",
+        model: options.model || "nomic-embed-text:latest",
+        baseURL: options["base-url"] || "http://localhost:11434",
+        dimensions: 768
+      };
+    } else if (provider === "mistral") {
+      if (!options["api-key"]) {
+        console.error("Error: --api-key required for Mistral");
+        process.exit(1);
+      }
+      config2.embedding = {
+        provider: "mistral",
+        model: options.model || "mistral-embed",
+        apiKey: options["api-key"],
+        dimensions: 1024
+      };
+    } else if (provider === "openai") {
+      if (!options["api-key"]) {
+        console.error("Error: --api-key required for OpenAI");
+        process.exit(1);
+      }
+      config2.embedding = {
+        provider: "openai",
+        model: options.model || "text-embedding-3-small",
+        apiKey: options["api-key"],
+        dimensions: 1536
+      };
+    }
+    saveConfig(config2);
+    console.log(`\u2713 Switched to ${provider} embeddings`);
+    console.log(`  Model: ${config2.embedding.model}`);
+    break;
+  }
+  case "agents": {
+    const subcommand = args[1];
+    if (subcommand !== "install" && subcommand !== "uninstall") {
+      console.error("Usage: massa-ai-config agents <install|uninstall> [--user|--project]");
+      process.exit(1);
+    }
+    const scope = typeof options.project === "boolean" ? "project" : "user";
+    const agentsDir = scope === "project" ? path5.join(process.cwd(), ".opencode/agents") : path5.join(process.env.XDG_CONFIG_HOME && process.env.XDG_CONFIG_HOME.trim() || path5.join(os3.homedir(), ".config"), "opencode", "agents");
+    const sourceAgentsDir = path5.resolve(__dirname2, "..", "agents");
+    if (subcommand === "install") {
+      await fs2.mkdir(agentsDir, { recursive: true });
+      let count = 0;
+      const entries = await fs2.readdir(sourceAgentsDir);
+      for (const entry of entries) {
+        if (!entry.startsWith("massa-ai-") || !entry.endsWith(".md"))
+          continue;
+        const src = path5.join(sourceAgentsDir, entry);
+        const dest = path5.join(agentsDir, entry);
+        await fs2.copyFile(src, dest);
+        count++;
+      }
+      console.log(`+ ${count} subagent specialists: investigator, planner, builder, reviewer, context-curator, verification-agent, requirements-analyst, architecture-specialist, test-engineer, documentation-agent, audit-specialist, mobile-specialist`);
+      console.log(`  written to: ${agentsDir}`);
+    } else {
+      let removed = 0;
+      try {
+        const entries = await fs2.readdir(agentsDir);
+        for (const entry of entries) {
+          if (!entry.startsWith("massa-ai-") || !entry.endsWith(".md"))
+            continue;
+          const filePath = path5.join(agentsDir, entry);
+          const content = await fs2.readFile(filePath, "utf8");
+          if (content.includes("massa-ai-owned: true")) {
+            await fs2.unlink(filePath);
+            removed++;
+          }
+        }
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
+      }
+      console.log(`- removed ${removed} massa-ai-owned agent files from ${agentsDir}`);
+      console.log("  User agents preserved.");
+    }
+    break;
+  }
+  default:
+    console.error(`Unknown command: ${command}`);
+    help();
+    process.exit(1);
+}