@ingeniomaps/cauce 0.1.0 → 0.3.0

package/automatization/hooks/run-hook.sh

@@ -4,13 +4,20 @@ set -u
 hook_name=${1:-}
 hook_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
 ops_root=$(CDPATH= cd -- "$hook_dir/../.." && pwd)
-runner="$ops_root/.ops/engine/hooks/run.js"
-[ -f "$runner" ] || runner="$ops_root/engine/hooks/run.js"
+# Mismo orden que tools/ops.js: primero la dependencia npm, después la copia local, y por último
+# el propio repositorio del toolkit. Un guard que no encuentra su motor bloquea, nunca permite.
+runner=""
+for candidate in \
+  "$ops_root/node_modules/@ingeniomaps/cauce/engine/hooks/run.js" \
+  "$ops_root/.ops/engine/hooks/run.js" \
+  "$ops_root/engine/hooks/run.js"
+do
+  if [ -f "$candidate" ]; then runner="$candidate"; break; fi
+done
 
-if [ ! -f "$runner" ]; then
+if [ -z "$runner" ]; then
   echo "BLOQUEADO [$hook_name]: no se encontró el motor de hooks de Cauce." >&2
-  echo "  Buscado en: $ops_root/.ops/engine/hooks/run.js" >&2
-  echo "           y: $ops_root/engine/hooks/run.js" >&2
+  echo "  Buscado en node_modules/@ingeniomaps/cauce, .ops/engine y engine/ bajo $ops_root" >&2
   exit 2
 fi
 

package/automatization/runners/antigravity/hook.js

@@ -29,7 +29,14 @@ function findRoot(input) {
 }
 
 function runtimeAt(root) {
-  const candidates = [path.join(root, '.ops', 'engine', 'hooks', 'run.js'), path.join(root, 'engine', 'hooks', 'run.js')]
+  // Mismo orden que tools/ops.js: dependencia npm, copia local, repositorio del toolkit.
+  const candidates = [
+    path.join(root, 'node_modules', '@ingeniomaps', 'cauce', 'engine', 'hooks', 'run.js'),
+    path.join(root, '.ops', 'engine', 'hooks', 'run.js'),
+    path.join(root, 'engine', 'hooks', 'run.js'),
+  ]
+  // El bridge corre antes de poder cargar el motor, así que repite la cascada de
+  // engine/core/ownership.js en vez de requerirla. Si cambia una, cambian las dos.
   const runtime = candidates.find(fs.existsSync)
   if (!runtime) throw new Error('No se encontró el runtime engine/hooks/run.js.')
   return require(runtime)

package/automatization/runners/antigravity/manifest.json

@@ -2,16 +2,51 @@
   "schemaVersion": 1,
   "name": "antigravity",
   "command": "agy",
-  "lifecycle": { "recommendedForNewProjects": true, "audience": "individual-and-new-google-projects" },
-  "config": { "source": "hooks.json", "target": ".agents/plugins/cauce/hooks.json" },
+  "lifecycle": {
+    "recommendedForNewProjects": true,
+    "audience": "individual-and-new-google-projects"
+  },
+  "config": {
+    "source": "hooks.json",
+    "target": ".agents/plugins/cauce/hooks.json"
+  },
   "instructions": [],
   "artifacts": [
-    { "source": "plugin.json", "target": ".agents/plugins/cauce/plugin.json" },
-    { "source": "hook.js", "target": ".agents/plugins/cauce/hook.js" },
-    { "source": "rules/cauce.md", "target": ".agents/plugins/cauce/rules/cauce.md" },
-    { "source": "skills/autobuild/SKILL.md", "target": ".agents/plugins/cauce/skills/autobuild/SKILL.md" },
-    { "source": "skills/integration-sync/SKILL.md", "target": ".agents/plugins/cauce/skills/integration-sync/SKILL.md" },
-    { "source": "skills/integration-promote/SKILL.md", "target": ".agents/plugins/cauce/skills/integration-promote/SKILL.md" }
+    {
+      "source": "plugin.json",
+      "target": ".agents/plugins/cauce/plugin.json"
+    },
+    {
+      "source": "hook.js",
+      "target": ".agents/plugins/cauce/hook.js"
+    },
+    {
+      "source": "rules/cauce.md",
+      "target": ".agents/plugins/cauce/rules/cauce.md"
+    },
+    {
+      "source": "skills/autobuild/SKILL.md",
+      "target": ".agents/plugins/cauce/skills/autobuild/SKILL.md"
+    },
+    {
+      "source": "skills/integration-sync/SKILL.md",
+      "target": ".agents/plugins/cauce/skills/integration-sync/SKILL.md"
+    },
+    {
+      "source": "skills/integration-promote/SKILL.md",
+      "target": ".agents/plugins/cauce/skills/integration-promote/SKILL.md"
+    },
+    {
+      "source": "skills/team/SKILL.md",
+      "target": ".agents/plugins/cauce/skills/team/SKILL.md"
+    }
   ],
-  "capabilities": { "nativeHooks": true, "nativeWorkflows": true, "projectInstructions": true, "checkpointing": false }
+  "capabilities": {
+    "nativeHooks": true,
+    "nativeWorkflows": true,
+    "projectInstructions": true,
+    "checkpointing": false,
+    "nativeSkills": true
+  },
+  "roleSkills": ".agents/plugins/cauce/skills"
 }

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/autobuild.js

