@ingeniomaps/cauce 0.1.0 → 0.2.0

package/automatization/runners/antigravity/skills/team/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: team
+description: Evalúa con un equipo si una intención es viable y propone una épica candidata.
+---
+
+Lee `AGENTS.md`, `planning/PROTOCOL.md` y el contexto de `organization/`. Obtené el recorrido con
+`node tools/ops.js team show <slug> --json` y ejecutá una etapa a la vez, adoptando en cada una el
+contrato del cargo que la posee. Respetá el dueño de decisión de cada dominio: ningún otro cargo
+resuelve en su lugar.
+
+Marcá el exit gate de una etapa como cumplido sólo si se cumple de verdad. Cuando falte evidencia,
+autoridad o una decisión externa, registrá la acción concreta en `planning/HUMAN_ACTIONS.md` y detente:
+una opinión del modelo no es investigación de usuarios ni valida un problema.
+
+Si la intención resulta viable, escribí la épica en `planning/roadmap/` con criterios observables y
+cerrá con `node tools/ops.js check planning`. Si no lo es, registrá en `planning/INBOX.md` por qué y
+qué la haría viable. **Nunca promuevas al BACKLOG**: esa firma es humana.

package/automatization/runners/claude/CLAUDE.md

@@ -3,8 +3,9 @@
 @AGENTS.md
 @planning/PROTOCOL.md
 
-Los hooks de `.claude/settings.json` son obligatorios. Usa `/autobuild` para ejecutar trabajo promovido;
-`/integration-sync` y `/integration-promote` gestionan staging local sin escritura remota.
+Los hooks de `.claude/settings.json` son obligatorios. Usa `/team` para evaluar si una intención es viable
+y proponer una épica, y `/autobuild` para ejecutar trabajo ya promovido; `/integration-sync` e
+`/integration-promote` gestionan staging local sin escritura remota. Ninguno promueve al BACKLOG.
 
 Antes de iniciar, respeta `planning/AWAITING_REVIEW.md` y el mutex de `planning/WIP.md`. Si el protocolo y
 un workflow difieren, manda el protocolo y la diferencia se registra en `planning/INBOX.md`.

package/automatization/runners/claude/manifest.json

@@ -2,12 +2,40 @@
   "schemaVersion": 1,
   "name": "claude",
   "command": "claude",
-  "config": { "source": "settings.json", "target": ".claude/settings.json" },
-  "instructions": [{ "source": "CLAUDE.md", "target": "CLAUDE.md" }],
+  "config": {
+    "source": "settings.json",
+    "target": ".claude/settings.json"
+  },
+  "instructions": [
+    {
+      "source": "CLAUDE.md",
+      "target": "CLAUDE.md"
+    }
+  ],
   "artifacts": [
-    { "source": "../../workflows/autobuild.js", "target": ".claude/workflows/autobuild.js" },
-    { "source": "../../workflows/integrations/sync.js", "target": ".claude/workflows/integration-sync.js" },
-    { "source": "../../workflows/integrations/promote.js", "target": ".claude/workflows/integration-promote.js" }
+    {
+      "source": "../../workflows/autobuild.js",
+      "target": ".claude/workflows/autobuild.js"
+    },
+    {
+      "source": "../../workflows/integrations/sync.js",
+      "target": ".claude/workflows/integration-sync.js"
+    },
+    {
+      "source": "../../workflows/integrations/promote.js",
+      "target": ".claude/workflows/integration-promote.js"
+    },
+    {
+      "source": "../../workflows/team.js",
+      "target": ".claude/workflows/team.js"
+    }
   ],
-  "capabilities": { "nativeHooks": true, "nativeWorkflows": true, "projectInstructions": true, "checkpointing": false }
+  "capabilities": {
+    "nativeHooks": true,
+    "nativeWorkflows": true,
+    "projectInstructions": true,
+    "checkpointing": false,
+    "nativeSkills": true
+  },
+  "roleSkills": ".claude/skills"
 }

package/automatization/runners/codex/manifest.json

@@ -2,8 +2,17 @@
   "schemaVersion": 1,
   "name": "codex",
   "command": "codex",
-  "config": { "source": "hooks.json", "target": ".codex/hooks/hooks.json" },
+  "config": {
+    "source": "hooks.json",
+    "target": ".codex/hooks/hooks.json"
+  },
   "instructions": [],
   "artifacts": [],
