@massa-ai/opencode-plugin 1.25.0 → 1.26.0

package/dist/config-cli.js

@@ -1180,13 +1180,751 @@ class Config {
   }
 }
 var config = new Config;
+// ../../packages/shared/dist/types/structural-transport.js
+var STRUCTURAL_SYMBOL_KINDS = [
+  "module",
+  "namespace",
+  "class",
+  "interface",
+  "trait",
+  "enum",
+  "function",
+  "method",
+  "constructor",
+  "property",
+  "field",
+  "variable",
+  "constant",
+  "type",
+  "type_parameter",
+  "export",
+  "heading",
+  "key"
+];
+var STRUCTURAL_SYMBOL_KINDS_DESCRIPTION = `Canonical graph schema v2 symbol kind. One of: ${STRUCTURAL_SYMBOL_KINDS.join(", ")}.`;
+var STRUCTURAL_SYMBOL_KIND_SCHEMA = Object.freeze({
+  type: "string",
+  enum: STRUCTURAL_SYMBOL_KINDS,
+  description: STRUCTURAL_SYMBOL_KINDS_DESCRIPTION
+});
 
-// src/config-cli.ts
-import { promises as fs2 } from "fs";
-import path5 from "path";
+// ../../packages/shared/dist/types/index.js
+var MemoryLevel;
+(function(MemoryLevel2) {
+  MemoryLevel2[MemoryLevel2["PERSISTENT"] = 0] = "PERSISTENT";
+  MemoryLevel2[MemoryLevel2["PROJECT"] = 1] = "PROJECT";
+  MemoryLevel2[MemoryLevel2["USER"] = 2] = "USER";
+  MemoryLevel2[MemoryLevel2["SESSION"] = 3] = "SESSION";
+  MemoryLevel2[MemoryLevel2["WORKING"] = 4] = "WORKING";
+})(MemoryLevel || (MemoryLevel = {}));
+var MemoryType;
+(function(MemoryType2) {
+  MemoryType2["CRITICAL"] = "critical";
+  MemoryType2["CONVERSATION"] = "conversation";
+  MemoryType2["CODE"] = "code";
+  MemoryType2["DECISION"] = "decision";
+  MemoryType2["PATTERN"] = "pattern";
+})(MemoryType || (MemoryType = {}));
+var CacheLevel;
+(function(CacheLevel2) {
+  CacheLevel2[CacheLevel2["L1"] = 1] = "L1";
+  CacheLevel2[CacheLevel2["L2"] = 2] = "L2";
+})(CacheLevel || (CacheLevel = {}));
+var CompressionStrategy;
+(function(CompressionStrategy2) {
+  CompressionStrategy2["CODE_STRUCTURE"] = "code_structure";
+  CompressionStrategy2["CONVERSATION_SUMMARY"] = "conversation_summary";
+  CompressionStrategy2["SEMANTIC_DEDUP"] = "semantic_dedup";
+  CompressionStrategy2["HIERARCHICAL"] = "hierarchical";
+})(CompressionStrategy || (CompressionStrategy = {}));
+var SearchSource;
+(function(SearchSource2) {
+  SearchSource2["VECTOR"] = "vector";
+  SearchSource2["KEYWORD"] = "keyword";
+  SearchSource2["HYBRID"] = "hybrid";
+  SearchSource2["CACHE"] = "cache";
+})(SearchSource || (SearchSource = {}));
+var Permission;
+(function(Permission2) {
+  Permission2["READ"] = "read";
+  Permission2["WRITE"] = "write";
+  Permission2["DELETE"] = "delete";
+  Permission2["ADMIN"] = "admin";
+})(Permission || (Permission = {}));
+var MemoryRelationType;
+(function(MemoryRelationType2) {
+  MemoryRelationType2["DERIVED_FROM"] = "DERIVED_FROM";
+  MemoryRelationType2["CONTRADICTS"] = "CONTRADICTS";
+  MemoryRelationType2["SUPPORTS"] = "SUPPORTS";
+  MemoryRelationType2["RELATES_TO"] = "RELATES_TO";
+  MemoryRelationType2["SUPERSEDES"] = "SUPERSEDES";
+  MemoryRelationType2["CAUSES"] = "CAUSES";
+  MemoryRelationType2["RESOLVES"] = "RESOLVES";
+})(MemoryRelationType || (MemoryRelationType = {}));
+var CheckpointType;
+(function(CheckpointType2) {
+  CheckpointType2["AUTO"] = "auto";
+  CheckpointType2["MANUAL"] = "manual";
+  CheckpointType2["MILESTONE"] = "milestone";
+})(CheckpointType || (CheckpointType = {}));
+var TaskStatus;
+(function(TaskStatus2) {
+  TaskStatus2["PENDING"] = "pending";
+  TaskStatus2["IN_PROGRESS"] = "in_progress";
+  TaskStatus2["COMPLETED"] = "completed";
+  TaskStatus2["FAILED"] = "failed";
+  TaskStatus2["PAUSED"] = "paused";
+})(TaskStatus || (TaskStatus = {}));
+// ../../packages/shared/dist/utils/logger.js
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+
+class Logger {
+  _level;
+  _enableMetrics;
+  _initialized = false;
+  constructor() {}
+  ensureInitialized() {
+    if (!this._initialized) {
+      try {
+        const configLevel = config.get("logging").level;
+        this._level = this.parseLogLevel(configLevel);
+        this._enableMetrics = config.get("logging").enableMetrics;
+      } catch {
+        this._level = LogLevel.INFO;
+        this._enableMetrics = false;
+      }
+      this._initialized = true;
+    }
+  }
+  get level() {
+    this.ensureInitialized();
+    return this._level;
+  }
+  get enableMetrics() {
+    this.ensureInitialized();
+    return this._enableMetrics;
+  }
+  parseLogLevel(level) {
+    const levels = {
+      debug: LogLevel.DEBUG,
+      info: LogLevel.INFO,
+      warn: LogLevel.WARN,
+      error: LogLevel.ERROR
+    };
+    return levels[level.toLowerCase()] ?? LogLevel.INFO;
+  }
+  shouldLog(level) {
+    return level >= this.level;
+  }
+  formatMessage(level, message, meta) {
+    const timestamp = new Date().toISOString();
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    return `[${timestamp}] [${level}] ${message}${metaStr}`;
+  }
+  write(message, _level) {
+    console.error(message);
+  }
+  debug(message, meta) {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      this.write(this.formatMessage("DEBUG", message, meta), LogLevel.DEBUG);
+    }
+  }
+  info(message, meta) {
+    if (this.shouldLog(LogLevel.INFO)) {
+      this.write(this.formatMessage("INFO", message, meta), LogLevel.INFO);
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog(LogLevel.WARN)) {
+      this.write(this.formatMessage("WARN", message, meta), LogLevel.WARN);
+    }
+  }
+  error(message, error, meta) {
+    if (this.shouldLog(LogLevel.ERROR)) {
+      const errorMeta = error ? {
+        ...meta,
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      } : meta;
+      this.write(this.formatMessage("ERROR", message, errorMeta), LogLevel.ERROR);
+    }
+  }
+  metric(name, value, unit) {
+    if (this.enableMetrics) {
+      this.info(`METRIC: ${name}`, { value, unit });
+    }
+  }
+  child(context) {
+    const childLogger = new Logger;
+    const originalDebug = childLogger.debug.bind(childLogger);
+    const originalInfo = childLogger.info.bind(childLogger);
+    const originalWarn = childLogger.warn.bind(childLogger);
+    const originalError = childLogger.error.bind(childLogger);
+    childLogger.debug = (msg, meta) => {
+      originalDebug(msg, { ...context, ...meta });
+    };
+    childLogger.info = (msg, meta) => {
+      originalInfo(msg, { ...context, ...meta });
+    };
+    childLogger.warn = (msg, meta) => {
+      originalWarn(msg, { ...context, ...meta });
+    };
+    childLogger.error = (msg, err, meta) => {
+      originalError(msg, err, { ...context, ...meta });
+    };
+    return childLogger;
+  }
+}
+var logger = new Logger;
+// ../../packages/shared/dist/utils/rate-limiter.js
+class RateLimiter {
+  tokens;
+  lastRefill;
+  maxTokens;
+  refillRate;
+  constructor(maxTokens, refillRate) {
+    this.maxTokens = maxTokens;
+    this.refillRate = refillRate;
+    this.tokens = maxTokens;
+    this.lastRefill = Date.now();
+  }
+  refill() {
+    const now = Date.now();
+    const timePassed = (now - this.lastRefill) / 1000;
+    const tokensToAdd = timePassed * this.refillRate;
+    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+    this.lastRefill = now;
+  }
+  tryConsume(tokens = 1) {
+    this.refill();
+    if (this.tokens >= tokens) {
+      this.tokens -= tokens;
+      return true;
+    }
+    return false;
+  }
+  async consume(tokens = 1) {
+    while (!this.tryConsume(tokens)) {
+      const waitTime = (tokens - this.tokens) / this.refillRate * 1000;
+      await this.sleep(Math.max(100, waitTime));
+    }
+  }
+  getAvailableTokens() {
+    this.refill();
+    return this.tokens;
+  }
+  reset() {
+    this.tokens = this.maxTokens;
+    this.lastRefill = Date.now();
+  }
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+}
+
+class SmartRateLimiter {
+  requestLimiter;
+  tokenLimiter;
+  constructor() {
+    const limits = config.get("rateLimit");
+    this.requestLimiter = new RateLimiter(limits.requestsPerMinute, limits.requestsPerMinute / 60);
+    this.tokenLimiter = new RateLimiter(limits.tokensPerMinute, limits.tokensPerMinute / 60);
+    logger.info("Smart Rate Limiter initialized", {
+      requestsPerMinute: limits.requestsPerMinute,
+      tokensPerMinute: limits.tokensPerMinute
+    });
+  }
+  async checkRequest(estimatedTokens = 1000) {
+    const hasRequestCapacity = this.requestLimiter.tryConsume(1);
+    const hasTokenCapacity = this.tokenLimiter.tryConsume(estimatedTokens);
+    if (!hasRequestCapacity) {
+      logger.warn("Request rate limit exceeded");
+      return false;
+    }
+    if (!hasTokenCapacity) {
+      logger.warn("Token rate limit exceeded", { estimatedTokens });
+      return false;
+    }
+    return true;
+  }
+  async waitForCapacity(estimatedTokens = 1000) {
+    await Promise.all([
+      this.requestLimiter.consume(1),
+      this.tokenLimiter.consume(estimatedTokens)
+    ]);
+  }
+  getStatus() {
+    return {
+      requestsAvailable: Math.floor(this.requestLimiter.getAvailableTokens()),
+      tokensAvailable: Math.floor(this.tokenLimiter.getAvailableTokens()),
+      requestsMax: config.get("rateLimit").requestsPerMinute,
+      tokensMax: config.get("rateLimit").tokensPerMinute
+    };
+  }
+  reset() {
+    this.requestLimiter.reset();
+    this.tokenLimiter.reset();
+    logger.info("Rate limiters reset");
+  }
+}
+var rateLimiter = new SmartRateLimiter;
+// ../../packages/shared/dist/profile-switch/hosts.js
 import os3 from "os";