@@ -2,10 +2,10 @@
 // Descubre proyecto, servicios y límites desde ops.config.json; no codifica rutas ni proveedores.
 export const meta = {
   name: 'autobuild',
-  description: 'Triage → Pick → Ready → Plan → Build → Review → Verify → QA → Commit → Done',
+  description: 'Triage → Pick → Cast → Ready → Plan → Build → Review → Verify → QA → Commit → Done',
   whenToUse: 'Ejecutar un hito aprobado con recuperación por WIP y checkpoint humano entre hitos.',
   phases: [
-    'Triage', 'Pick', 'Ready', 'Decompose', 'Plan', 'Critique', 'Build', 'Review',
+    'Triage', 'Pick', 'Cast', 'Ready', 'Decompose', 'Plan', 'Critique', 'Build', 'Review',
     'Verify', 'QA', 'Commit', 'Done', 'Closing',
   ].map((title) => ({ title, detail: `Fase ${title} del protocolo agnóstico` })),
 }
@@ -81,6 +81,31 @@ const COMMIT = {
     branch: { type: 'string' }, leftovers: { type: 'array', items: { type: 'string' } }, reason: { type: 'string' },
   },
 }
+// Dueño por defecto de cada fase. Es determinista: no hace falta preguntarle a un modelo quién
+// revisa la arquitectura o quién decide si la evidencia de calidad alcanza.
+const OWNERS = {
+  ready: 'product-manager',
+  plan: 'software-architect',
+  review: 'software-architect',
+  verify: 'qa-engineer',
+  qa: 'qa-engineer',
+  commit: 'release-manager',
+}
+
+const CAST_RULES = 'Elegís quién trabaja, no qué se hace. No inventes slugs: usá sólo los que ' +
+  'devuelve el CLI. Un cargo se suma por riesgo, plataforma o alcance, nunca por rutina.'
+
+const CAST = {
+  type: 'object', additionalProperties: false, required: ['build'],
+  properties: {
+    build: { type: 'string' },
+    review: { type: 'array', items: { type: 'string' } },
+    verify: { type: 'array', items: { type: 'string' } },
+    qa: { type: 'array', items: { type: 'string' } },
+    reason: { type: 'string' },
+  },
+}
+
 const CONTRACT = {
   type: 'object', additionalProperties: false,
   required: ['project', 'workspaceRoots', 'maxTaskHours', 'commitPerTask', 'humanCheckpoint', 'contracts'],
@@ -164,11 +189,41 @@ while (safety++ < 50) {
   const direct = planning.lane === 'directo'
   const lite = planning.lane === 'lite'
 
+  // Quién ejecuta cada fase. Los dueños por defecto son fijos y no gastan una llamada; los
+  // condicionales entran por riesgo, plataforma y alcance —nunca por rutina—, que es la misma
+  // regla que ya usa el team. En `directo` no hay condicionales: el lane baja ceremonia.
+  const cast = { ...OWNERS, build: '' }
+  if (!direct) {
+    phase('Cast')
+    const chosen = await read(
+      `${CAST_RULES}\n\nTarea ${task.id} en ${task.service}. Aceptación: ${task.acceptance}.\n` +
+      `Run "node tools/ops.js agents list ${ROOT} --json" and choose only from the slugs it lists.\n` +
+      `Elegí el cargo que implementa según la plataforma del servicio${lite ? '.' : ', y los cargos ' +
+      'condicionales que la superficie realmente justifica: seguridad si toca autenticación, permisos, ' +
+      'criptografía o datos sensibles; privacidad si toca datos personales; sre si toca disponibilidad, ' +
+      'límites o despliegue; ux si cambia una superficie que usa una persona; y el que corresponda a ' +
+      'datos o modelos si los toca. Dejá vacío lo que no aplique: sumar un cargo que no aporta es ruido ' +
+      'que diluye la revisión.'}`,
+      { schema: CAST, label: 'cast' },
+    )
+    if (chosen) {
+      cast.build = chosen.build || ''
+      for (const key of ['review', 'verify', 'qa']) {
+        cast[key] = [OWNERS[key], ...(lite ? [] : chosen[key] || [])].filter(Boolean).join(', ')
+      }
+      log(`Cargos: build=${cast.build || '(sin asignar)'} · review=${cast.review} · qa=${cast.qa}`)
+    }
+  }
+  const asRole = (slugs) => (slugs
+    ? `Actuá como ${slugs}, respetando el contrato de cada uno en su SKILL.md bajo agents/ y sus ` +
+      `límites: un cargo que no puede decidir solo, no decide solo.\n\n`
+    : '')
+
   if (!planning.wipActive) {
     phase('Ready')
     const ready = await read(
-      `As product manager, check concrete acceptance, dependencies and unresolved decisions for ${task.id}: ${task.acceptance}. ` +
-      `Clarify wording only; never expand scope.`, { schema: READY },
+      `${asRole(OWNERS.ready)}Check concrete acceptance, dependencies and unresolved decisions for ${task.id}: ` +
+      `${task.acceptance}. Clarify wording only; never expand scope.`, { schema: READY },
     )
     if (!ready.ready) {
       await write(`Register ${task.id} in ${HUMAN} with reason and an exact human action: ${ready.reason}.`)
@@ -192,7 +247,8 @@ while (safety++ < 50) {
 
     phase('Plan')
     let plan = await run(
-      `Inspect real code, repository instructions, neighbouring conventions, epic context and git status for ${task.id}. ` +
+      `${asRole(OWNERS.plan)}Inspect real code, repository instructions, neighbouring conventions, epic context ` +
+      `and git status for ${task.id}. ` +
       `Produce the smallest plan satisfying ${task.acceptance}. Planning files cannot be implementation files.`, { schema: PLAN },
     )
     if (!direct && !lite) {
@@ -209,13 +265,16 @@ while (safety++ < 50) {
     }
     await write(
       `Persist active WIP before code: task=${task.id}, hito=${JSON.stringify(task.hito)}, phase=Build, service=${task.service}, ` +
-      `acceptance=${JSON.stringify(task.acceptance)}, unchecked steps=${JSON.stringify(plan.steps)}. Follow the WIP contract exactly.`,
+      `acceptance=${JSON.stringify(task.acceptance)}, unchecked steps=${JSON.stringify(plan.steps)}. ` +
+      `Registrá además el reparto de cargos ${JSON.stringify(cast)} en las decisiones del WIP, para que ` +
+      `después se pueda auditar quién revisó qué. Follow the WIP contract exactly.`,
     )
   }
 
   phase('Build')
   const build = await run(
-    `Implement only ${task.id} inside ${task.service}. Resume at the first pending WIP step; verify completed steps on disk ` +
+    `${asRole(cast.build)}Implement only ${task.id} inside ${task.service}. Resume at the first pending WIP ` +
+    `step; verify completed steps on disk ` +
     `and tick each successful step. Use RED/GREEN for behavior. Acceptance: ${task.acceptance}.`, {
       schema: { type: 'object', required: ['completed', 'summary'], properties: {
         completed: { type: 'boolean' }, summary: { type: 'string' }, blockers: { type: 'array', items: { type: 'string' } },
@@ -227,7 +286,8 @@ while (safety++ < 50) {
   if (!direct) {
     phase('Review')
     let review = await run(
-      `Review the actual diff for acceptance, regressions, security, architecture, generated code, migrations and accidental scope.`,
+      `${asRole(cast.review)}Review the actual diff for acceptance, regressions, security, architecture, ` +
+      `generated code, migrations and accidental scope. Cada cargo revisa su dominio, no el ajeno.`,
       { schema: DECISION },
     )
     if (!review.approved) {
@@ -239,14 +299,15 @@ while (safety++ < 50) {
 
   phase('Verify')
   const verified = await run(
-    `Discover and run the real gates for ${task.service}: repository instructions first, then applicable test, lint, ` +
+    `${asRole(cast.verify)}Discover and run the real gates for ${task.service}: repository instructions first, ` +
+    `then applicable test, lint, ` +
     `typecheck and build. Read actual exit codes. passed=true needs commands and no task-caused regression.`, { schema: VERIFY },
   )
   if (!verified.passed || !verified.commands.length) return stop('verify-failed', verified.details)
 
   phase('QA')
   const qa = await run(
-    `${direct || lite ? 'Perform the cheapest real acceptance check' : 'Exercise real consumer-visible behavior'} for ` +
+    `${asRole(cast.qa)}${direct || lite ? 'Perform the cheapest real acceptance check' : 'Exercise real consumer-visible behavior'} for ` +
     `${task.id}. Unit tests alone are not QA. Start only minimum runtime and tear it down. Acceptance: ${task.acceptance}.`,
     { schema: QA },
   )
@@ -254,7 +315,8 @@ while (safety++ < 50) {
 
   phase('Commit')
   const commit = contract.commitPerTask ? await run(
-    `Find the git repo owning ${task.service}, inspect status/diff, stage explicit task files, create one Conventional ` +
+    `${asRole(OWNERS.commit)}Find the git repo owning ${task.service}, inspect status/diff, stage explicit task ` +
+    `files, create one Conventional ` +
     `Commit with footer "Task: ${task.id}", then verify log/status. Never amend or push; report unrelated leftovers.`,
     { schema: COMMIT },
   ) : { committed: true, reason: 'runner.commitPerTask is disabled' }

package/automatization/workflows/team.js

@@ -0,0 +1,225 @@
+// 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 REPORTS = `${P}/reports`
+
+// Tres formas de invocarlo, porque escribir JSON en un slash command no es razonable:
+//
+//   /team quiero cobrar con tarjeta                    equipo por defecto
+//   /team feasibility-review: quiero cobrar con tarjeta   equipo elegido por prefijo
+//   /team {"team": "acme-soporte", "intent": "..."}    argumentos estructurados
+//
+// El prefijo se toma como candidato y se confirma más abajo contra los equipos que existen: si no es
+// uno, el texto completo era la intención y nadie tuvo que aprenderse una sintaxis.
+const input = typeof args === 'string' ? { intent: args } : (args || {})
+const raw = String(input.intent || process.env.OPS_INTENT || '').trim()
+const prefix = raw.match(/^([a-z][a-z0-9-]*)\s*:\s*(.+)$/s)
+const CANDIDATE = String(input.team || process.env.OPS_TEAM || (prefix ? prefix[1] : '') || 'product-development')
+const INTENT = (input.team || !prefix ? raw : prefix[2]).trim()
+
+const MANIFEST = {
+  type: 'object', additionalProperties: false, required: ['name', 'purpose', 'stages', 'guardrails'],
+  properties: {
+    name: { type: 'string' }, purpose: { type: 'string' },
+    outcome: { type: 'string', enum: ['epic', 'report'] },
+    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' },
+      phase: { type: 'string', enum: ['discovery', 'delivery'] },
+      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 resolved = await agent(
+  `${BASE}\n\nRun "node tools/ops.js team list" from ${ROOT}. Report whether "${CANDIDATE}" is one of ` +
+  `the slugs it printed, and the full list. Do not guess: report only what the command printed.`,
+  { schema: { type: 'object', required: ['exists', 'teams'], properties: {
+    exists: { type: 'boolean' }, teams: { type: 'array', items: { type: 'string' } },
+  } }, label: 'team-resolve' },
+)
+if (!resolved) return stop('teams-unavailable', 'no se pudo listar los equipos')
+if (!resolved.exists && (input.team || process.env.OPS_TEAM)) {
+  return stop('equipo-inexistente', `${CANDIDATE} no existe. Disponibles: ${resolved.teams.join(', ')}`)
+}
+// El prefijo era parte de la intención, no un equipo: se recompone y sigue con el equipo por defecto.
+const TEAM = resolved.exists ? CANDIDATE : 'product-development'
+const GOAL = resolved.exists ? INTENT : raw
+if (!resolved.exists && prefix) log(`"${CANDIDATE}" no es un equipo: se toma el texto completo como intención.`)
+
+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, outcome, entryAgent, facilitator, guardrails, the stages with id, phase, ` +
+  `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: ${GOAL}`
+
+phase('Stages')
+
+const handoffs = []
+const blocked = []
+// Sólo descubrimiento: este recorrido propone trabajo, no lo ejecuta. Las etapas de entrega las
+// corre `autobuild`, y sólo después de que una persona promueva la épica al BACKLOG.
+const discovery = contract.stages.filter((stage) => stage.phase === 'discovery')
+if (!discovery.length) return stop('sin-descubrimiento', `${TEAM} no declara etapas de discovery`)
+for (const stage of discovery) {
+  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')
+
+// Un recorrido que registra lo aprendido no propone trabajo: deja el informe y las tareas de
+// seguimiento en el INBOX, donde una persona decide si alguna merece convertirse en épica.
+if (contract.outcome === 'report') {
+  const report = await agent(
+    `${RULES}\n\nHandoffs completos:\n${JSON.stringify(handoffs)}\n\nEscribí el informe en ${REPORTS} como ` +
+    `<AAAA-MM-DD>-<slug>.md: qué pasó, qué se sabe con evidencia, qué se supone, qué se decidió y qué ` +
+    `queda abierto. Separá causa de síntoma y no atribuyas responsabilidad a personas. Registrá cada ` +
+    `seguimiento en la sección Lecciones de ${INBOX}, sin promoverlo, y toda acción que requiera una ` +
+    `persona en ${HUMAN}.`,
+    { schema: { type: 'object', required: ['file', 'followUps'], properties: {
+      file: { type: 'string' }, followUps: { type: 'integer' }, summary: { type: 'string' },
+    } }, label: 'report-write' },
+  )
+  if (!report) return stop('report-unavailable', 'el informe no devolvió resultado')
+  log(`Informe en ${report.file}. ${report.followUps} seguimiento(s) en el INBOX, sin promover.`)
+  return finish({ team: TEAM, stages: handoffs.length, report: report.file, promoted: false })
+}
+
+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 })