-  "capabilities": { "nativeHooks": true, "nativeWorkflows": false, "projectInstructions": true, "checkpointing": false }
+  "capabilities": {
+    "nativeHooks": true,
+    "nativeWorkflows": false,
+    "projectInstructions": true,
+    "checkpointing": false,
+    "nativeSkills": false
+  }
 }

package/automatization/runners/gemini/manifest.json

@@ -2,13 +2,39 @@
   "schemaVersion": 1,
   "name": "gemini",
   "command": "gemini",
-  "lifecycle": { "recommendedForNewProjects": false, "audience": "enterprise-cloud-api-key" },
-  "config": { "source": "settings.json", "target": ".gemini/settings.json" },
-  "instructions": [{ "source": "GEMINI.md", "target": "GEMINI.md" }],
+  "lifecycle": {
+    "recommendedForNewProjects": false,
+    "audience": "enterprise-cloud-api-key"
+  },
+  "config": {
+    "source": "settings.json",
+    "target": ".gemini/settings.json"
+  },
+  "instructions": [
+    {
+      "source": "GEMINI.md",
+      "target": "GEMINI.md"
+    }
+  ],
   "artifacts": [
-    { "source": "commands/ops/autobuild.toml", "target": ".gemini/commands/ops/autobuild.toml" },
-    { "source": "commands/ops/integration-sync.toml", "target": ".gemini/commands/ops/integration-sync.toml" },
-    { "source": "commands/ops/integration-promote.toml", "target": ".gemini/commands/ops/integration-promote.toml" }
+    {
+      "source": "commands/ops/autobuild.toml",
+      "target": ".gemini/commands/ops/autobuild.toml"
+    },
+    {
+      "source": "commands/ops/integration-sync.toml",
+      "target": ".gemini/commands/ops/integration-sync.toml"
+    },
+    {
+      "source": "commands/ops/integration-promote.toml",
+      "target": ".gemini/commands/ops/integration-promote.toml"
+    }
   ],
-  "capabilities": { "nativeHooks": false, "nativeWorkflows": false, "projectInstructions": true, "checkpointing": true }
+  "capabilities": {
+    "nativeHooks": false,
+    "nativeWorkflows": false,
+    "projectInstructions": true,
+    "checkpointing": true,
+    "nativeSkills": false
+  }
 }

package/automatization/workflows/team.js