+import path5 from "path";
+var HOSTS = ["claude", "codex", "cursor", "opencode"];
+function isHost(v) {
+  return typeof v === "string" && HOSTS.includes(v);
+}
+var CURSOR_SKIP_REASON = "all tiers inherit \u2014 Cursor publishes no resolvable model IDs";
+function fileLayout(host, activeDir, activeGlob, variantsRoot) {
+  return {
+    host,
+    route: "files",
+    activeDir,
+    activeGlob,
+    variantsRoot,
+    variantDir: (profile) => path5.join(variantsRoot, profile)
+  };
+}
+function resolveHostLayout(host, opts = {}) {
+  const targetHome = opts.targetHome ?? os3.homedir();
+  const override = opts.projectRoot?.[host];
+  switch (host) {
+    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"));
+    }
+    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"));
+    }
+    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"));
+    }
+  }
+}
+function detectRoute(platform) {
+  const route = platform?.installRoute;
+  if (route === "file")
+    return { kind: "proceed" };
+  if (route === "marketplace") {
+    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."
+    };
+  }
+  return {
+    kind: "refuse",
+    reason: "no install route recorded \u2014 re-run the installer to record the install route"
+  };
+}
+// ../../packages/shared/dist/profile-switch/state.js
+import fs2 from "fs";
+import path6 from "path";
+
+class InstallStateError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InstallStateError";
+  }
+}
+function namedError(name, message) {
+  const err = new InstallStateError(message);
+  err.name = name;
+  return err;
+}
+var CorruptInstallStateError = (filePath, cause) => namedError("CorruptInstallStateError", `install-state.json at ${filePath} is corrupt: ${cause}`);
+var UnwritableInstallStateError = (filePath, cause) => namedError("UnwritableInstallStateError", `could not write install-state.json at ${filePath}: ${cause}`);
+var DEFAULT_STATE = () => ({ version: 2, platforms: {} });
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateShape(raw, filePath) {
+  if (!isPlainObject(raw)) {
+    throw CorruptInstallStateError(filePath, "root is not a JSON object");
+  }
+  if (raw.platforms !== undefined && !isPlainObject(raw.platforms)) {
+    throw CorruptInstallStateError(filePath, '"platforms" is present but not an object');
+  }
+  const platforms = isPlainObject(raw.platforms) ? raw.platforms : {};
+  return {
+    ...raw,
+    version: typeof raw.version === "number" ? raw.version : 2,
+    platforms
+  };
+}
+function readInstallState(filePath) {
+  let text;
+  try {
+    text = fs2.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT")
+      return DEFAULT_STATE();
+    throw CorruptInstallStateError(filePath, `could not read file: ${err.message}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    throw CorruptInstallStateError(filePath, `invalid JSON: ${err.message}`);
+  }
+  return validateShape(raw, filePath);
+}
+function writeInstallState(filePath, state) {
+  const validated = validateShape(state, filePath);
+  const text = `${JSON.stringify(validated, null, 2)}
+`;
+  try {
+    fs2.mkdirSync(path6.dirname(filePath), { recursive: true });
+    fs2.writeFileSync(filePath, text);
+  } catch (err) {
+    throw UnwritableInstallStateError(filePath, err.message);
+  }
+}
+function updatePlatform(filePath, host, patch) {
+  const state = readInstallState(filePath);
+  const existing = isPlainObject(state.platforms[host]) ? state.platforms[host] : { root: "", skills: [], skillsOwner: "plugin" };
+  const merged = { ...existing, ...patch };
+  const next = {
+    ...state,
+    platforms: { ...state.platforms, [host]: merged }
+  };
+  writeInstallState(filePath, next);
+  return next;
+}
+// ../../packages/shared/dist/profile-switch/lock.js
+import fs3 from "fs";
+import path7 from "path";
+import os4 from "os";
+import crypto2 from "crypto";
+import { execFileSync } from "child_process";
+
+class LockError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LockError";
+  }
+}
+function namedError2(name, message) {
+  const err = new LockError(message);
+  err.name = name;
+  return err;
+}
+var LockHeldError = (lockDir) => namedError2("LockHeldError", `another switch is running (lock held at ${lockDir})`);
+var LockAcquireError = (lockDir, cause) => namedError2("LockAcquireError", `could not acquire switch lock at ${lockDir}: ${cause}`);
+var DEFAULT_STALE_AFTER_MS = 5 * 60 * 1000;
+var DEFAULT_CLOCK = { now: () => Date.now() };
+var DEFAULT_IDENTITY = {
+  pid: () => process.pid,
+  hostname: () => os4.hostname(),
+  processStart: (pid) => {
+    try {
+      const out = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+        encoding: "utf-8"
+      }).trim();
+      return out.length > 0 ? out : null;
+    } catch {
+      return null;
+    }
+  }
+};
+function readOwner(ownerPath) {
+  let raw;
+  try {
+    raw = JSON.parse(fs3.readFileSync(ownerPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const r = raw;
+  if (typeof r.host === "string" && typeof r.pid === "number" && typeof r.processStart === "string" && typeof r.token === "string" && typeof r.timestamp === "number") {
+    return r;
+  }
+  return null;
+}
+function releaseIfOwned(lockDir, ownerPath, token) {
+  const owner = readOwner(ownerPath);
+  if (owner === null || owner.token !== token)
+    return;
+  fs3.rmSync(lockDir, { recursive: true, force: true });
+}
+function acquireLock(stateFilePath, options = {}) {
+  const lockDir = `${stateFilePath}.switch.lock`;
+  const ownerPath = path7.join(lockDir, "owner.json");
+  const clock = options.clock ?? DEFAULT_CLOCK;
+  const identity = options.identity ?? DEFAULT_IDENTITY;
+  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+  const createFresh = () => {
+    fs3.mkdirSync(lockDir);
+    const pid = identity.pid();
+    const startedAt = identity.processStart(pid);
+    if (startedAt == null) {
+      fs3.rmSync(lockDir, { recursive: true, force: true });
+      throw LockAcquireError(lockDir, "could not determine this process's start-time identity");
+    }
+    const token = crypto2.randomUUID();
+    const record = {
+      host: identity.hostname(),
+      pid,
+      processStart: startedAt,
+      token,
+      timestamp: clock.now()
+    };
+    fs3.mkdirSync(path7.dirname(ownerPath), { recursive: true });
+    fs3.writeFileSync(ownerPath, JSON.stringify(record));
+    return { lockDir, release: () => releaseIfOwned(lockDir, ownerPath, token) };
+  };
+  try {
+    return createFresh();
+  } catch (err) {
+    if (err.code !== "EEXIST")
+      throw err;
+  }
+  const owner = readOwner(ownerPath);
+  const provenDead = owner !== null && clock.now() - owner.timestamp >= staleAfterMs && identity.processStart(owner.pid) !== owner.processStart;
+  if (!provenDead)
+    throw LockHeldError(lockDir);
+  const reclaimDir = `${lockDir}.reclaim.${owner.token}`;
+  try {
+    fs3.renameSync(lockDir, reclaimDir);
+  } catch {
+    throw LockHeldError(lockDir);
+  }
+  fs3.rmSync(reclaimDir, { recursive: true, force: true });
+  try {
+    return createFresh();
+  } catch {
+    throw LockHeldError(lockDir);
+  }
+}
+// ../../packages/shared/dist/profile-switch/engine.js
+import fs4 from "fs";
+import path8 from "path";
+import os5 from "os";
+import crypto3 from "crypto";
+class SwitchEngineError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SwitchEngineError";
+  }
+}
+function namedError3(name, message) {
+  const err = new SwitchEngineError(message);
+  err.name = name;
+  return err;
+}
+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");
+}
+function resolveCommon(opts) {
+  const targetHome = opts.targetHome ?? os5.homedir();
+  const stateFilePath = opts.stateFilePath ?? defaultStatePath(targetHome);
+  return { targetHome, stateFilePath };
+}
+function listProfiles(opts = {}) {
+  const { targetHome, stateFilePath } = resolveCommon(opts);
+  const state = readInstallState(stateFilePath);
+  const universe = opts.hosts ?? HOSTS;
+  const hosts = universe.map((host) => {
+    const layout = resolveHostLayout(host, { targetHome, projectRoot: opts.projectRoot });
+    if (layout.route === "skip") {
+      return {
+        host,
+        installed: false,
+        skipped: true,
+        skipReason: layout.reason,
+        activeProfile: null,
+        bundleVersion: null,
+        availableProfiles: []
+      };
+    }
+    const installed = fs4.existsSync(layout.activeDir);
+    const availableProfiles = listVariantProfiles(layout);
+    const platform = state.platforms[host];
+    return {
+      host,
+      installed,
+      skipped: false,
+      skipReason: null,
+      activeProfile: platform?.modelProfile?.profile ?? "balanced",
+      bundleVersion: platform?.plugin?.version ?? null,
+      availableProfiles
+    };
+  });
+  return { hosts };
+}
+function listVariantProfiles(layout) {
+  if (!fs4.existsSync(layout.variantsRoot))
+    return [];
+  return fs4.readdirSync(layout.variantsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+}
+function matchesGlob(filename, glob) {
+  const starIdx = glob.indexOf("*");
+  if (starIdx === -1)
+    return filename === glob;
+  const prefix = glob.slice(0, starIdx);
+  const suffix = glob.slice(starIdx + 1);
+  return filename.length >= prefix.length + suffix.length && filename.startsWith(prefix) && filename.endsWith(suffix);
+}
+function assertStateWritable(stateFilePath) {
+  const dir = path8.dirname(stateFilePath);
+  try {
+    fs4.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    throw UnwritableInstallStateError(stateFilePath, err.message);
+  }
+  const checkPath = fs4.existsSync(stateFilePath) ? stateFilePath : dir;
+  try {
+    fs4.accessSync(checkPath, fs4.constants.W_OK);
+  } catch (err) {
+    throw UnwritableInstallStateError(stateFilePath, err.message);
+  }
+}
+function copyFileRouteVariant(layout, variantDir) {
+  fs4.mkdirSync(layout.activeDir, { recursive: true });
+  let changed = 0;
+  for (const entry of fs4.readdirSync(variantDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !matchesGlob(entry.name, layout.activeGlob))
+      continue;
+    fs4.copyFileSync(path8.join(variantDir, entry.name), path8.join(layout.activeDir, entry.name));
+    changed++;
+  }
+  return changed;
+}
+function repointOpencodeVariant(layout, variantDir) {
+  fs4.mkdirSync(layout.activeDir, { recursive: true });
+  let changed = 0;
+  for (const entry of fs4.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));
+    let destExists = true;
+    let destIsSymlink = false;
+    try {
+      destIsSymlink = fs4.lstatSync(dest).isSymbolicLink();
+    } catch {
+      destExists = false;
+    }
+    if (destExists && !destIsSymlink)
+      continue;
+    const tmp = `${dest}.massa-ai-switch.${crypto3.randomUUID()}`;
+    fs4.symlinkSync(target, tmp);
+    fs4.renameSync(tmp, dest);
+    changed++;
+  }
+  return changed;
+}
+function copyVariant(host, layout, variantDir) {
+  return host === "opencode" ? repointOpencodeVariant(layout, variantDir) : copyFileRouteVariant(layout, variantDir);
+}
+function switchProfile(opts) {
+  const { targetHome, stateFilePath } = resolveCommon(opts);
+  const dryRun = opts.dryRun ?? false;
+  const requested = opts.host ? [opts.host] : opts.hosts ?? HOSTS;
+  const universe = HOSTS.filter((h) => requested.includes(h));
+  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 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) => fs4.existsSync(h.layout.activeDir));
+  if (installedFileHosts.length === 0)
+    throw NoHostsDetectedError();
+  const withAvailability = fileHosts.map((h) => {
+    const variantsRootExists = fs4.existsSync(h.layout.variantsRoot);
+    const variantDir = h.layout.variantDir(opts.profile);
+    const available = variantsRootExists && fs4.existsSync(variantDir) && fs4.statSync(variantDir).isDirectory();
+    return { ...h, variantsRootExists, variantDir, available };
+  });
+  if (!withAvailability.some((h) => h.available)) {
+    const known = new Set;
+    for (const h of withAvailability) {
+      if (!h.variantsRootExists)
+        continue;
+      for (const name of listVariantProfiles(h.layout))
+        known.add(name);
+    }
+    throw UnknownProfileError(opts.profile, [...known].sort());
+  }
+  const lock = dryRun ? null : acquireLock(stateFilePath, opts.lock);
+  try {
+    const rows = [...skipRows];
+    for (const h of withAvailability) {
+      if (!h.variantsRootExists) {
+        rows.push({ host: h.host, status: "unsupported", reason: "bundle has no variants \u2014 upgrade plugin" });
+        continue;
+      }
+      if (!h.available) {
+        const supported = listVariantProfiles(h.layout);
+        rows.push({
+          host: h.host,
+          status: "unsupported",
+          reason: `profile "${opts.profile}" not supported on ${h.host} (supports: ${supported.join(", ") || "none"})`
+        });
+        continue;
+      }
+      const route = detectRoute(state.platforms[h.host]);
+      if (route.kind === "refuse") {
+        rows.push({ host: h.host, status: "failed", reason: route.reason });
+        continue;
+      }
+      if (dryRun) {
+        rows.push({ host: h.host, status: "switched" });
+        continue;
+      }
+      try {
+        const filesChanged = copyVariant(h.host, h.layout, h.variantDir);
+        updatePlatform(stateFilePath, h.host, {
+          modelProfile: { profile: opts.profile, switchedAt: new Date().toISOString() }
+        });
+        rows.push({ host: h.host, status: "switched", filesChanged });
+      } catch (err) {
+        rows.push({ host: h.host, status: "failed", reason: err.message });
+      }
+    }
+    const ordered = orderRows(universe, rows);
+    const restartRequired = !dryRun && ordered.some((r) => r.status === "switched");
+    return { profile: opts.profile, dryRun, hosts: ordered, restartRequired };
+  } finally {
+    lock?.release();
+  }
+}
+function orderRows(universe, rows) {
+  const byHost = new Map(rows.map((r) => [r.host, r]));
+  return HOSTS.filter((h) => universe.includes(h) && byHost.has(h)).map((h) => byHost.get(h));
+}
+// ../../packages/shared/dist/profile-switch/report.js
+function reportSucceeded(report) {
+  return report.hosts.every((h) => h.status === "switched" || h.status === "skipped");
+}
+// src/config-cli.ts
+import { promises as fs5 } from "fs";
+import path9 from "path";
+import os6 from "os";
 import { fileURLToPath } from "url";
-var __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path9.dirname(fileURLToPath(import.meta.url));
 function help() {
   console.log(`
 massa-ai-config - Configuration manager for massa-ai
@@ -1212,6 +1950,11 @@ Commands:
     agents install [--user|--project]   Write 17 agent .md files
     agents uninstall [--user|--project] Remove only massa-ai-owned agents
 
+  profile list      List shipped model profiles + per-host active profile
+  profile show      Same as 'profile list'
+  profile set <name> [--host <h>] [--dry-run]
+                    Switch installed agents to a profile (restart required after)
+
 Examples:
   massa-ai-config init
   massa-ai-config init --mistral your-api-key
@@ -1219,6 +1962,7 @@ Examples:
   massa-ai-config use mistral --api-key your-key
   massa-ai-config set embedding.dimensions 1024
   massa-ai-config agents install --user
+  massa-ai-config profile set work --dry-run
 `);
 }
 function parseOptions(args) {
@@ -1236,6 +1980,30 @@ function parseOptions(args) {
   }
   return options;
 }
+function formatProfileInventory(inventory) {
+  for (const h of inventory.hosts) {
+    if (h.skipped) {
+      console.log(`  ${h.host}: skipped (${h.skipReason})`);
+      continue;
+    }
+    if (!h.installed) {
+      console.log(`  ${h.host}: not installed`);
+      continue;
+    }
+    console.log(`  ${h.host}: active=${h.activeProfile} bundle=${h.bundleVersion ?? "unknown"} supports=${h.availableProfiles.length > 0 ? h.availableProfiles.join(",") : "none"}`);
+  }
+}
+function formatSwitchReport(report) {
+  console.log(`profile: ${report.profile}${report.dryRun ? " (dry run \u2014 no files changed)" : ""}`);
+  for (const row of report.hosts) {
+    const detail = row.reason ? `: ${row.reason}` : row.filesChanged !== undefined ? ` (${row.filesChanged} files changed)` : "";
+    console.log(`  ${row.host}: ${row.status}${detail}`);
+  }
+  if (report.restartRequired) {
+    console.log(`
+A host session restart is required for the change to take effect.`);
+  }
+}
 async function runCli(argv) {
   const args = argv;
   const command = args[0];
@@ -1358,18 +2126,18 @@ Using defaults:`);
         return 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");
+      const agentsDir = scope === "project" ? path9.join(process.cwd(), ".opencode/agents") : path9.join(process.env.XDG_CONFIG_HOME && process.env.XDG_CONFIG_HOME.trim() || path9.join(os6.homedir(), ".config"), "opencode", "agents");
+      const sourceAgentsDir = path9.resolve(__dirname2, "..", "agents");
       if (subcommand === "install") {
-        await fs2.mkdir(agentsDir, { recursive: true });
+        await fs5.mkdir(agentsDir, { recursive: true });
         let count = 0;
-        const entries = await fs2.readdir(sourceAgentsDir);
+        const entries = await fs5.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);
+          const src = path9.join(sourceAgentsDir, entry);
+          const dest = path9.join(agentsDir, entry);
+          await fs5.copyFile(src, dest);
           count++;
         }
         console.log(`+ ${count} subagent specialists (generated from skills/agents/*/SKILL.md)`);
@@ -1377,14 +2145,14 @@ Using defaults:`);
       } else {
         let removed = 0;
         try {
-          const entries = await fs2.readdir(agentsDir);
+          const entries = await fs5.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");
+            const filePath = path9.join(agentsDir, entry);
+            const content = await fs5.readFile(filePath, "utf8");
             if (content.includes("massa-ai-owned: true")) {
-              await fs2.unlink(filePath);
+              await fs5.unlink(filePath);
               removed++;
             }
           }
@@ -1397,6 +2165,44 @@ Using defaults:`);
       }
       break;
     }
+    case "profile": {
+      const subcommand = args[1];
+      if (subcommand === "list" || subcommand === "show") {
+        try {
+          formatProfileInventory(listProfiles());
+        } catch (e) {
+          console.error(`Error: ${e.message}`);
+          return 1;
+        }
+        return 0;
+      }
+      if (subcommand === "set") {
+        const name = args[2];
+        if (!name) {
+          console.error("Usage: massa-ai-config profile set <name> [--host <h>] [--dry-run]");
+          return 1;
+        }
+        const hostOpt = typeof options.host === "string" ? options.host : undefined;
+        if (hostOpt !== undefined && !isHost(hostOpt)) {
+          console.error(`Error: unknown host "${hostOpt}"`);
+          return 1;
+        }
+        try {
+          const report = switchProfile({
+            profile: name,
+            host: hostOpt,
+            dryRun: options["dry-run"] === true
+          });
+          formatSwitchReport(report);
+          return reportSucceeded(report) ? 0 : 1;
+        } catch (e) {
+          console.error(`Error: ${e.message}`);
+          return 1;
+        }
+      }
+      console.error("Usage: massa-ai-config profile <list|show|set> ...");
+      return 1;
+    }
     default:
       console.error(`Unknown command: ${command}`);
       help();