@ancleto/spec 0.7.1 → 0.8.0

package/README.md

@@ -23,6 +23,7 @@
 - [Características principales](#características-principales)
 - [Requisitos](#requisitos)
 - [Instalación](#instalación)
+- [Hosts soportados y layouts por agente](#hosts-soportados-y-layouts-por-agente)
 - [Guía de .gitignore](#guía-de-gitignore)
 - [Configuración y tiers de costo](#configuración-y-tiers-de-costo)
 - [Uso rápido](#uso-rápido)
@@ -39,7 +40,7 @@
 
 **Ancleto** (alias de CLI: `aspec`) es un orquestador ligero para desarrollo de software asistido por IA bajo el paradigma **SDD (Spec-Driven Development)**.
 
-Vive dentro de tu entorno de desarrollo (OpenCode, Cursor, VS Code, Roo, etc.) y automatiza tres cosas que normalmente hacés a mano:
+Vive dentro de tu entorno de desarrollo (OpenCode, Claude, Cursor, VS Code, Roo, etc.) y automatiza tres cosas que normalmente hacés a mano:
 
 - **Especificar** — escritura guiada de especificaciones y planes de implementación.
 - **Descubrir** — relevamiento topológico del repositorio y empaquetado de contexto.
@@ -125,6 +126,59 @@ Para medir el consumo **real** por sesión (no estimado): `ancleto stats` lee la
 
 ---
 
+## Hosts soportados y layouts por agente
+
+`--agent <nombre>` selecciona **el layout nativo a materializar** (el directorio y la convención de
+nombre de cada asset) y el **pipeline de adaptación de frontmatter** de ese host. No arbitra qué
+descubre cada host: si dos hosts leen el mismo directorio, el descubrimiento compartido es un efecto
+del host (el CLI no deduplica ni elige un "ganador").
+
+| Host (`--agent`) | skills | agents | commands |
+|---|---|---|---|
+| `opencode` (default) | `.opencode/skills/<n>/SKILL.md` | `.opencode/agents/<n>.md` | `.opencode/commands/<n>.md` |
+| `claude` | `.claude/skills/<n>/SKILL.md` | `.claude/agents/<n>.md` (adaptado) | `.claude/commands/<n>.md` |
+| `vscode` (VS Code / Copilot) | `.github/skills/<n>/SKILL.md` | `.github/agents/<n>.agent.md` | `.github/prompts/<n>.prompt.md` |
+| `antigravity` | `.agents/skills/<n>/SKILL.md` | `.agents/agents/<n>.md` (adaptado) | `.agents/skills/<n>/SKILL.md` (como skill) |
+| `cursor` | `.cursor/skills/<n>/SKILL.md` | — | — |
+| `roo` | `.roo/skills/<n>/SKILL.md` | — | — |
+
+Cada host recibe sus skills en **su** directorio nativo. **`.agents/skills` es un punto de lectura
+compartido** —lo leen opencode, Cursor, VS Code y Antigravity—, no un destino universal: Claude lee
+`.claude/skills` y Roo, `.roo/skills`. Por eso el CLI no escribe todas las skills en `.agents/skills`.
+
+**Antigravity** no tiene directorio de commands de proyecto; sus `/cleto-*` se materializan como
+**command-skills** en `.agents/skills/<n>/SKILL.md` (los Workflows están deprecados a favor de Agent
+Skills), por eso `installedPaths.commands` queda vacío para este host. Sus `agents` se escriben en
+`.agents/agents/<n>.md` con el frontmatter adaptado: `name` inyectado, `tools` como **lista** de ids
+verificados de Antigravity (`read`→`view_file`, `edit`→`replace_file_content`, `grep`→`grep_search`,
+`bash`→`run_command`, `todowrite`→`manage_task`), `mode`→`mainAgent`/`subagent`,
+`commandExecutionPolicy: sandbox` y `model: inherit` (el tier no reescribe modelos de Antigravity). Una
+tool de opencode sin id verificado se **omite con aviso** (`skip tool '<k>': no verified Antigravity id
+for agent '<n>'`): un id inexistente cuelga el subagent. Los ids que sólo existen en el SDK
+(`find_file`, `edit_file`, `search_web`, `read_url_content`, …), los de comunidad (`write_to_file`,
+`call_mcp_tool`, `multi_replace_file_content`, …) y los de delegación (`invoke_subagent`,
+`start_subagent`, `define_subagent`) **no** se emiten; el uso de MCP se expresa por
+`mcpServers`/`.agents/mcp_config.json`, nunca como tool id. El campo `skill` no es una tool: se cubre
+con el surfaceo automático de skills de Antigravity.
+
+Los assets que un host no soporta (por ejemplo `agents`/`commands` de `cursor` y `roo`)
+**no se escriben** y el instalador avisa por `stderr`
+(`skip agents: not supported by host 'cursor'`) sin abortar. La instalación es **aditiva y no
+destructiva**: instalar con otro agente escribe en su base y preserva los layouts previos, y el
+manifiesto `.ancletorc.installedPaths` acumula la unión de los destinos realmente escritos.
+
+La **configuración MCP específica de host** está fuera de alcance con **una excepción**: para
+`agent: antigravity` el CLI genera o mergea (no destructivo) el MCP de workspace
+`.agents/mcp_config.json` con esquema `{ "mcpServers": { "<n>": { "command", "args", "env" } } }`,
+incluyendo el servidor de memoria `ancleto-memory`; preserva `mcpServers` preexistentes y no pisa
+homónimos. `.mcp.json` (Claude) y `.vscode/mcp.json` (VS Code) siguen fuera de alcance, al igual que el
+MCP global de Antigravity. `claude` se soporta con adaptación de frontmatter obligatoria para `agents`
+(se omiten `model`/`tools` sin equivalencia verificada y las claves
+`mode`/`color`/`temperature`/`permission`), sin MCP propio. Tanto `init` como `install --project`
+configuran el MCP del host en la misma ejecución; `--no-mcp` lo omite.
+
+---
+
 ## Guía de .gitignore
 
 El framework **no gestiona tu `.gitignore`**: es una decisión del proyecto. Como referencia, esta es la combinación que funciona bien con Ancleto:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ancleto/spec",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Orquestador SDD liviano con subagentes optimizados para costo/tokens",
   "type": "module",
   "bin": {

package/src/cli/index.js

@@ -35,13 +35,19 @@ Uso:
   ancleto install --tier <nivel>     normal | minimo | gratis (wizard interactivo en TTY)
   ancleto install --lang <codigo>    auto | es | en | pt (idioma de los artifacts; auto = idioma de la conversacion)
   ancleto install --exclude <globs>  Paths excluidos del discovery, coma-separados (ej: "**/*.png,docs")
-  ancleto install --agent <nombre>    opencode | vscode | antigravity | cursor | roo (wizard si no esta guardado)
+  ancleto install --agent <nombre>    opencode | claude | vscode | antigravity | cursor | roo (wizard si no esta guardado)
+                                   Elige el layout nativo a materializar (directorio + convencion de
+                                   nombre) y el adapter de frontmatter del host. NO arbitra el
+                                   descubrimiento entre hosts: si dos leen el mismo directorio, eso es
+                                   efecto del host (no se deduplica ni se elige "ganador").
+                                   antigravity instala skills, agents adaptados y commands como skills
+                                   (.agents/*) y mergea el MCP de workspace .agents/mcp_config.json.
   ancleto update [--project <dir>]    Alias de install (re-instala sobre lo existente)
                                    Parado en un proyecto con .ancletorc opera sobre ese proyecto;
                                    usa --global para forzar el alcance global
   ancleto upgrade [--agent <nombre>]  Re-aplica templates (LOCKED) y skills sobre el proyecto actual
-  ancleto init [--with-azure] [--agent <nombre>] [--tier <nivel>] [--lang <codigo>] [--exclude <globs>]
-                                     Crea .ancletorc en el repositorio actual
+  ancleto init [--with-azure] [--agent <nombre>] [--tier <nivel>] [--lang <codigo>] [--exclude <globs>] [--no-mcp]
+                                     Crea .ancletorc en el repositorio actual y configura el MCP del host
                                      (interactivo en TTY: banner + menu; Azure desactivado por defecto)
   ancleto discovery --check           Estado del seed (READY/STALE/PARTIAL/MISSING)
   ancleto discovery [--compress] [--include G] [--ignore G] [--token-budget N]
@@ -147,12 +153,28 @@ async function writeProjectsRegistry(reg) {
   return file
 }
 
+// D9: directorios locales de agents derivados del host/manifiesto, no de
+// `.opencode/agents` fijo. Un proyecto antigravity usa `.agents/agents`.
+function localAgentDirs(rc, agent) {
+  const dirs = new Set(rc?.installedPaths?.agents || [])
+  const spec = AGENT_TARGETS[agent || rc?.agent]?.agents
+  if (spec?.dir) dirs.add(spec.dir)
+  return [...dirs]
+}
+
+async function hasLocalAgents(baseDir, rc, agent) {
+  for (const d of localAgentDirs(rc, agent)) {
+    if (await exists(join(baseDir, d))) return true
+  }
+  return false
+}
+
 async function registerProject(projectDir, { agent, tier } = {}) {
   const abs = resolve(projectDir)
   const rc = await readAncletorc(abs)
   const tierFile = join(abs, '.opencode', '.ancleto-tier')
   const localTier = (await exists(tierFile)) ? (await readFile(tierFile, 'utf8')).trim() : null
-  const hasScopedAgents = await exists(join(abs, '.opencode', 'agents'))
+  const hasScopedAgents = await hasLocalAgents(abs, rc, agent)
   const entry = {
     path: abs.replace(/\\/g, '/'),
     version: await packageVersion(),
@@ -227,7 +249,7 @@ async function projectStatus(entry) {
   if (!rc) return { ...entry, exists: false, reason: 'sin .ancletorc' }
   const tierFile = join(abs, '.opencode', '.ancleto-tier')
   const tier = (await exists(tierFile)) ? (await readFile(tierFile, 'utf8')).trim() : null
-  const scoped = await exists(join(abs, '.opencode', 'agents'))
+  const scoped = await hasLocalAgents(abs, rc, entry.agent)
   return {
     ...entry,
     exists: true,
@@ -591,13 +613,13 @@ async function applyTier(agentsDir, tier, models = null) {
   }
 }
 
-const SUPPORTED_AGENTS = ['opencode', 'vscode', 'antigravity', 'cursor', 'roo']
+const SUPPORTED_AGENTS = ['opencode', 'claude', 'vscode', 'antigravity', 'cursor', 'roo']
 const DEFAULT_AGENT = 'opencode'
 
 function askAgent() {
   return new Promise((resolve) => {
     const rl = createInterface({ input: process.stdin, output: process.stdout })
-    rl.question('Agente/IDE [opencode/vscode/antigravity/cursor/roo] (default: opencode): ', (a) => {
+    rl.question(`Agente/IDE [${SUPPORTED_AGENTS.join('/')}] (default: ${DEFAULT_AGENT}): `, (a) => {
       rl.close()
       const t = a.trim().toLowerCase()
       resolve(SUPPORTED_AGENTS.includes(t) ? t : DEFAULT_AGENT)
@@ -725,6 +747,47 @@ async function mergeMcp(configDir, mcpMap) {
   return { file: targets.join(', '), added: [...new Set(added)] }
 }
 
+// D6: MCP de workspace de Antigravity (`.agents/mcp_config.json`). Merge NO
+// destructivo: se preservan `mcpServers` y demas claves top-level, no se pisa un
+// servidor homonimo, y un JSON invalido se avisa sin sobrescribir. Esquema del host
+// `{ command, args, env }` (se descartan `type`/`enabled` de opencode).
+async function mergeAntigravityMcp(projectDir, mcpMap) {
+  if (Object.keys(mcpMap).length === 0) return { file: null, added: [] }
+  const file = join(projectDir, '.agents', 'mcp_config.json')
+  let cfg = {}
+  if (await exists(file)) {
+    try {
+      cfg = JSON.parse((await readFile(file, 'utf8')).replace(/^\uFEFF/, ''))
+    } catch {
+      console.warn(`ancleto: no se pudo leer ${basename(file)} como JSON; MCP de Antigravity no se modifico`)
+      return { file, added: [] }
+    }
+  }
+  cfg.mcpServers = cfg.mcpServers || {}
+  const added = []
+  for (const [name, def] of Object.entries(mcpMap)) {
+    if (cfg.mcpServers[name]) continue
+    const command = Array.isArray(def.command) ? def.command : [def.command]
+    const server = { command: command[0], args: command.slice(1) }
+    if (def.env) server.env = def.env
+    cfg.mcpServers[name] = server
+    added.push(name)
+  }
+  await mkdir(dirname(file), { recursive: true })
+  await writeFile(file, JSON.stringify(cfg, null, 2) + '\n')
+  return { file, added }
+}
+
+// D6: dueno unico del MCP de host. Antigravity mergea `.agents/mcp_config.json`;
+// el resto conserva `mergeMcp` sobre opencode.json (targetDir = .opencode del
+// proyecto o config global).
+async function setupHostMcp(targetDir, mcpMap, { projectDir = null, agent = null } = {}) {
+  if (Object.keys(mcpMap).length === 0) return { file: null, added: [] }
+  if (agent === 'antigravity' && projectDir) return mergeAntigravityMcp(projectDir, mcpMap)
+  await mkdir(targetDir, { recursive: true })
+  return mergeMcp(targetDir, mcpMap)
+}
+
 async function copyAssets(dest) {
   await mkdir(dest, { recursive: true })
   for (const d of ASSETS) {
@@ -732,32 +795,297 @@ async function copyAssets(dest) {
   }
 }
 
-const AGENT_SKILLS_DIR = {
-  opencode: '.opencode/skills',
-  vscode: '.vscode/skills',
-  antigravity: '.antigravity/skills',
-  cursor: '.cursor/skills',
-  roo: '.roo/skills'
+// D1: destino nativo por host. Cada asset declara su directorio y su convencion
+// de nombre (ext); null = asset no soportado por ese host. Fuente unica de rutas.
+const MD_EXT = '.md'
+const AGENT_TARGETS = {
+  opencode: {
+    skills: { dir: '.opencode/skills' },
+    agents: { dir: '.opencode/agents', ext: MD_EXT },
+    commands: { dir: '.opencode/commands', ext: MD_EXT }
+  },
+  claude: {
+    skills: { dir: '.claude/skills' },
+    agents: { dir: '.claude/agents', ext: MD_EXT },
+    commands: { dir: '.claude/commands', ext: MD_EXT }
+  },
+  vscode: {
+    skills: { dir: '.github/skills' },
+    agents: { dir: '.github/agents', ext: '.agent.md' },
+    commands: { dir: '.github/prompts', ext: '.prompt.md' }
+  },
+  // Antigravity: agents adaptados en `.agents/agents` y commands materializados
+  // como skills dentro de `.agents/skills` (Antigravity no tiene dir de commands;
+  // los Workflows estan deprecados a favor de Agent Skills). `package: 'skill-dir'`
+  // marca que el asset se empaqueta como `<dir>/<n>/SKILL.md`, no como archivo plano.
+  antigravity: {
+    skills: { dir: '.agents/skills' },
+    agents: { dir: '.agents/agents', ext: MD_EXT },
+    commands: { dir: '.agents/skills', package: 'skill-dir' }
+  },
+  // Cursor y Roo: solo skills (D3/D7). .agents/skills es punto de lectura
+  // compartido (D2), no destino universal.
+  cursor: { skills: { dir: '.cursor/skills' }, agents: null, commands: null },
+  roo: { skills: { dir: '.roo/skills' }, agents: null, commands: null }
 }
 
 const ANCLETO_SKILLS = ['ancleto-new', 'ancleto-propose', 'ancleto-apply', 'ancleto-verify', 'ancleto-archive', 'ancleto-bulk-archive', 'ancleto-continue', 'ancleto-explore', 'ancleto-ff', 'ancleto-onboard', 'ancleto-workflow']
 
-async function installAgentSkills(projectDir, agent) {
-  const dir = AGENT_SKILLS_DIR[agent] || AGENT_SKILLS_DIR.opencode
-  const dest = join(projectDir, dir)
-  await mkdir(dest, { recursive: true })
-  for (const name of ANCLETO_SKILLS) {
-    const src = join(ROOT, 'skills', name)
-    if (!(await exists(src))) {
-      console.warn(`ancleto: skill no encontrada en el paquete: ${name}`)
+// Frontmatter: parser propio sin dependencias. Cada entrada conserva su clave y
+// sus lineas crudas (incluye block scalars y mapas anidados), preservando orden.
+function parseFrontmatter(content) {
+  const m = /^(---\r?\n)([\s\S]*?)(\r?\n---)(\r?\n?)([\s\S]*)$/.exec(content)
+  if (!m) return { hasFrontmatter: false, content }
+  const entries = []
+  for (const line of m[2].split(/\r?\n/)) {
+    if (/^[A-Za-z0-9_-]+:/.test(line)) {
+      entries.push({ key: line.slice(0, line.indexOf(':')), lines: [line] })
+    } else if (entries.length) {
+      entries[entries.length - 1].lines.push(line)
+    } else {
+      entries.push({ key: null, lines: [line] })
+    }
+  }
+  return { hasFrontmatter: true, open: m[1], entries, close: m[3], nl: m[4], body: m[5] }
+}
+
+function serializeFrontmatter(parsed) {
+  if (!parsed.hasFrontmatter) return parsed.content
+  const inner = parsed.entries.flatMap((e) => e.lines).join('\n')
+  return `${parsed.open}${inner}${parsed.close}${parsed.nl}${parsed.body}`
+}
+
+// D4/D5: hosts cuyo formato de agents difiere del origen requieren adaptacion.
+// Claude/VS Code eliminan las claves de opencode; Antigravity usa una
+// transformacion propia (D2). El resto es identidad (preservacion verbatim).
+const AGENT_ADAPTER_HOSTS = new Set(['claude', 'vscode', 'antigravity'])
+const AGENT_ADAPTER_DROP = new Set(['mode', 'color', 'temperature', 'permission', 'model', 'tools'])
+
+// D3: tabla unica (fijada contra la tabla oficial de frontmatter de Custom
+// Subagents) de ids de Antigravity. Conjunto CERRADO: solo se emiten estos ids.
+// Los ids solo-SDK (`find_file`, `edit_file`, `search_web`, `read_url_content`,
+// ...), los de comunidad (`write_to_file`, `call_mcp_tool`,
+// `multi_replace_file_content`, ...) y los de delegacion (`invoke_subagent`,
+// `start_subagent`, `define_subagent`) NO se emiten: no estan confirmados en el
+// frontmatter y un id inexistente cuelga el subagent (Known Issue). Una clave no
+// listada aqui se omite con aviso a stderr, nunca en silencio (D5).
+const ANTIGRAVITY_TOOL_MAP = {
+  read: 'view_file',
+  edit: 'replace_file_content',
+  grep: 'grep_search',
+  bash: 'run_command',
+  todowrite: 'manage_task'
+}
+
+// Hijos directos del mapa `tools:` con su valor crudo (p. ej. `read: true`).
+function parseToolFlags(entry) {
+  const flags = []
+  if (!entry) return flags
+  let childIndent = null
+  for (const line of entry.lines.slice(1)) {
+    const m = /^(\s+)([A-Za-z0-9_-]+):\s*(.*?)\s*$/.exec(line)
+    if (!m) continue
+    if (childIndent === null) childIndent = m[1].length
+    if (m[1].length !== childIndent) continue
+    flags.push({ key: m[2], value: m[3] })
+  }
+  return flags
+}
+
+function frontmatterValue(entry, fallback = null) {
+  if (!entry) return fallback
+  const m = /^[A-Za-z0-9_-]+:\s*(.*?)\s*$/.exec(entry.lines[0] || '')
+  return m ? m[1] : fallback
+}
+
+// D2/D3/D5/D8: adapta el frontmatter de un agent de opencode al de Antigravity.
+// `name` (requerido por el host) se inyecta desde el nombre del archivo. `tools` se
+// emite siempre como lista (el default del host es la lista vacia). Nunca se inventa
+// un id: una clave sin id verificado se omite con aviso (un id inexistente cuelga el
+// subagent).
+function adaptAntigravityFrontmatter(content, name) {
+  const parsed = parseFrontmatter(content)
+  if (!parsed.hasFrontmatter) return content
+  const byKey = (k) => parsed.entries.find((e) => e.key === k)
+  // Claves que el adaptador gestiona: las dropeadas (AGENT_ADAPTER_DROP), las que
+  // re-emite (name/tools/mainAgent/subagent/model/commandExecutionPolicy) y los campos
+  // que preserva del origen (description/skills/mcpServers). Se filtran TODAS del
+  // conjunto conservado para que ninguna pueda quedar duplicada, y se re-emiten una
+  // sola vez en orden determinista, sin importar lo que declare la fuente.
+  const managed = new Set([
+    ...AGENT_ADAPTER_DROP,
+    'name',
+    'description',
+    'mainAgent',
+    'subagent',
+    'commandExecutionPolicy',
+    'mcpServers',
+    'skills'
+  ])
+  // Se conservan las claves extra (no gestionadas); los campos preservados se
+  // re-emiten abajo desde su primera ocurrencia en el origen.
+  const kept = parsed.entries.filter((e) => e.key && !managed.has(e.key))
+
+  const toolIds = []
+  for (const { key, value } of parseToolFlags(byKey('tools'))) {
+    if (value === 'false') continue
+    if (key === 'skill') continue // no es tool: se cubre por `skills`/surfaceo automatico (OQ2)
+    const id = ANTIGRAVITY_TOOL_MAP[key]
+    if (id) {
+      toolIds.push(id)
+      continue
+    }
+    // D3/D5: regla dura. Un id fuera del frontmatter confirmado (exista o no en el
+    // SDK) no se emite: un id inexistente cuelga el subagent. Se omite con aviso,
+    // nunca en silencio. El uso de MCP NO se infiere desde claves desconocidas del
+    // mapa `tools`: se expresa por `mcpServers`/`.agents/mcp_config.json` (D6).
+    console.error(`skip tool '${key}': no verified Antigravity id for agent '${name}'`)
+  }
+
+  const mode = frontmatterValue(byKey('mode'))
+  const mainAgent = mode === 'subagent' ? 'false' : 'true'
+  const subagent = mode === 'primary' ? 'false' : 'true'
+
+  // Orden determinista: name, description, tools, mainAgent, subagent, model,
+  // commandExecutionPolicy, mcpServers, skills, y luego las claves extra conservadas.
+  const out = [{ key: 'name', lines: [`name: ${name}`] }]
+  const description = byKey('description')
+  if (description) out.push(description)
+  out.push({ key: 'tools', lines: [`tools: [${toolIds.join(', ')}]`] })
+  out.push({ key: 'mainAgent', lines: [`mainAgent: ${mainAgent}`] })
+  out.push({ key: 'subagent', lines: [`subagent: ${subagent}`] })
+  out.push({ key: 'model', lines: [`model: inherit`] })
+  out.push({ key: 'commandExecutionPolicy', lines: [`commandExecutionPolicy: sandbox`] })
+  const mcpServers = byKey('mcpServers')
+  if (mcpServers) out.push(mcpServers)
+  const skills = byKey('skills')
+  if (skills) out.push(skills)
+  out.push(...kept)
+  parsed.entries = out
+  return serializeFrontmatter(parsed)
+}
+
+function adaptFrontmatter(content, host, assetKind, name) {
+  if (assetKind !== 'agents' || !AGENT_ADAPTER_HOSTS.has(host)) return content
+  if (host === 'antigravity') return adaptAntigravityFrontmatter(content, name)
+  const parsed = parseFrontmatter(content)
+  if (!parsed.hasFrontmatter) return content
+  parsed.entries = parsed.entries.filter((e) => !(e.key && AGENT_ADAPTER_DROP.has(e.key)))
+  return serializeFrontmatter(parsed)
+}
+
+// D12: asset no soportado -> no se escribe y se avisa a stderr (no bloqueante).
+function warnUnsupportedAsset(asset, agent) {
+  console.error(`skip ${asset}: not supported by host '${agent}'`)
+}
+
+async function copyDirTransformed(srcDir, destDir, host, assetKind) {
+  await mkdir(destDir, { recursive: true })
+  for (const e of await readdir(srcDir, { withFileTypes: true })) {
+    const src = join(srcDir, e.name)
+    const dest = join(destDir, e.name)
+    if (e.isDirectory()) {
+      await copyDirTransformed(src, dest, host, assetKind)
+    } else if (e.isFile() && e.name.endsWith(MD_EXT)) {
+      await writeFile(dest, adaptFrontmatter(await readFile(src, 'utf8'), host, assetKind))
+    } else if (e.isFile()) {
+      await cp(src, dest)
+    }
+  }
+}
+
+async function installAssetFiles(cat, projectDir, spec, host) {
+  const destDir = join(projectDir, spec.dir)
+  await mkdir(destDir, { recursive: true })
+  for (const e of await readdir(join(ROOT, cat), { withFileTypes: true })) {
+    if (!e.isFile() || !e.name.endsWith(MD_EXT)) continue
+    const base = e.name.slice(0, -MD_EXT.length)
+    const content = await readFile(join(ROOT, cat, e.name), 'utf8')
+    await writeFile(join(destDir, `${base}${spec.ext}`), adaptFrontmatter(content, host, cat, base))
+  }
+}
+
+// D4: un command de ancleto convertido en skill (`name` + `description` del origen,
+// body verbatim). Antigravity no tiene dir de commands: sus `/cleto-*` viven como
+// command-skills dentro de `.agents/skills`.
+function commandToSkill(content, name) {
+  const parsed = parseFrontmatter(content)
+  const desc = parsed.hasFrontmatter ? parsed.entries.find((e) => e.key === 'description') : null
+  const head = ['---', `name: ${name}`, ...(desc ? desc.lines : []), '---'].join('\n')
+  const body = parsed.hasFrontmatter ? parsed.body : content
+  return `${head}\n${body}`
+}
+
+// Materializa `commands/*.md` como `.agents/skills/<n>/SKILL.md` (asset empaquetado).
+async function installCommandSkills(projectDir, spec) {
+  const destBase = join(projectDir, spec.dir)
+  for (const e of await readdir(join(ROOT, 'commands'), { withFileTypes: true })) {
+    if (!e.isFile() || !e.name.endsWith(MD_EXT)) continue
+    const base = e.name.slice(0, -MD_EXT.length)
+    const content = await readFile(join(ROOT, 'commands', e.name), 'utf8')
+    await mkdir(join(destBase, base), { recursive: true })
+    await writeFile(join(destBase, base, 'SKILL.md'), commandToSkill(content, base))
+  }
+}
+
+// Dueno unico de la instalacion de assets por proyecto: materializa skills,
+// agents y commands en el destino nativo del host y devuelve las rutas escritas.
+async function installAgentAssets(projectDir, agent) {
+  const model = AGENT_TARGETS[agent] || AGENT_TARGETS[DEFAULT_AGENT]
+  const written = { agents: [], commands: [], skills: [] }
+
+  if (model.skills) {
+    await copyDirTransformed(join(ROOT, 'skills'), join(projectDir, model.skills.dir), agent, 'skills')
+    written.skills.push(model.skills.dir)
+  } else {
+    warnUnsupportedAsset('skills', agent)
+  }
+
+  for (const cat of ['agents', 'commands']) {
+    const spec = model[cat]
+    if (!spec) {
+      warnUnsupportedAsset(cat, agent)
+      continue
+    }
+    // D4: un asset empaquetado (commands de Antigravity) vive dentro del layout de
+    // skills; no se registra un directorio de commands propio en installedPaths.
+    if (spec.package === 'skill-dir') {
+      await installCommandSkills(projectDir, spec)
       continue
     }
-    await cp(src, join(dest, name), { recursive: true })
+    await installAssetFiles(cat, projectDir, spec, agent)
+    written[cat].push(spec.dir)
+  }
+  return written
+}
+
+// D10: installedPaths es la union de destinos realmente escritos; un asset
+// omitido (null) no deja rastro. No se borran rutas previas (no destructivo).
+function unionInstalledPaths(existing, next) {
+  const out = {}
+  for (const k of ['templates', 'agents', 'commands', 'skills']) {
+    out[k] = [...new Set([...(existing?.[k] || []), ...(next?.[k] || [])])]
   }
-  if (dir !== AGENT_SKILLS_DIR.opencode) {
-    await cp(join(ROOT, 'skills'), dest, { recursive: true })
+  return out
+}
+
+// Convencion de nombre esperada en un directorio instalado (para `check`).
+function installedExtFor(cat, dirRel) {
+  for (const t of Object.values(AGENT_TARGETS)) {
+    const spec = t[cat]
+    if (spec && spec.dir === dirRel && spec.ext) return spec.ext
   }
-  return dir.replace(/\\/g, '/')
+  return null
+}
+
+// D9: hosts realmente instalados derivados del manifiesto (union de destinos
+// escritos), no de un unico `rc.agent`. Un proyecto multi-host debe sumar los
+// esperados de todos los hosts para no reportar huerfanos falsos.
+function installedHostsFromPaths(ip) {
+  const dirs = new Set([...(ip?.skills || []), ...(ip?.agents || []), ...(ip?.commands || [])])
+  return Object.entries(AGENT_TARGETS)
+    .filter(([, t]) => ['skills', 'agents', 'commands'].some((cat) => t[cat]?.dir && dirs.has(t[cat].dir)))
+    .map(([host]) => host)
 }
 
 const CHANGES_ROOT = 'aspec'
@@ -864,9 +1192,9 @@ function findInsertAnchor(local, source, name) {
   return local.length
 }
 
+// Solo mergea los templates raiz (AGENTS.md/PRODUCT.md). Los assets por host
+// los materializa installAgentAssets (dueno unico).
 async function copyTemplates(projectDir) {
-  const dest = join(projectDir, '.opencode')
-  await copyAssets(dest)
   for (const t of TEMPLATES) {
     const target = join(projectDir, t)
     const source = await readFile(join(ROOT, 'templates', t), 'utf8')
@@ -965,18 +1293,16 @@ async function install(args) {
     await migrateLegacyOpenspec(projectDir)
     await scaffoldAspec(projectDir)
     await refreshWorkingContext(projectDir)
-    const agentSkillsDir = await installAgentSkills(projectDir, agent)
+    const written = await installAgentAssets(projectDir, agent)
     await writeManifest(projectDir, {
       agent,
       language,
       ...(excludeChoice !== null ? { discovery: { ...existingDiscovery, exclude: excludeChoice } } : {}),
       ...(gratisModelChoice ? { gratisModel: gratisModelChoice } : {}),
-      installedPaths: {
+      installedPaths: unionInstalledPaths(existingRc?.installedPaths, {
         templates: ['AGENTS.md', 'PRODUCT.md'],
-        agents: ['.opencode/agents'],
-        commands: ['.opencode/commands'],
-        skills: [agentSkillsDir]
-      }
+        ...written
+      })
     })
   } else {
     await copyAssets(target)
@@ -984,6 +1310,9 @@ async function install(args) {
 
   const models = tierModels(tier, TIERS, gratisModelChoice)
   await applyTier(join(target, 'agents'), tier, models)
+  // El estado de tier vive en el base de opencode; puede no existir si el host
+  // resuelto ubica sus assets en otro directorio (p. ej. cursor -> .cursor/).
+  await mkdir(target, { recursive: true })
   await writeFile(tierStatePath(target), tier + '\n')
 
   if (projectDir) await registerProject(projectDir, { agent, tier })
@@ -997,9 +1326,9 @@ async function install(args) {
     }
   }
 
-  const res = await mergeMcp(target, mcpMap)
+  const res = await setupHostMcp(target, mcpMap, { projectDir, agent })
   const loc = projectDir
-    ? `${projectDir} (.opencode/ + templates en la raiz)`
+    ? `${projectDir} (layout ${agent} + templates en la raiz)`
     : `${target} (disponible en todos tus proyectos)`
   console.log(`ancleto: instalado en ${loc}`)
   console.log(`ancleto: tier de costo de agents: ${tier}`)
@@ -1020,20 +1349,19 @@ async function upgradeCmd(args) {
   await migrateLegacyOpenspec(projectDir)
   const agent = await resolveAgent(args, rc.agent)
   await copyTemplates(projectDir)
-  const agentSkillsDir = await installAgentSkills(projectDir, agent)
+  const written = await installAgentAssets(projectDir, agent)
   const wentContext = await refreshWorkingContext(projectDir)
   const manifest = await writeManifest(projectDir, {
     agent,
-    installedPaths: {
+    installedPaths: unionInstalledPaths(rc.installedPaths, {
       templates: ['AGENTS.md', 'PRODUCT.md'],
-      agents: ['.opencode/agents'],
-      commands: ['.opencode/commands'],
-      skills: [agentSkillsDir]
-    }
+      ...written
+    })
   })
+  const skillsDir = written.skills[0] || '.opencode/skills'
   console.log(`ancleto: upgrade completo (v${manifest.version}, agente: ${agent})`)
   console.log('  ✔ templates re-aplicados (bloques LOCKED actualizados, EXTENSIBLE intacto)')
-  console.log(`  ✔ skills actualizadas en ${agentSkillsDir} (${ANCLETO_SKILLS.length} skills)`)
+  console.log(`  ✔ skills actualizadas en ${skillsDir} (${ANCLETO_SKILLS.length} skills)`)
   console.log(wentContext ? '  ✔ working-context.md regenerado' : '  ✔ working-context.md sin reglas activas (vacio)')
   console.log('  ✔ manifiesto .ancletorc actualizado')
 }
@@ -1041,6 +1369,7 @@ async function upgradeCmd(args) {
 async function initProject(args) {
   const projectDir = process.cwd()
   const withAzure = args.includes('--with-azure')
+  const withMcp = !args.includes('--no-mcp')
   const agentFlag = scanAgentFlag(args)
   const tierFlag = scanTierFlag(args)
   const langFlag = scanLangFlag(args)
@@ -1100,12 +1429,17 @@ async function initProject(args) {
     const persisted = isKnownGratisModel(existing?.gratisModel) ? existing.gratisModel : null
     gratisModelChoice = persisted || gratisModel()
   }
+  const written = await installAgentAssets(projectDir, agent)
   const manifest = await writeManifest(projectDir, {
     azure,
     discovery,
     agent,
     language,
-    ...(gratisModelChoice ? { gratisModel: gratisModelChoice } : {})
+    ...(gratisModelChoice ? { gratisModel: gratisModelChoice } : {}),
+    installedPaths: unionInstalledPaths(existing?.installedPaths, {
+      templates: ['AGENTS.md', 'PRODUCT.md'],
+      ...written
+    })
   })
   await copyTemplates(projectDir)
   if (tier) {
@@ -1115,7 +1449,12 @@ async function initProject(args) {
   await scaffoldAspec(projectDir)
   await refreshWorkingContext(projectDir)
   await registerProject(projectDir, { agent, tier: tier || null })
+  // D7: init configura el MCP del host igual que install (mismo dueno, sin rama
+  // especial por host); --no-mcp conserva el escape.
+  const mcpMap = withMcp ? buildDefaultMcp({}) : {}
+  const mcpRes = await setupHostMcp(join(projectDir, '.opencode'), mcpMap, { projectDir, agent })
   if (azure.enabled) console.log(AZURE_MCP_NOTICE)
+  if (mcpRes.added.length) console.log(`ancleto: MCP configurados: ${mcpRes.added.join(', ')} en ${mcpRes.file}`)
   console.log(`ancleto: .ancletorc actualizado en ${projectDir} (v${manifest.version})${azure.enabled ? ' (Azure habilitado)' : ' (Azure desactivado)'} (Agente: ${agent})${tier ? ` (Tier: ${tier})` : ''} (Idioma: ${language})`)
 }
 
@@ -1571,6 +1910,8 @@ async function checkCommand() {
     process.exit(1)
   }
   const ip = rc.installedPaths
+  // D9: la union de hosts instalados se lee del manifiesto, no de un unico `rc.agent`.
+  const installedHosts = installedHostsFromPaths(ip)
   let missing = 0
   let orphans = 0
 
@@ -1591,7 +1932,21 @@ async function checkCommand() {
         missing++
         continue
       }
-      const expected = (await readdir(join(ROOT, cat))).sort()
+      // La convencion de nombre del host (p. ej. vscode: .agent.md/.prompt.md)
+      // se deriva del mismo modelo de destino; en skills no cambia el nombre.
+      const ext = installedExtFor(cat, dirRel)
+      let expected = (await readdir(join(ROOT, cat))).sort().map((f) => (ext ? f.replace(/\.md$/, ext) : f))
+      // D9: los command-skills de Antigravity viven dentro de `.agents/skills`; el
+      // conjunto esperado de ese dir suma el catalogo de skills y los commands de
+      // cualquier host instalado que empaquete commands ahi (union, no rc.agent).
+      const packagesCommandsHere = cat === 'skills' && installedHosts.some((h) => {
+        const cs = AGENT_TARGETS[h].commands
+        return cs?.package === 'skill-dir' && cs.dir === dirRel
+      })
+      if (packagesCommandsHere) {
+        const cmds = (await readdir(join(ROOT, 'commands'))).filter((f) => f.endsWith(MD_EXT)).map((f) => f.slice(0, -MD_EXT.length))
+        expected = [...new Set([...expected, ...cmds])].sort()
+      }
       const actual = (await readdir(destDir)).sort()
       const missingFiles = expected.filter((f) => !actual.includes(f))
       const orphanFiles = actual.filter((f) => !expected.includes(f))
@@ -1624,10 +1979,13 @@ async function checkTierOrphan(cwd) {
   if (!(await exists(tierFile))) return warnings
   const tier = (await readFile(tierFile, 'utf8')).trim()
   if (!TIERS[tier]) return warnings
-  const localAgents = join(cwd, '.opencode', 'agents')
+  // D9: se cuentan los agents locales del host realmente instalados, no
+  // `.opencode/agents` fijo (un proyecto antigravity usa `.agents/agents`).
+  const rc = await readAncletorc(cwd)
   let count = 0
-  if (await exists(localAgents)) {
-    count = (await readdir(localAgents)).filter((f) => f.endsWith('.md')).length
+  for (const d of localAgentDirs(rc)) {
+    const p = join(cwd, d)
+    if (await exists(p)) count += (await readdir(p)).filter((f) => f.endsWith(MD_EXT)).length
   }
   if (count === 0) {
     warnings.push(`tier "${tier}" sin agentes locales donde aplicarlo — este proyecto usa los agentes globales. Corre 'ancleto install --project .' para que el tier aplique, o borra .opencode/.ancleto-tier.`)