ostacky 0.5.3 → 0.5.5

package/dist/cli.js

@@ -161,7 +161,7 @@ var require_picocolors = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "ostacky",
-  version: "0.5.3",
+  version: "0.5.5",
   description: "Instalador interactivo de agentes y comandos para OpenCode",
   type: "module",
   bin: {
@@ -169,9 +169,11 @@ var package_default = {
   },
   scripts: {
     dev: "bun run src/cli.ts",
-    build: "bun build src/cli.ts --target=node --format=esm --outfile dist/cli.js && bun scripts/add-shebang.ts",
+    build: "bun build src/cli.ts --target=node --format=esm --outfile dist/cli.js && bun scripts/bundle-mcp.ts && bun scripts/add-shebang.ts",
     start: "node dist/cli.js",
     test: "bun test",
+    "hash:check": "bun run scripts/update-manifest-hashes.ts --check",
+    "hash:update": "bun run scripts/update-manifest-hashes.ts",
     prepublishOnly: "bun run build"
   },
   files: [
@@ -874,18 +876,19 @@ var L2 = () => {
 
 // src/prompts.ts
 import { join as join5 } from "path";
+import { existsSync as existsSync4 } from "fs";
 // manifest.json
 var manifest_default = {
-  version: "0.5.3",
+  version: "0.5.5",
   repo: "JaimeHoracio/Ostacky",
-  tag: "v0.5.3",
+  tag: "v0.5.5",
   agents: [
     {
       name: "ostacky",
       file: "assets/agents/ostacky.md",
       description: "Orquestador principal con ruteo por nivel de impacto, máquina de estados persistida (controller MCP), edición segura con 3 outcomes, y delegación en OpenSpec + Superpowers",
-      version: "0.5.3",
-      sha256: "92c533260f1747f660be123d699c227b77b3f36e3c8f33929a6f470b56fef6dc"
+      version: "0.5.5",
+      sha256: "b96e6d8d85c1264675c31f364adddb4baba379aae57ccdcd3260f45517dee714"
     }
   ],
   commands: [
@@ -893,14 +896,14 @@ var manifest_default = {
       name: "install-stack",
       file: "assets/commands/install-stack.md",
       description: "Instala el stack tecnológico del proyecto (CodeGraph, skills, OpenSpec, Engram, Context7, controller MCP)",
-      version: "0.5.3",
-      sha256: "e8b75efe505766d47dd4d38cfb055b6801552cd457d99bce018c196a346e4560"
+      version: "0.5.5",
+      sha256: "04d2b8e1944f121595fdad0711a48eaf0409fcab599f816ec9480a7df98914af"
     },
     {
       name: "opsx-sync",
       file: "assets/commands/opsx-sync.md",
       description: "Sincroniza delta specs del change activo sin inicializar CodeGraph si ya existe índice",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "ed9948f1910743b672e1dfad496bc96972a224a98b063232be39290d43068c50"
     }
   ],
@@ -909,15 +912,15 @@ var manifest_default = {
       name: "ask-user-server",
       file: "assets/mcp/ask-user-server/",
       description: "MCP server con tool ask_user para consultar al usuario con bloqueo de ejecución",
-      version: "0.5.3",
-      sha256: "b1614dda3a7a8f27367a2da48d80145a43bba6b88f7719fc5a8e041dfb905435"
+      version: "0.5.5",
+      sha256: "e9ae702eb8b05d18742d64edf58fd55c5faf7b5ce24d62370918c619fa48cc24"
     },
     {
       name: "ostacky-controller",
       file: "assets/mcp/ostacky-controller/",
-      description: "Máquina de estados persistida para Ostacky: validación de transiciones, consumo de decisiones, autorización de side effects, edición segura y snapshots reutilizables",
-      version: "0.5.3",
-      sha256: "c66291cf170a7579e611580e8ac6f4bb15857d7e71b43fb793d92ea3a0013951"
+      description: "Máquina de estados persistida para Ostacky: 13 tools MCP para ciclo completo de request (start_request → discovery → route → execution → sync → done), edición segura con validación de transiciones y persistencia atómica",
+      version: "0.5.5",
+      sha256: "9d2a76528b899096fa160ee864f42002fa4dbd81dd47501bd16801e06c7b4dff"
     }
   ],
   skills: [
@@ -925,77 +928,77 @@ var manifest_default = {
       name: "execution-mode-evaluation",
       file: "assets/skills/execution-mode-evaluation/SKILL.md",
       description: "Skill de análisis de modo de ejecución — output reconciliado con controller snapshot contract (recommendation field)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "1063bc501b284d84daa181198cfb8194beff481594ba9931e6bbd46d89cfdabd"
     },
     {
       name: "brainstorming",
       file: "assets/skills/brainstorming/SKILL.md",
       description: "Skill de descubrimiento y exploración (Superpowers)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "ad15458c54912007ae3f708c698a11f0a4a58e2a7c7860a1ae8874db573c9e98"
     },
     {
       name: "writing-plans",
       file: "assets/skills/writing-plans/SKILL.md",
       description: "Skill de planificación de implementación (Superpowers) — execution handoff removido, Ostacky decide modo de ejecución",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "ff242e9205666f74dc1b28bf19bd77270d46dcc5c322d643faa49aabf8e8d096"
     },
     {
       name: "tdd",
       file: "assets/skills/tdd/SKILL.md",
       description: "Skill de test-driven development (Superpowers)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "7eacd8ee81dc5c0b85065c0392e37ee10314661f7edb59dd8e70a9e0dae8f371"
     },
     {
       name: "subagent-driven-development",
       file: "assets/skills/subagent-driven-development/SKILL.md",
       description: "Skill de ejecución con subagentes (Superpowers) — ejecuta solo después de confirmación del coordinador Ostacky",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "a9e6c9070f63dcac0a065a1abd91c9218fa07e201f594d1ce5f6a0dc0bfa0674"
     },
     {
       name: "dispatching-parallel-agents",
       file: "assets/skills/dispatching-parallel-agents/SKILL.md",
       description: "Skill de dispatch paralelo de agentes (Superpowers)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "281edf0c38f358497c7e2066fa8217a2ba3e2a39b4205c4af0c41d328fc035a1"
     },
     {
       name: "review",
       file: "assets/skills/review/SKILL.md",
       description: "Skill de revisión de código (Superpowers)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "c78d3beff45e9bb6b5e9e1d7155910f379e082d7aaf3c61b90d651d09e0d2e2a"
     },
     {
       name: "openspec-explore",
       file: "assets/skills/openspec-explore/SKILL.md",
       description: "Skill de exploración pre-spec (OpenSpec)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "1c75cab8672c2eb8b12f27a0b31f0b7fdb73c21c72583c1e8a566e09fe4108a6"
     },
     {
       name: "openspec-propose",
       file: "assets/skills/openspec-propose/SKILL.md",
       description: "Skill de generación de proposal (OpenSpec)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "ab88e9aa22db09559ccf7987d08adc0469b7c6fbe46498e63a3b64926f19e66b"
     },
     {
       name: "openspec-apply-change",
       file: "assets/skills/openspec-apply-change/SKILL.md",
       description: "Skill de aplicación de change (OpenSpec)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "847c2f88a66e8d5946c1fec422a5367c89eca5340839b659bbaaeb6f0bdac487"
     },
     {
       name: "openspec-archive-change",
       file: "assets/skills/openspec-archive-change/SKILL.md",
       description: "Skill de archivo de change (OpenSpec)",
-      version: "0.5.3",
+      version: "0.5.5",
       sha256: "3d35905ec40a081b8fd77b144426e540c67b1f50cc5801b655313a4fdfaa087a"
     }
   ]
@@ -1143,7 +1146,8 @@ import {
   statSync,
   copyFileSync,
   readFileSync as readFileSync3,
-  rmSync
+  rmSync,
+  createWriteStream
 } from "fs";
 import { createHash as createHash2 } from "crypto";
 import { join as join4, resolve, dirname as dirname3, relative } from "path";
@@ -1186,7 +1190,7 @@ function clearLockfile(opencodeRoot) {
   const lockfile = readLockfile(opencodeRoot);
   if (!lockfile) {
     writeLockfile(opencodeRoot, {
-      version: "0.5.3",
+      version: "0.5.5",
       lockedAt: new Date().toISOString(),
       repo: "",
       tag: "",
@@ -1238,26 +1242,37 @@ function ensureOpenCodePaths(opencodeDir) {
     root: opencodeDir,
     agents: join4(opencodeDir, "agents"),
     commands: join4(opencodeDir, "commands"),
-    skills: join4(opencodeDir, "skills")
+    skills: join4(opencodeDir, "skills"),
+    mcp: join4(opencodeDir, "mcp"),
+    tools: join4(opencodeDir, "tools")
   };
-  for (const dir of [paths.root, paths.agents, paths.commands, paths.skills]) {
+  for (const dir of [paths.root, paths.agents, paths.commands, paths.skills, paths.mcp, paths.tools]) {
     if (!existsSync3(dir))
       mkdirSync2(dir, { recursive: true });
   }
   return paths;
 }
+function ensureToolDirs(toolsDir, toolNames) {
+  for (const name of toolNames) {
+    const dir = join4(toolsDir, name);
+    if (!existsSync3(dir))
+      mkdirSync2(dir, { recursive: true });
+  }
+}
 function createOpenCodeDir(baseDir) {
   return ensureOpenCodePaths(join4(baseDir, ".opencode"));
 }
-function copyDirRecursive(src, dest) {
+function copyDirRecursive(src, dest, skipGenerated = false) {
   if (!existsSync3(dest))
     mkdirSync2(dest, { recursive: true });
   for (const entry of readdirSync(src)) {
+    if (skipGenerated && (entry === "node_modules" || entry === "package-lock.json"))
+      continue;
     const srcPath = join4(src, entry);
     const destPath = join4(dest, entry);
     const stat = statSync(srcPath);
     if (stat.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
+      copyDirRecursive(srcPath, destPath, skipGenerated);
     } else {
       copyFileSync(srcPath, destPath);
     }
@@ -1272,6 +1287,8 @@ function computeTreeHash(dir) {
 }
 function walkForHash(root, current, lines) {
   for (const entry of readdirSync(current)) {
+    if (entry === "node_modules" || entry === "package-lock.json")
+      continue;
     const full = join4(current, entry);
     const stat = statSync(full);
     if (stat.isDirectory()) {
@@ -1283,6 +1300,97 @@ function walkForHash(root, current, lines) {
     }
   }
 }
+function stripJsoncComments(text) {
+  let result = "";
+  let i = 0;
+  let inString = false;
+  while (i < text.length) {
+    const char = text[i];
+    const next = text[i + 1];
+    if (inString) {
+      if (char === "\\") {
+        result += char + (next ?? "");
+        i += 2;
+        continue;
+      }
+      if (char === '"')
+        inString = false;
+      result += char;
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      result += char;
+      i++;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      while (i < text.length && text[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    result += char;
+    i++;
+  }
+  return result.replace(/,\s*([}\]])/g, "$1");
+}
+function readOpenCodeConfig(configPath) {
+  const raw = readFileSync3(configPath, "utf-8");
+  try {
+    return JSON.parse(stripJsoncComments(raw));
+  } catch {
+    return null;
+  }
+}
+function writeOpenCodeConfig(configPath, config) {
+  writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function ensureOpenCodeConfig(projectRoot) {
+  const existing = findOpenCodeConfig(projectRoot);
+  if (existing)
+    return existing;
+  const configPath = join4(projectRoot, "opencode.json");
+  writeOpenCodeConfig(configPath, {
+    $schema: "https://opencode.ai/config.json",
+    mcp: {}
+  });
+  return configPath;
+}
+function setMcpEntry(name, entry) {
+  const projectRoot = findProjectRoot();
+  const configPath = ensureOpenCodeConfig(projectRoot);
+  const config = readOpenCodeConfig(configPath);
+  if (!config)
+    return;
+  if (!config.mcp)
+    config.mcp = {};
+  config.mcp[name] = entry;
+  writeOpenCodeConfig(configPath, config);
+}
+function ensureMcpEntry(name, entry) {
+  const projectRoot = findProjectRoot();
+  const configPath = ensureOpenCodeConfig(projectRoot);
+  const config = readOpenCodeConfig(configPath);
+  if (!config)
+    return;
+  if (!config.mcp)
+    config.mcp = {};
+  const mcp = config.mcp;
+  if (!mcp[name]) {
+    mcp[name] = entry;
+    writeOpenCodeConfig(configPath, config);
+  }
+}
 function upsertLockfile(paths, type, item, manifest, contentHash) {
   const existing = readLockfile(paths.root) ?? {
     version: manifest.version,
@@ -1307,13 +1415,37 @@ function upsertLockfile(paths, type, item, manifest, contentHash) {
   existing.lockedAt = new Date().toISOString();
   writeLockfile(paths.root, existing);
 }
+function readBundledAsset(relativePath) {
+  const fullPath = join4(PACKAGE_ROOT, relativePath);
+  if (!existsSync3(fullPath))
+    return null;
+  return readFileSync3(fullPath, "utf-8");
+}
 async function installAgent(item, manifest, paths) {
-  const content = await downloadFile(manifest, item.file);
+  let content;
+  try {
+    content = await downloadFile(manifest, item.file);
+  } catch (downloadErr) {
+    const bundled = readBundledAsset(item.file);
+    if (bundled === null) {
+      throw new Error(`Descarga falló (${downloadErr.message}) y el asset no está bundleado en ${item.file}`);
+    }
+    content = bundled;
+  }
   writeFileSync3(join4(paths.agents, `${item.name}.md`), content, "utf-8");
   upsertLockfile(paths, "agents", item, manifest, sha256(content));
 }
 async function installCommand(item, manifest, paths) {
-  const content = await downloadFile(manifest, item.file);
+  let content;
+  try {
+    content = await downloadFile(manifest, item.file);
+  } catch (downloadErr) {
+    const bundled = readBundledAsset(item.file);
+    if (bundled === null) {
+      throw new Error(`Descarga falló (${downloadErr.message}) y el asset no está bundleado en ${item.file}`);
+    }
+    content = bundled;
+  }
   writeFileSync3(join4(paths.commands, `${item.name}.md`), content, "utf-8");
   upsertLockfile(paths, "commands", item, manifest, sha256(content));
 }
@@ -1346,27 +1478,37 @@ async function installMcpServer(item, manifest, paths) {
 ` + `  esperado: ${item.sha256}
 ` + `  recibido: ${treeHash}`);
   }
-  const dest = join4(paths.root, "mcp", item.name);
+  const dest = join4(paths.mcp, item.name);
   if (existsSync3(dest)) {
     rmSync(dest, { recursive: true, force: true });
   }
-  copyDirRecursive(src, dest);
-  upsertLockfile(paths, "mcpServers", item, manifest, treeHash);
-  const projectRoot = findProjectRoot();
-  const configPath = findOpenCodeConfig(projectRoot);
-  if (configPath) {
-    const raw = readFileSync3(configPath, "utf-8");
-    const config = JSON.parse(raw);
-    if (!config.mcp)
-      config.mcp = {};
-    config.mcp[item.name] = {
-      type: "local",
-      command: ["node", `.opencode/mcp/${item.name}/index.js`],
-      enabled: true
-    };
-    writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
-`, "utf-8");
+  mkdirSync2(dest, { recursive: true });
+  const bundledPath = join4(PACKAGE_ROOT, "dist", "mcp", item.name, "index.js");
+  if (existsSync3(bundledPath)) {
+    copyFileSync(bundledPath, join4(dest, "index.js"));
+  } else {
+    copyDirRecursive(src, dest, true);
+    const installCmd = isCommandAvailable("bun") ? "bun install --no-save" : "npm install --no-audit --no-fund";
+    try {
+      const output = execSync(installCmd, {
+        cwd: dest,
+        encoding: "utf-8",
+        timeout: 60000
+      });
+      if (output)
+        console.error(output);
+    } catch (e2) {
+      throw new Error(`MCP server "${item.name}" copiado pero ${installCmd} falló: ${e2.message}.
+` + `Resolvé las dependencias manualmente:
+` + `  cd .opencode/mcp/${item.name} && bun install`);
+    }
   }
+  upsertLockfile(paths, "mcpServers", item, manifest, treeHash);
+  ensureMcpEntry(item.name, {
+    type: "local",
+    command: ["node", `.opencode/mcp/${item.name}/index.js`],
+    enabled: true
+  });
 }
 function findOpenCodeConfig(projectRoot) {
   const candidates = ["opencode.json", "opencode.jsonc"];
@@ -1378,7 +1520,7 @@ function findOpenCodeConfig(projectRoot) {
   return null;
 }
 function isMcpServerInstalled(name, paths) {
-  return existsSync3(join4(paths.root, "mcp", name, "index.js"));
+  return existsSync3(join4(paths.mcp, name, "index.js"));
 }
 function isAgentInstalled(name, paths) {
   return existsSync3(join4(paths.agents, `${name}.md`));
@@ -1426,7 +1568,7 @@ function uninstallSkill(name, paths) {
   return true;
 }
 function uninstallMcpServer(name, paths) {
-  const dirPath = join4(paths.root, "mcp", name);
+  const dirPath = join4(paths.mcp, name);
   try {
     if (existsSync3(dirPath)) {
       rmSync(dirPath, { recursive: true, force: true });
@@ -1437,18 +1579,17 @@ function uninstallMcpServer(name, paths) {
   const projectRoot = findProjectRoot();
   const configPath = findOpenCodeConfig(projectRoot);
   if (configPath) {
-    try {
-      const raw = readFileSync3(configPath, "utf-8");
-      const config = JSON.parse(raw);
-      if (config.mcp && config.mcp[name]) {
-        delete config.mcp[name];
-        if (Object.keys(config.mcp).length === 0) {
+    const config = readOpenCodeConfig(configPath);
+    if (config) {
+      const mcp = config.mcp;
+      if (mcp && mcp[name]) {
+        delete mcp[name];
+        if (Object.keys(mcp).length === 0) {
           delete config.mcp;
         }
-        writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
-`, "utf-8");
+        writeOpenCodeConfig(configPath, config);
       }
-    } catch {}
+    }
   }
   removeFromLockfile(paths.root, "mcpServers", name);
   return true;
@@ -1483,44 +1624,189 @@ function isCommandAvailable(cmd) {
     return false;
   }
 }
-function installCodeGraph() {
-  if (!isCommandAvailable("codegraph")) {
-    try {
-      if (process.platform === "win32") {
-        execSync('powershell -c "irm https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.ps1 | iex"', { stdio: "inherit", timeout: 120000 });
-      } else {
-        execSync("curl -fsSL https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.sh | sh", { stdio: "inherit", timeout: 120000 });
-      }
-      if (!isCommandAvailable("codegraph")) {
-        return {
-          success: false,
-          message: "CodeGraph instalado pero no está en PATH. ¿Necesitás reiniciar la terminal?"
-        };
+function detectPlatformTarget() {
+  const platform = process.platform;
+  const arch = process.arch;
+  let os;
+  let cpu;
+  if (platform === "darwin")
+    os = "darwin";
+  else if (platform === "linux")
+    os = "linux";
+  else if (platform === "win32")
+    os = "win32";
+  else
+    return null;
+  if (arch === "arm64")
+    cpu = "arm64";
+  else if (arch === "x64")
+    cpu = "x64";
+  else
+    return null;
+  return `${os}-${cpu}`;
+}
+function downloadToFile(url, dest, timeoutMs = 180000) {
+  return new Promise((resolve2, reject) => {
+    const file = createWriteStream(dest);
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    fetch(url, { signal: controller.signal, headers: { "User-Agent": "ostacky-installer" } }).then((res) => {
+      if (!res.ok || !res.body) {
+        reject(new Error(`HTTP ${res.status} ${res.statusText} descargando ${url}`));
+        return;
       }
+      const reader = res.body.getReader();
+      const pump = ({ done, value }) => {
+        if (done) {
+          file.end();
+          return Promise.resolve();
+        }
+        return new Promise((w2) => file.write(Buffer.from(value), () => w2())).then(() => reader.read().then(pump));
+      };
+      return reader.read().then(pump);
+    }).then(() => {
+      clearTimeout(timer);
+      file.on("finish", () => resolve2());
+    }).catch((err) => {
+      clearTimeout(timer);
+      file.destroy();
+      try {
+        unlinkSync(dest);
+      } catch {}
+      reject(err);
+    });
+  });
+}
+async function downloadAndExtract(url, destDir, stripComponents = 1, timeoutMs = 180000) {
+  const tmp = join4(destDir, `.download-${Date.now()}`);
+  if (!existsSync3(tmp))
+    mkdirSync2(tmp, { recursive: true });
+  const archivePath = join4(tmp, url.endsWith(".zip") ? "archive.zip" : "archive.tar.gz");
+  try {
+    await downloadToFile(url, archivePath, timeoutMs);
+    if (!existsSync3(destDir))
+      mkdirSync2(destDir, { recursive: true });
+    if (process.platform === "win32" && url.endsWith(".zip")) {
+      execSync(`powershell -NoProfile -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force"`, { stdio: "pipe", timeout: 60000 });
+    } else {
+      const stripArg = stripComponents > 0 ? `--strip-components=${stripComponents}` : "";
+      execSync(`tar -xzf "${archivePath}" -C "${destDir}" ${stripArg}`, {
+        stdio: "pipe",
+        timeout: 60000
+      });
+    }
+  } finally {
+    try {
+      rmSync(tmp, { recursive: true, force: true });
+    } catch {}
+  }
+}
+async function fetchLatestReleaseTag(repo) {
+  try {
+    const res = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+      signal: AbortSignal.timeout(5000),
+      headers: { "User-Agent": "ostacky-installer" }
+    });
+    if (res.ok) {
+      const data = await res.json();
+      return data.tag_name ?? null;
+    }
+  } catch {}
+  try {
+    const res = await fetch(`https://github.com/${repo}/releases/latest`, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(5000),
+      headers: { "User-Agent": "ostacky-installer" }
+    });
+    const loc = res.headers.get("location") ?? "";
+    const m3 = loc.match(/releases\/tag\/(v[^/]+)$/);
+    if (m3)
+      return m3[1];
+  } catch {}
+  return null;
+}
+async function installCodeGraph(toolsDir) {
+  const projectRoot = findProjectRoot();
+  const cgToolDir = join4(toolsDir ?? join4(projectRoot, ".opencode", "tools"), "codegraph");
+  if (!existsSync3(cgToolDir))
+    mkdirSync2(cgToolDir, { recursive: true });
+  const target = detectPlatformTarget();
+  if (!target) {
+    return {
+      success: false,
+      message: `Plataforma no soportada para descarga local: ${process.platform}/${process.arch}. Instalá CodeGraph manualmente.`
+    };
+  }
+  const localBin = join4(cgToolDir, "bin", "codegraph");
+  const localBinExe = localBin + (process.platform === "win32" ? ".exe" : "");
+  if (existsSync3(localBinExe)) {
+    try {
+      execSync(`"${localBinExe}" --version`, { stdio: "pipe", timeout: 1e4 });
+    } catch {
+      try {
+        rmSync(join4(cgToolDir, "bin"), { recursive: true, force: true });
+      } catch {}
+    }
+  }
+  if (!existsSync3(localBinExe)) {
+    const tag = await fetchLatestReleaseTag("colbymchenry/codegraph");
+    if (!tag) {
+      return {
+        success: false,
+        message: "No se pudo obtener la última versión de CodeGraph desde GitHub."
+      };
+    }
+    const ext = process.platform === "win32" ? "zip" : "tar.gz";
+    const url = `https://github.com/colbymchenry/codegraph/releases/download/${tag}/codegraph-${target}.${ext}`;
+    try {
+      await downloadAndExtract(url, cgToolDir, 1, 180000);
     } catch (e2) {
       return {
         success: false,
-        message: `Error instalando CodeGraph: ${e2.message}`
+        message: `Error descargando CodeGraph ${tag}: ${e2.message}`
+      };
+    }
+    if (!existsSync3(localBinExe)) {
+      return {
+        success: false,
+        message: `Descarga de CodeGraph ${tag} completada pero no se encontró el binario en ${localBinExe}.`
       };
     }
+    if (process.platform !== "win32") {
+      try {
+        execSync(`chmod +x "${localBinExe}"`, { stdio: "pipe" });
+      } catch {}
+    }
   }
   try {
-    execSync("codegraph install --target=opencode --location=local --yes", {
+    execSync(`"${localBinExe}" init -i`, { stdio: "pipe", timeout: 120000, cwd: projectRoot });
+  } catch {}
+  try {
+    execSync(`"${localBinExe}" install --target opencode --location local --yes`, {
       stdio: "pipe",
-      timeout: 60000
+      timeout: 30000,
+      cwd: projectRoot
     });
-    execSync("codegraph init -i", { stdio: "pipe", timeout: 120000 });
-    return { success: true, message: "CodeGraph instalado y configurado para OpenCode" };
-  } catch (e2) {
-    return {
-      success: false,
-      message: `Error configurando CodeGraph: ${e2.message}`
-    };
+  } catch {}
+  const rootAgentsMd = join4(projectRoot, "AGENTS.md");
+  if (existsSync3(rootAgentsMd)) {
+    const dest = join4(cgToolDir, "AGENTS.md");
+    try {
+      copyFileSync(rootAgentsMd, dest);
+      unlinkSync(rootAgentsMd);
+    } catch {}
   }
+  setMcpEntry("codegraph", {
+    type: "local",
+    command: [`.opencode/tools/codegraph/bin/codegraph`, "serve", "--mcp"],
+    enabled: true
+  });
+  return { success: true, message: "CodeGraph instalado localmente en .opencode/tools/codegraph/ y configurado para OpenCode" };
 }
 function setupOpenSpec() {
+  const npxCmd = isCommandAvailable("bun") ? "bunx" : "npx --yes";
   try {
-    execSync("npx --yes openspec init --tools opencode --force", {
+    execSync(`${npxCmd} openspec init --tools opencode --force`, {
       stdio: "pipe",
       timeout: 120000
     });
@@ -1532,122 +1818,223 @@ function setupOpenSpec() {
     };
   }
 }
-function installEngram() {
-  if (isCommandAvailable("engram")) {
+async function installEngram(toolsDir) {
+  const projectRoot = findProjectRoot();
+  const engramToolDir = join4(toolsDir ?? join4(projectRoot, ".opencode", "tools"), "engram");
+  const engramBinDir = join4(engramToolDir, "bin");
+  if (!existsSync3(engramBinDir))
+    mkdirSync2(engramBinDir, { recursive: true });
+  const target = detectPlatformTarget();
+  if (!target) {
+    return {
+      success: false,
+      message: `Plataforma no soportada para descarga local: ${process.platform}/${process.arch}. Instalá Engram manualmente.`
+    };
+  }
+  const localBin = join4(engramBinDir, "engram" + (process.platform === "win32" ? ".exe" : ""));
+  if (existsSync3(localBin)) {
     try {
-      execSync("engram setup opencode", { stdio: "pipe", timeout: 30000 });
-      return { success: true, message: "Engram ya instalado y configurado para OpenCode" };
-    } catch (e2) {
+      execSync(`"${localBin}" --version`, { stdio: "pipe", timeout: 1e4 });
+    } catch {
+      try {
+        unlinkSync(localBin);
+      } catch {}
+    }
+  }
+  if (!existsSync3(localBin)) {
+    const tag = await fetchLatestReleaseTag("Gentleman-Programming/engram");
+    if (!tag) {
       return {
         success: false,
-        message: `Error configurando Engram: ${e2.message}`
+        message: "No se pudo obtener la última versión de Engram desde GitHub."
       };
     }
-  }
-  if (isCommandAvailable("go")) {
+    const versionNum = tag.replace(/^v/, "");
+    const [os, cpu] = target.split("-");
+    const engramCpu = cpu === "x64" ? "amd64" : cpu;
+    const ext = process.platform === "win32" ? "zip" : "tar.gz";
+    const url = `https://github.com/Gentleman-Programming/engram/releases/download/${tag}/engram_${versionNum}_${os}_${engramCpu}.${ext}`;
     try {
-      execSync("go install github.com/Gentleman-Programming/engram/cmd/engram@latest", { stdio: "pipe", timeout: 120000 });
-      if (isCommandAvailable("engram")) {
-        execSync("engram setup opencode", { stdio: "pipe", timeout: 30000 });
-        return { success: true, message: "Engram instalado via go install y configurado" };
+      await downloadAndExtract(url, engramToolDir, 0, 120000);
+    } catch (e2) {
+      return {
+        success: false,
+        message: `Error descargando Engram ${tag}: ${e2.message}`
+      };
+    }
+    const extractedBin = join4(engramToolDir, "engram" + (process.platform === "win32" ? ".exe" : ""));
+    if (existsSync3(extractedBin) && extractedBin !== localBin) {
+      try {
+        copyFileSync(extractedBin, localBin);
+        unlinkSync(extractedBin);
+      } catch {}
+    }
+    if (!existsSync3(localBin)) {
+      const found = findBinaryInDir(engramToolDir, "engram");
+      if (found && found !== localBin) {
+        try {
+          copyFileSync(found, localBin);
+          if (process.platform !== "win32")
+            execSync(`chmod +x "${localBin}"`, { stdio: "pipe" });
+        } catch {}
       }
-    } catch {}
+    }
+    if (!existsSync3(localBin)) {
+      return {
+        success: false,
+        message: `Descarga de Engram ${tag} completada pero no se encontró el binario en ${localBin}.`
+      };
+    }
+    if (process.platform !== "win32") {
+      try {
+        execSync(`chmod +x "${localBin}"`, { stdio: "pipe" });
+      } catch {}
+    }
   }
-  if (isCommandAvailable("brew") && (process.platform === "darwin" || process.platform === "linux")) {
-    try {
-      execSync("brew install gentleman-programming/tap/engram", {
-        stdio: "pipe",
-        timeout: 120000
-      });
-      if (isCommandAvailable("engram")) {
-        execSync("engram setup opencode", { stdio: "pipe", timeout: 30000 });
-        return { success: true, message: "Engram instalado via Homebrew y configurado" };
-      }
-    } catch {}
+  setMcpEntry("engram", {
+    type: "local",
+    command: [`.opencode/tools/engram/bin/engram`, "mcp"],
+    enabled: true
+  });
+  try {
+    execSync(`"${localBin}" setup opencode`, { stdio: "pipe", timeout: 30000 });
+  } catch {}
+  return { success: true, message: "Engram instalado localmente en .opencode/tools/engram/bin/ y configurado para OpenCode (MCP + plugin)" };
+}
+function findBinaryInDir(dir, name) {
+  const entries = readdirSync(dir);
+  for (const entry of entries) {
+    const full = join4(dir, entry);
+    const stat = statSync(full);
+    if (stat.isDirectory()) {
+      const found = findBinaryInDir(full, name);
+      if (found)
+        return found;
+    } else if (entry === name || entry === name + ".exe") {
+      return full;
+    }
   }
-  return {
-    success: false,
-    message: `No se pudo instalar Engram automáticamente.
-` + `  - Tenés Go? Ejecutá: go install github.com/Gentleman-Programming/engram/cmd/engram@latest
-` + `  - O descargá el binario: https://github.com/Gentleman-Programming/engram/releases
-` + "  - Después ejecutá: engram setup opencode"
-  };
+  return null;
 }
-function patchOpenCodeConfig() {
+function setupContext7(toolsDir) {
   const projectRoot = findProjectRoot();
-  const candidates = ["opencode.json", "opencode.jsonc"];
-  let configPath = null;
-  for (const name of candidates) {
-    const full = join4(projectRoot, name);
-    if (existsSync3(full)) {
-      configPath = full;
-      break;
-    }
+  const ctx7ToolDir = join4(toolsDir ?? join4(projectRoot, ".opencode", "tools"), "context7");
+  if (!existsSync3(ctx7ToolDir))
+    mkdirSync2(ctx7ToolDir, { recursive: true });
+  ensureMcpEntry("context7", {
+    type: "remote",
+    url: "https://mcp.context7.com/mcp",
+    enabled: true
+  });
+  const npxCmd = isCommandAvailable("bun") ? "bunx" : "npx --yes";
+  try {
+    execSync(`${npxCmd} ctx7 setup --opencode`, {
+      stdio: "pipe",
+      timeout: 60000
+    });
+    return { success: true, message: "Context7 configurado (MCP + skill instalado)" };
+  } catch {
+    return {
+      success: true,
+      message: "Context7 MCP registrado (skill opcional no instalada — corrí `npx ctx7 setup --opencode` manualmente si la querés)"
+    };
   }
+}
+function patchOpenCodeConfig() {
+  const projectRoot = findProjectRoot();
+  const configPath = findOpenCodeConfig(projectRoot);
   if (!configPath) {
     return {
       success: false,
       message: "No se encontró opencode.json ni opencode.jsonc"
     };
   }
-  try {
-    const raw = readFileSync3(configPath, "utf-8");
-    const config = JSON.parse(raw);
-    let changed = false;
-    if ("plugin" in config) {
-      delete config.plugin;
-      changed = true;
-    }
-    if (changed) {
-      writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
-`, "utf-8");
-      return { success: true, message: "Config actualizada (plugin legacy eliminado)" };
-    }
-    return { success: true, message: "Config de OpenCode ya está limpia" };
-  } catch (e2) {
+  const config = readOpenCodeConfig(configPath);
+  if (!config) {
     return {
       success: false,
-      message: `Error parcheando config: ${e2.message}`
+      message: `Error parseando ${configPath}`
     };
   }
+  let changed = false;
+  if ("plugin" in config) {
+    delete config.plugin;
+    changed = true;
+  }
+  if (changed) {
+    writeOpenCodeConfig(configPath, config);
+    return { success: true, message: "Config actualizada (plugin legacy eliminado)" };
+  }
+  return { success: true, message: "Config de OpenCode ya está limpia" };
 }
 function uninstallEngramConfig() {
   const projectRoot = findProjectRoot();
-  const candidates = ["opencode.json", "opencode.jsonc"];
-  let configPath = null;
-  for (const name of candidates) {
-    const full = join4(projectRoot, name);
-    if (existsSync3(full)) {
-      configPath = full;
-      break;
-    }
-  }
+  const configPath = findOpenCodeConfig(projectRoot);
   if (!configPath) {
     return { success: false, message: "No se encontró opencode.json ni opencode.jsonc" };
   }
-  try {
-    const raw = readFileSync3(configPath, "utf-8");
-    const config = JSON.parse(raw);
-    let changed = false;
-    if (config.mcp && "engram" in config.mcp) {
-      delete config.mcp.engram;
-      if (Object.keys(config.mcp).length === 0) {
-        delete config.mcp;
-      }
-      changed = true;
-    }
-    if (!changed) {
-      return { success: true, message: "Engram no estaba configurado en este proyecto" };
+  const config = readOpenCodeConfig(configPath);
+  if (!config) {
+    return { success: false, message: `Error parseando ${configPath}` };
+  }
+  const mcp = config.mcp;
+  if (mcp && "engram" in mcp) {
+    delete mcp.engram;
+    if (Object.keys(mcp).length === 0) {
+      delete config.mcp;
     }
-    writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
-`, "utf-8");
+    writeOpenCodeConfig(configPath, config);
     return { success: true, message: "Config de Engram eliminada de opencode.json" };
-  } catch (e2) {
-    return {
-      success: false,
-      message: `Error limpiando config de Engram: ${e2.message}`
-    };
   }
+  return { success: true, message: "Engram no estaba configurado en este proyecto" };
+}
+function uninstallStackConfig(paths) {
+  const projectRoot = findProjectRoot();
+  const removed = [];
+  const configPath = findOpenCodeConfig(projectRoot);
+  if (configPath) {
+    const config = readOpenCodeConfig(configPath);
+    if (config) {
+      const mcp = config.mcp;
+      let changed = false;
+      if (mcp) {
+        for (const name of ["codegraph", "context7", "engram"]) {
+          if (name in mcp) {
+            delete mcp[name];
+            removed.push(`mcp.${name}`);
+            changed = true;
+          }
+        }
+        if (Object.keys(mcp).length === 0) {
+          delete config.mcp;
+          changed = true;
+        }
+      }
+      if (changed) {
+        writeOpenCodeConfig(configPath, config);
+      }
+    }
+  }
+  const codegraphDir = join4(projectRoot, ".codegraph");
+  if (existsSync3(codegraphDir)) {
+    try {
+      rmSync(codegraphDir, { recursive: true, force: true });
+      removed.push(".codegraph/");
+    } catch {}
+  }
+  if (existsSync3(paths.tools)) {
+    try {
+      rmSync(paths.tools, { recursive: true, force: true });
+      removed.push(".opencode/tools/");
+    } catch {}
+  }
+  if (removed.length === 0) {
+    return { success: true, message: "No había configuración del stack para remover" };
+  }
+  return {
+    success: true,
+    message: `Removido: ${removed.join(", ")}. Los binarios globales (codegraph, engram) no se tocaron.`
+  };
 }
 
 // src/prompts.ts
@@ -1686,11 +2073,11 @@ function printPostInstallSteps() {
   ].join(`
 `), "Próximos pasos");
 }
-async function doInstallStack() {
+async function doInstallStack(toolsDir) {
   const spin = L2();
   let allOk = true;
   spin.start("Instalando CodeGraph...");
-  const cg = installCodeGraph();
+  const cg = await installCodeGraph(toolsDir);
   spin.stop(cg.success ? `✓ ${cg.message}` : `✗ ${cg.message}`);
   if (!cg.success)
     allOk = false;
@@ -1700,10 +2087,15 @@ async function doInstallStack() {
   if (!os.success)
     allOk = false;
   spin.start("Instalando Engram...");
-  const eng = installEngram();
+  const eng = await installEngram(toolsDir);
   spin.stop(eng.success ? `✓ ${eng.message}` : `✗ ${eng.message}`);
   if (!eng.success)
     allOk = false;
+  spin.start("Configurando Context7...");
+  const ctx = setupContext7(toolsDir);
+  spin.stop(ctx.success ? `✓ ${ctx.message}` : `✗ ${ctx.message}`);
+  if (!ctx.success)
+    allOk = false;
   spin.start("Verificando configuración...");
   const cfg = patchOpenCodeConfig();
   spin.stop(cfg.success ? `✓ ${cfg.message}` : `✗ ${cfg.message}`);
@@ -1788,6 +2180,7 @@ function kindLabel(type) {
 async function doInstallAll(manifest, paths) {
   const spin = L2();
   let errors = 0;
+  ensureToolDirs(paths.tools, ["codegraph", "engram", "context7"]);
   for (const agent of manifest.agents) {
     spin.start(`Descargando agente: ${agent.name}  (${agent.version})`);
     try {
@@ -1828,14 +2221,14 @@ async function doInstallAll(manifest, paths) {
       errors++;
     }
   }
-  if (errors === 0) {
-    v2.info("Instalando stack de herramientas...");
-    await doInstallStack();
-  }
+  v2.info("Instalando stack de herramientas...");
+  await doInstallStack(paths.tools);
   const missingTools = [];
-  if (!isCommandAvailable("codegraph"))
+  const codegraphBin = join5(paths.tools, "codegraph", "bin", "codegraph");
+  const engramBin = join5(paths.tools, "engram", "bin", "engram");
+  if (!existsSync4(codegraphBin))
     missingTools.push("CodeGraph");
-  if (!isCommandAvailable("engram"))
+  if (!existsSync4(engramBin))
     missingTools.push("Engram");
   if (missingTools.length > 0) {
     v2.warn(`Faltan herramientas del stack: ${missingTools.join(", ")}.
@@ -1926,6 +2319,35 @@ async function doAddSkill(manifest, paths) {
     }
   }
 }
+async function doAddMcp(manifest, paths) {
+  const lockfile = readLockfile(paths.root);
+  const options = (manifest.mcpServers ?? []).map((m3) => {
+    const installed = getInstalledVersion(lockfile, "mcpServers", m3.name);
+    const hint = installed ? `v${installed} instalado — ${m3.description}` : m3.description;
+    return { value: m3.name, label: `${m3.name}  (v${m3.version})`, hint };
+  });
+  if (options.length === 0) {
+    v2.info("No hay MCP servers disponibles en el manifest.");
+    return;
+  }
+  const selected = await pe({
+    message: "¿Qué MCP servers deseas instalar?",
+    options,
+    required: true
+  });
+  onCancel(selected);
+  const spin = L2();
+  for (const name of selected) {
+    const item = manifest.mcpServers.find((m3) => m3.name === name);
+    spin.start(`Instalando MCP server: ${name}  (${item.version})`);
+    try {
+      await installMcpServer(item, manifest, paths);
+      spin.stop(`MCP server instalado: ${name}  (${item.version})`);
+    } catch (e2) {
+      spin.stop(`Error: ${e2.message}`);
+    }
+  }
+}
 async function doUpdate(manifest, paths) {
   const candidates = getUpdateCandidates(manifest, paths);
   if (candidates.length === 0) {
@@ -1983,6 +2405,8 @@ async function runInteractiveMenu() {
       { value: "agent", label: "Instalar agente" },
       { value: "command", label: "Instalar command" },
       { value: "skill", label: "Instalar skill" },
+      { value: "mcp", label: "Instalar MCP server" },
+      { value: "stack", label: "Instalar stack de herramientas (CodeGraph, Engram, Context7)" },
       { value: "update", label: "Actualizar instalación" },
       { value: "uninstall", label: "Desinstalar" },
       { value: "exit", label: "Salir" }
@@ -2010,6 +2434,17 @@ async function runInteractiveMenu() {
       printPostInstallSteps();
       fe("Listo.");
       break;
+    case "mcp":
+      await doAddMcp(manifest, paths);
+      printPostInstallSteps();
+      fe("Listo.");
+      break;
+    case "stack": {
+      ensureToolDirs(paths.tools, ["codegraph", "engram", "context7"]);
+      await doInstallStack(paths.tools);
+      fe("Listo.");
+      break;
+    }
     case "update": {
       const latestManifest = await loadLatestManifest();
       await doUpdate(latestManifest, paths);
@@ -2073,6 +2508,52 @@ async function runAddSkillCommand() {
   printPostInstallSteps();
   fe("Listo.");
 }
+async function runAddMcpCommand() {
+  we(" OpenCode Installer ");
+  const manifest = await loadManifest();
+  const paths = await resolveOpenCodePaths();
+  if (!paths) {
+    fe("Cancelado.");
+    return;
+  }
+  await doAddMcp(manifest, paths);
+  printPostInstallSteps();
+  fe("Listo.");
+}
+async function runInstallStackCommand() {
+  we(" OpenCode Installer — Stack ");
+  const paths = await resolveOpenCodePaths();
+  if (!paths) {
+    fe("Cancelado.");
+    return;
+  }
+  ensureToolDirs(paths.tools, ["codegraph", "engram", "context7"]);
+  await doInstallStack(paths.tools);
+  fe("Stack instalado.");
+}
+async function runUninstallStackCommand() {
+  we(" OpenCode Installer — Stack ");
+  const paths = await resolveOpenCodePaths();
+  if (!paths) {
+    fe("Cancelado.");
+    return;
+  }
+  const confirm = await me({
+    message: "¿Remover la configuración del stack (CodeGraph, Engram, Context7) del proyecto? Los binarios globales no se tocan."
+  });
+  onCancel(confirm);
+  if (!confirm) {
+    fe("Cancelado.");
+    return;
+  }
+  const result = uninstallStackConfig(paths);
+  if (result.success) {
+    v2.success(result.message);
+  } else {
+    v2.warn(result.message);
+  }
+  fe("Stack desinstalado.");
+}
 async function runUpdateCommand() {
   we(" OpenCode Installer ");
   const manifest = await loadLatestManifest();
@@ -2101,7 +2582,7 @@ async function doUninstallTotal(paths) {
     pathsToDelete.push(join5(paths.skills, name));
   }
   for (const name of Object.keys(lockfile.mcpServers ?? {})) {
-    pathsToDelete.push(join5(paths.root, "mcp", name));
+    pathsToDelete.push(join5(paths.mcp, name));
   }
   ye(pathsToDelete.join(`
 `), `Se eliminarán ${pathsToDelete.length} archivo(s) / directorio(s)`);
@@ -2221,14 +2702,46 @@ async function doUninstallSkill(paths) {
     }
   }
 }
+async function doUninstallMcp(paths) {
+  const lockfile = readLockfile(paths.root);
+  if (!lockfile) {
+    v2.warn("No hay instalación registrada.");
+    return;
+  }
+  const installed = Object.keys(lockfile.mcpServers ?? {});
+  if (installed.length === 0) {
+    v2.info("No hay MCP servers instalados.");
+    return;
+  }
+  const options = installed.map((name) => ({
+    value: name,
+    label: name,
+    hint: `v${lockfile.mcpServers[name].version}`
+  }));
+  const selected = await pe({
+    message: "¿Qué MCP servers querés desinstalar?",
+    options,
+    required: true
+  });
+  onCancel(selected);
+  for (const name of selected) {
+    const ok = uninstallMcpServer(name, paths);
+    if (ok) {
+      v2.success(`MCP server eliminado: ${name}`);
+    } else {
+      v2.warn(`No se pudo eliminar el MCP server: ${name}`);
+    }
+  }
+}
 async function doUninstall(paths) {
   const scope = await de({
     message: "¿Qué querés desinstalar?",
     options: [
-      { value: "all", label: "Todo (agentes + commands + skills)" },
+      { value: "all", label: "Todo (agentes + commands + skills + MCPs)" },
       { value: "agent", label: "Solo un agente" },
       { value: "command", label: "Solo un command" },
-      { value: "skill", label: "Solo una skill" }
+      { value: "skill", label: "Solo una skill" },
+      { value: "mcp", label: "Solo un MCP server" }
     ]
   });
   onCancel(scope);
@@ -2245,6 +2758,9 @@ async function doUninstall(paths) {
     case "skill":
       await doUninstallSkill(paths);
       break;
+    case "mcp":
+      await doUninstallMcp(paths);
+      break;
   }
 }
 async function runUninstallCommand() {
@@ -2371,22 +2887,64 @@ async function runUninstallSkillCommand(name) {
   }
   fe("Listo.");
 }
+async function runUninstallMcpCommand(name) {
+  we(" OpenCode Installer ");
+  const paths = await resolveOpenCodePaths();
+  if (!paths) {
+    fe("Cancelado.");
+    return;
+  }
+  if (name) {
+    try {
+      validateFilePath(name);
+    } catch (e2) {
+      v2.warn(`Nombre inválido: ${e2.message}`);
+      return;
+    }
+    const lockfile = readLockfile(paths.root);
+    if (!lockfile || !lockfile.mcpServers || !(name in lockfile.mcpServers)) {
+      v2.warn(`${name} no está instalado.`);
+      return;
+    }
+    const dirPath = join5(paths.mcp, name);
+    ye(dirPath, `Se eliminará`);
+    const confirm = await me({ message: `¿Borrar el MCP server "${name}"?` });
+    onCancel(confirm);
+    if (!confirm) {
+      v2.info("Cancelado.");
+      return;
+    }
+    const ok = uninstallMcpServer(name, paths);
+    if (ok) {
+      v2.success(`MCP server eliminado: ${name}`);
+    } else {
+      v2.warn(`No se pudo eliminar el MCP server: ${name}`);
+    }
+  } else {
+    await doUninstallMcp(paths);
+  }
+  fe("Listo.");
+}
 
 // src/cli.ts
 var HELP = `
-ostacky — Instalador de agentes, comandos y skills para OpenCode
+ostacky — Instalador de agentes, comandos, skills y MCPs para OpenCode
 
 Uso:
   npx ostacky                    Menú interactivo (instalación completa)
-  npx ostacky install            Instalar TODO (agente + skills + CodeGraph + OpenSpec + Engram)
+  npx ostacky install            Instalar TODO (agente + skills + MCPs + CodeGraph + OpenSpec + Engram + Context7)
   npx ostacky add agent          Agregar agente(s)
   npx ostacky add command        Agregar command(s)
   npx ostacky add skill          Agregar skill(s)
+  npx ostacky add mcp            Agregar MCP server(s)
+  npx ostacky install-stack      Instalar solo el stack de herramientas (CodeGraph, OpenSpec, Engram, Context7)
+  npx ostacky uninstall-stack    Remover la configuración del stack del proyecto
   npx ostacky update             Actualizar instalación
   npx ostacky uninstall          Desinstalar todo
   npx ostacky uninstall agent    Desinstalar agente(s)
   npx ostacky uninstall command  Desinstalar command(s)
   npx ostacky uninstall skill    Desinstalar skill(s)
+  npx ostacky uninstall mcp      Desinstalar MCP server(s)
   npx ostacky --help             Mostrar esta ayuda
   npx ostacky --version          Mostrar versión
 `.trim();
@@ -2396,6 +2954,12 @@ async function main() {
     case "install":
       await runInstallCommand();
       break;
+    case "install-stack":
+      await runInstallStackCommand();
+      break;
+    case "uninstall-stack":
+      await runUninstallStackCommand();
+      break;
     case "add":
       if (subcmd === "agent") {
         await runAddAgentCommand();
@@ -2403,8 +2967,10 @@ async function main() {
         await runAddCommandCommand();
       } else if (subcmd === "skill") {
         await runAddSkillCommand();
+      } else if (subcmd === "mcp") {
+        await runAddMcpCommand();
       } else {
-        console.error(`Tipo desconocido: "${subcmd}". Usa 'agent', 'command' o 'skill'.`);
+        console.error(`Tipo desconocido: "${subcmd}". Usa 'agent', 'command', 'skill' o 'mcp'.`);
         process.exit(1);
       }
       break;
@@ -2421,10 +2987,13 @@ async function main() {
       } else if (subcmd === "skill") {
         const name = process.argv[4];
         await runUninstallSkillCommand(name);
+      } else if (subcmd === "mcp") {
+        const name = process.argv[4];
+        await runUninstallMcpCommand(name);
       } else if (subcmd === undefined) {
         await runUninstallCommand();
       } else {
-        console.error(`Subcomando desconocido: "${subcmd}". Usa 'agent', 'command', 'skill' o nada.`);
+        console.error(`Subcomando desconocido: "${subcmd}". Usa 'agent', 'command', 'skill', 'mcp' o nada.`);
         process.exit(1);
       }
       break;