@@ -0,0 +1,172 @@
+// Recorrido de un equipo: convierte una intención en una épica candidata, o en la razón por la
+// que todavía no se puede. Es el espejo de `autobuild`, que ejecuta trabajo ya aprobado.
+//
+// Nunca promueve: escribe la épica en roadmap/ y para. Promoverla al BACKLOG sigue siendo la firma
+// humana que autoriza ejecución.
+export const meta = {
+  name: 'team',
+  description: 'Recorre las etapas de un equipo, exige sus exit gates y propone una épica',
+  whenToUse: 'Evaluar si una idea es viable y darle forma antes de aprobarla, con varios cargos.',
+  phases: [
+    { title: 'Contract', detail: 'Manifiesto del equipo y contexto de la empresa' },
+    { title: 'Stages', detail: 'Una etapa por dueño de decisión, con su exit gate' },
+    { title: 'Draft', detail: 'Épica candidata con criterios observables' },
+    { title: 'Closing', detail: 'Validación y acciones humanas pendientes' },
+  ],
+}
+
+const ROOT = process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || '.'
+const P = `${ROOT}/planning`
+const ROADMAP = `${P}/roadmap`
+const HUMAN = `${P}/HUMAN_ACTIONS.md`
+const INBOX = `${P}/INBOX.md`
+
+const TEAM = String(args && args.team || process.env.OPS_TEAM || 'product-development')
+const INTENT = String(args && args.intent || process.env.OPS_INTENT || '').trim()
+
+const MANIFEST = {
+  type: 'object', additionalProperties: false, required: ['name', 'purpose', 'stages', 'guardrails'],
+  properties: {
+    name: { type: 'string' }, purpose: { type: 'string' },
+    entryAgent: { type: 'string' }, facilitator: { type: 'string' },
+    guardrails: { type: 'array', items: { type: 'string' } },
+    owners: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
+      domain: { type: 'string' }, agent: { type: 'string' },
+    } } },
+    stages: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
+      id: { type: 'string' }, agent: { type: 'string' }, exitGate: { type: 'string' },
+      produces: { type: 'array', items: { type: 'string' } },
+    } } },
+  },
+}
+const STAGE = {
+  type: 'object', additionalProperties: false, required: ['gatePassed', 'findings'],
+  properties: {
+    gatePassed: { type: 'boolean' },
+    findings: { type: 'string' },
+    evidence: { type: 'array', items: { type: 'string' } },
+    assumptions: { type: 'array', items: { type: 'string' } },
+    openQuestions: { type: 'array', items: { type: 'string' } },
+    missing: { type: 'string' },
+    humanAction: { type: 'string' },
+  },
+}
+const EPIC = {
+  type: 'object', additionalProperties: false, required: ['viable', 'title'],
+  properties: {
+    viable: { type: 'boolean' }, title: { type: 'string' }, slug: { type: 'string' },
+    reason: { type: 'string' },
+    criteria: { type: 'array', items: { type: 'string' } },
+    stories: { type: 'array', items: { type: 'string' } },
+  },
+}
+
+const stop = (reason, detail = '') => {
+  log(`Checkpoint: ${reason}${detail ? ` — ${detail}` : ''}`)
+  return finish({ stopped: true, reason, detail })
+}
+
+if (!INTENT) return stop('sin-intencion', 'pasá la intención a evaluar en args.intent')
+
+phase('Contract')
+
+const BASE = `Nunca inventes clientes, métricas, restricciones ni decisiones. No confundas una opinión ` +
+  `del modelo con evidencia: si algo no se puede afirmar con lo disponible, decilo y registrá qué ` +
+  `haría falta averiguar. No promuevas trabajo al BACKLOG, no escribas en sistemas externos y no ` +
+  `declares validado nada sin evidencia observable.`
+
+const contract = await agent(
+  `${BASE}\n\nRun "node tools/ops.js team show ${TEAM} --json" from ${ROOT} and report only what it ` +
+  `printed: name, purpose, entryAgent, facilitator, guardrails, the stages with id, agent, produces ` +
+  `and exitGate, and decisionOwners flattened into owners as domain/agent pairs. Then read ` +
+  `${ROOT}/organization/ and report nothing from it: it is context for later stages, not output.`,
+  { schema: MANIFEST, label: 'team-contract' },
+)
+if (!contract) return stop('contract-unavailable', `no se pudo leer el manifiesto de ${TEAM}`)
+
+const owners = (contract.owners || []).map((owner) => `${owner.domain}=${owner.agent}`).join(', ')
+const RULES = `${BASE}\n\nEquipo ${contract.name}: ${contract.purpose}\n` +
+  `Guardrails: ${contract.guardrails.join(' ')}\n` +
+  `${owners ? `Dueños de decisión: ${owners}. Ningún otro cargo resuelve en su dominio.\n` : ''}` +
+  `Contexto de la empresa en ${ROOT}/organization/. Intención a evaluar: ${INTENT}`
+
+phase('Stages')
+
+const handoffs = []
+const blocked = []
+for (const stage of contract.stages) {
+  const previous = handoffs.length
+    ? `Handoffs previos:\n${handoffs.map((entry) => `- ${entry.id}: ${entry.findings}`).join('\n')}`
+    : 'Sos la primera etapa: no hay handoff previo.'
+
+  const result = await agent(
+    `${RULES}\n\n${previous}\n\nActuá como ${stage.agent}, respetando su contrato en ` +
+    `agents/<tipo>/${stage.agent}/SKILL.md y sus límites. Etapa "${stage.id}": producí ` +
+    `${(stage.produces || []).join(' y ')}. Distinguí hechos, evidencia, supuestos y preguntas ` +
+    `abiertas. El exit gate es: "${stage.exitGate}". Marcá gatePassed sólo si se cumple de verdad; ` +
+    `si no, explicá en missing qué falta y en humanAction la acción concreta que lo desbloquea.`,
+    { schema: STAGE, label: `stage:${stage.id}` },
+  )
+  if (!result) return stop('stage-unavailable', `la etapa ${stage.id} no devolvió resultado`)
+
+  handoffs.push({ id: stage.id, agent: stage.agent, ...result })
+  if (!result.gatePassed) {
+    blocked.push({ stage: stage.id, missing: result.missing || '', action: result.humanAction || '' })
+    log(`Gate no cumplido en ${stage.id}: ${result.missing || 'sin detalle'}`)
+    break
+  }
+}
+
+if (blocked.length) {
+  await agent(
+    `${RULES}\n\nRegistrá en ${HUMAN} una fila por cada bloqueo, con la tarea, el estado pendiente, el ` +
+    `origen (etapa ${blocked[0].stage}) y la acción humana exacta que lo desbloquea. No inventes ` +
+    `responsables ni fechas. Bloqueos: ${JSON.stringify(blocked)}`,
+    { label: 'human-actions' },
+  )
+  return stop('gate-no-cumplido', `${blocked[0].stage}: ${blocked[0].missing}`)
+}
+
+phase('Draft')
+
+const epic = await agent(
+  `${RULES}\n\nHandoffs completos:\n${JSON.stringify(handoffs)}\n\nComo product-manager, decidí si la ` +
+  `intención es viable con la evidencia reunida. Si lo es, redactá la épica: título, slug en ` +
+  `kebab-case, criterios observables C1..CN —cada uno verificable sin ambigüedad— e historias que ` +
+  `rastreen a esos criterios. Si no lo es, viable=false y el motivo concreto. No la promuevas.`,
+  { schema: EPIC, label: 'epic-draft' },
+)
+if (!epic) return stop('draft-unavailable', 'la propuesta de épica no devolvió resultado')
+
+if (!epic.viable) {
+  await agent(
+    `${RULES}\n\nRegistrá la conclusión en la sección Lecciones de ${INBOX}: por qué esta intención no ` +
+    `es viable hoy y qué la haría viable. Motivo: ${epic.reason}`,
+    { label: 'inbox-lesson' },
+  )
+  return stop('no-viable', epic.reason)
+}
+
+await agent(
+  `${RULES}\n\nEscribí la épica en ${ROADMAP} como epic-NNN-${epic.slug}.md, tomando el próximo NNN ` +
+  `libre y siguiendo el contrato de ${P}/PROTOCOL.md: frontmatter epic/title/status/service con ` +
+  `status open, criterios **CN**, "## Contexto relevante" e historias con (→ CN) y (service: ruta). ` +
+  `Título: ${epic.title}. Criterios: ${JSON.stringify(epic.criteria)}. ` +
+  `Historias: ${JSON.stringify(epic.stories)}. No toques BACKLOG.md: la promoción es humana.`,
+  { label: 'epic-write' },
+)
+
+phase('Closing')
+
+const closing = await agent(
+  `${RULES}\n\nRun "node tools/ops.js check ${P}" from ${ROOT} and report whether it passed. If it ` +
+  `failed, repair only the epic you just wrote so it satisfies the contract; never weaken a criterion ` +
+  `to force green.`,
+  { schema: { type: 'object', required: ['passed', 'details'], properties: {
+    passed: { type: 'boolean' }, details: { type: 'string' },
+  } }, label: 'closing-check' },
+)
+if (!closing || !closing.passed) return stop('check-failed', closing ? closing.details : 'sin resultado')
+
+log(`Épica candidata lista en ${ROADMAP}. Promoverla al BACKLOG requiere una decisión humana.`)
+return finish({ team: TEAM, stages: handoffs.length, epic: epic.slug, promoted: false })

package/engine/agents/catalog.js

@@ -0,0 +1,67 @@
+'use strict'
+
+// Resolución única del catálogo de cargos. La usan el ciclo de aprendizaje, la validación de
+// equipos y la instalación en runners: tres lugares que antes resolvían por su cuenta.
+//
+// Cada tipo separa lo del toolkit de lo del proyecto igual que el resto de las colecciones:
+//
+//   agents/<tipo>/system/<slug>/SKILL.md   viene con Cauce y se reemplaza al actualizar
+//   agents/<tipo>/<slug>/SKILL.md          es del proyecto y manda sobre el anterior
+//
+// Un slug repetido entre tipos distintos sigue siendo ambiguo: ahí no hay ninguna regla que
+// diga cuál gana, y elegir en silencio sería peor que fallar.
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+
+function directories(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+  } catch { return [] }
+}
+
+function types(root) {
+  return directories(path.join(root, 'agents'))
+}
+
+// Todos los cargos visibles: los del proyecto ocultan a los del sistema con el mismo slug.
+function list(root) {
+  const catalog = path.join(root, 'agents')
+  const found = new Map()
+  for (const type of types(root)) {
+    const base = path.join(catalog, type)
+    // El sistema primero para que el proyecto lo sobrescriba al pasar por encima.
+    for (const [source, system] of [[path.join(base, 'system'), true], [base, false]]) {
+      for (const slug of directories(source)) {
+        if (slug === 'system' || !SLUG.test(slug)) continue
+        const dir = path.join(source, slug)
+        if (!fs.existsSync(path.join(dir, 'SKILL.md'))) continue
+        found.set(slug, { slug, type, dir, system })
+      }
+    }
+  }
+  return [...found.values()].sort((left, right) => left.slug.localeCompare(right.slug))
+}
+
+function resolve(root, slug) {
+  if (!SLUG.test(slug || '')) throw new Error(`agente inválido: ${slug || '(vacío)'}`)
+  const matches = []
+  for (const type of types(root)) {
+    const own = path.join(root, 'agents', type, slug)
+    const system = path.join(root, 'agents', type, 'system', slug)
+    // Dentro de un tipo la precedencia está definida; entre tipos no, y por eso se acumulan.
+    if (fs.existsSync(path.join(own, 'SKILL.md'))) matches.push(own)
+    else if (fs.existsSync(path.join(system, 'SKILL.md'))) matches.push(system)
+  }
+  if (!matches.length) throw new Error(`no existe agents/<tipo>/${slug}/SKILL.md`)
+  if (matches.length > 1) {
+    throw new Error(`agente ambiguo ${slug}: ${matches.map((dir) => path.relative(root, dir)).join(', ')}`)
+  }
+  return matches[0]
+}
+
+module.exports = { list, resolve, types }

package/engine/agents/learning.js

@@ -4,6 +4,7 @@
 
 const fs = require('fs')
 const path = require('path')
+const catalog = require('./catalog')
 
 const REQUIRED_SECTIONS = [
   'Hallazgos',
@@ -15,22 +16,7 @@ const REQUIRED_SECTIONS = [
 ]
 
 function agentRoot(root, agent) {
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(agent || '')) throw new Error(`agente inválido: ${agent || '(vacío)'}`)
-  const catalog = path.join(root, 'agents')
-  let types = []
-  try {
-    types = fs.readdirSync(catalog, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name)
-  } catch { /* catálogo ausente */ }
-  const matches = types
-    .map((type) => path.join(catalog, type, agent))
-    .filter((target) => fs.existsSync(path.join(target, 'SKILL.md')))
-  if (!matches.length) throw new Error(`no existe agents/<tipo>/${agent}/SKILL.md`)
-  if (matches.length > 1) {
-    throw new Error(`agente ambiguo ${agent}: ${matches.map((target) => path.relative(root, target)).join(', ')}`)
-  }
-  return matches[0]
+  return catalog.resolve(root, agent)
 }
 
 function isoDate(now = new Date()) { return now.toISOString().slice(0, 10) }

package/engine/automation/index.js

@@ -5,6 +5,9 @@ const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const F = require('../core/files')
 const H = require('../hooks/run')
+const P = require('../planning/parser')
+const catalog = require('../agents/catalog')
+const O = require('../core/ownership')
 
 const RUNNER_NAMES = ['claude', 'codex', 'gemini', 'antigravity']
 
@@ -81,6 +84,48 @@ function resolveItem(paths, root, name, item) {
   }
 }
 
+// Cargos del catálogo, con el frontmatter que el runner indexa para elegir a quién invocar.
+function roleCatalog(root) {
+  return catalog.list(root)
+    .map((role) => {
+      const field = P.frontmatter(fs.readFileSync(path.join(role.dir, 'SKILL.md'), 'utf8'))
+      return { ...role, reference: path.relative(root, role.dir), description: field('description') }
+    })
+    .filter((role) => role.description)
+}
+
+// Puntero fino: conserva nombre y descripción —lo único que el runner lee hasta invocar— y remite
+// al contrato completo. Evita duplicar el catálogo entero dentro de la configuración del runner.
+function roleSkill(role) {
+  return `---
+name: ${role.slug}
+description: ${role.description}
+---
+
+# ${role.slug}
+
+Leé \`${role.reference}/SKILL.md\` para el contrato completo del cargo: cuándo actuar,
+qué decide, qué no le corresponde y cuál es su entrega mínima. Sus métodos y formatos de salida están
+en \`${role.reference}/references/\`.
+
+Respetá los límites de ese contrato y las reglas de \`AGENTS.md\`. Generado por
+\`cauce automation install\`: no lo edites acá.
+`
+}
+
+function installRoleSkills(root, runner, output) {
+  if (!runner.capabilities.nativeSkills || !runner.roleSkills) return 0
+  const base = F.assertWithin(root, path.resolve(root, runner.roleSkills), `${runner.name}: roleSkills`)
+  const roles = roleCatalog(root)
+  for (const role of roles) {
+    const file = path.join(base, role.slug, 'SKILL.md')
+    F.assertNoSymlinkPath(root, file)
+    F.atomicWrite(file, roleSkill(role))
+  }
+  if (roles.length) output.log(`✓ ${runner.name}: ${roles.length} cargo(s) disponibles en ${runner.roleSkills}`)
+  return roles.length
+}
+
 function hasHooks(config) {
   if (config.hooks && Object.keys(config.hooks).length) return true
   const events = [
@@ -125,12 +170,11 @@ function check(root) {
       errors.push(`automatization/hooks/${name} no es ejecutable`)
     }
   }
-  const installedRuntime = path.join(root, '.ops', 'engine', 'hooks', 'run.js')
-  const sourceRuntime = path.join(root, 'engine', 'hooks', 'run.js')
-  if (!fs.existsSync(installedRuntime) && !fs.existsSync(sourceRuntime)) {
-    errors.push('falta engine/hooks/run.js')
+  // El motor puede venir de la dependencia npm, de la copia local o del propio repositorio.
+  if (!O.engineAt(root, path.join('hooks', 'run.js'))) {
+    errors.push('falta engine/hooks/run.js: instalá la dependencia o restaurá .ops/engine')
   }
-  const workflows = ['autobuild.js', path.join('integrations', 'sync.js')]
+  const workflows = ['autobuild.js', 'team.js', path.join('integrations', 'sync.js')]
   workflows.push(path.join('integrations', 'promote.js'))
   for (const name of workflows) {
     if (!fs.existsSync(path.join(root, 'automatization', 'workflows', name))) {
@@ -256,6 +300,23 @@ function doctor(root, name, output = console) {
       errors.push(`${item.target}: difiere de la fuente canónica`)
     }
   }
+  // Un cargo que quedó fuera, o cuya descripción cambió en el catálogo, deja al runner eligiendo
+  // con información vieja. Se reinstala, no se repara a mano.
+  if (runner.capabilities.nativeSkills && runner.roleSkills) {
+    const missing = []
+    const stale = []
+    for (const role of roleCatalog(root)) {
+      const file = path.join(root, runner.roleSkills, role.slug, 'SKILL.md')
+      if (!fs.existsSync(file)) missing.push(role.slug)
+      else if (fs.readFileSync(file, 'utf8') !== roleSkill(role)) stale.push(role.slug)
+    }
+    if (missing.length) {
+      warnings.push(`${missing.length} cargo(s) sin instalar en ${runner.roleSkills}: reinstalá el adaptador`)
+    }
+    if (stale.length) {
+      warnings.push(`${stale.length} cargo(s) desactualizados en ${runner.roleSkills}: reinstalá el adaptador`)
+    }
+  }
   const executable = spawnSync(
     'sh',
     ['-c', 'command -v "$1" >/dev/null 2>&1', 'runner-doctor', runner.command],
@@ -304,6 +365,7 @@ function install(root, name, output = console) {
       output.log(`✓ ${name}: instalado ${resolved.item.target}`)
     }
   }
+  installRoleSkills(root, runner, output)
   return runner
 }
 
@@ -323,6 +385,8 @@ module.exports = {
   install,
   legacyGuardWiring,
   pruneSupersededHooks,
+  roleCatalog,
+  roleSkill,
   listHooks,
   mergeConfig,
   runnerManifest,