@ingeniomaps/cauce 0.27.0 → 0.28.0

package/CHANGELOG.md

@@ -14,6 +14,41 @@ desde este repositorio no va, porque el que lee no puede actuar sobre eso. Cuand
 unas pocas líneas casi siempre es porque cuenta cómo se descubrió el problema o por qué se eligió el
 diseño — eso vive en el commit y en el código.
 
+## [0.28.0] - 2026-08-18
+
+### Añadido
+
+- **`/onboard`: el recorrido que llena una instancia recién creada.** `init` la deja funcionando y sin
+  enterar de nada —`organization/` es el molde y el roadmap está vacío—, y llenarlo exige leer el
+  repositorio y decidir qué es cada cosa, que es justo lo que un CLI determinista no puede hacer. El
+  recorrido inventaría los subproyectos con manifiesto propio, **corre** los comandos de test, lint y
+  build que cada uno declara, y escribe `organization/`, la sección «Mapa real» de `AGENTS.md` y las
+  raíces reales en `ops.config.json`.
+
+  Corre los comandos en vez de copiarlos del README porque un mapa copiado envejece sin avisar y el
+  primer Verify de una tarea real es donde aparece: cada comando queda como verificado, falla o ausente.
+  Lo que deduce va marcado «(supuesto)» y lo que nada sostiene queda «Por definir». No lee `.env` ni
+  ninguna credencial —de `.env.example` toma sólo los nombres de variable—, y las credenciales, los MCP
+  y el permiso de push salen como filas de `HUMAN_ACTIONS.md` con la acción concreta que las desbloquea,
+  sin proponer ningún valor. Cierra escribiendo la épica 001 —que una tarea pueda atravesar el ciclo
+  entero— y no la promueve.
+
+  Si la instancia ya tiene contexto escrito, para y pide `force`: reescribir un borrador que alguien
+  corrigió no deja rastro de lo que se perdió. Y un workspace todavía sin código no es un error: escribe
+  lo que el contexto permita y traer los repos pasa a ser la primera historia.
+
+  Claude y Antigravity lo reciben como recorrido ejecutable; Codex y Gemini lo operan desde la sección
+  «El arranque» que `automation install` deja en sus instrucciones. Si ya tenés una instancia, el
+  workflow llega con `automation install` —no con `upgrade`—: los workflows viven en el runner.
+
+### Corregido
+
+- **`init` dentro de una carpeta que ya nombra al toolkit deja de anidar.** Correrlo parado en
+  `acme-ops/` creaba `acme-ops/ops/` —una raíz ops dentro de otra— y llamaba «acme-ops» al proyecto.
+  Ahora la instancia es esa carpeta y el proyecto se llama «acme». Además un `.git` solo dejó de contar
+  como contenido, así que `mkdir acme-ops && git init && cauce init` no pide `--force` para no pisar
+  nada.
+
 ## [0.27.0] - 2026-08-18
 
 ### Añadido

package/README.md

@@ -96,9 +96,22 @@ falta igual —el motor, los guards y los workflows son JavaScript—.
 
 ### El primer ciclo
 
-Desde el runner, `/team` recorre un equipo y deja escrita una épica candidata en `planning/roadmap/`, y
-`/autobuild` toma una tarea ya promovida y la ejecuta fase por fase. Sin runner el recorrido es el
-mismo: la [tabla de comandos](#comandos) y [FLOW.md](template/planning/FLOW.md) lo operan a mano.
+`init` deja la instancia funcionando, no enterada: `organization/` llega como molde y el roadmap está
+vacío. Llenarlo exige leer el repositorio y decidir qué es cada cosa, que es lo que un CLI determinista
+no puede hacer, así que ese recorrido vive en el runner:
+
+```text
+/onboard    inventaría los servicios, corre sus comandos de test, lint y build, y escribe
+            organization/, el «Mapa real» de AGENTS.md y las raíces de ops.config.json.
+            Lo deducido queda marcado como supuesto; credenciales, MCP y el permiso de push
+            van a HUMAN_ACTIONS.md. Cierra con la épica 001, sin promoverla.
+/team       evalúa si una intención posterior es viable y propone su épica.
+/autobuild  ejecuta una tarea ya promovida, fase por fase.
+```
+
+Claude y Antigravity lo traen como recorrido ejecutable; Codex y Gemini lo operan siguiendo las
+instrucciones que `automation install` les deja. Sin runner, la [tabla de comandos](#comandos) y
+[FLOW.md](template/planning/FLOW.md) hacen el mismo camino a mano.
 
 Dentro del proyecto el CLI se invoca con `node tools/ops.js` —o `npx cauce`, que la dependencia deja
 disponible—; desde este repositorio, con `node engine/cli/ops.js`. En la tabla de abajo `ops` representa

package/automatization/runners/antigravity/manifest.json

@@ -39,6 +39,10 @@
     {
       "source": "skills/team/SKILL.md",
       "target": ".agents/plugins/cauce/skills/team/SKILL.md"
+    },
+    {
+      "source": "skills/onboard/SKILL.md",
+      "target": ".agents/plugins/cauce/skills/onboard/SKILL.md"
     }
   ],
   "capabilities": {

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

@@ -0,0 +1,30 @@
+---
+name: onboard
+description: Escanea el repositorio y deja escrito el contexto de la empresa y la primera épica.
+---
+
+Es el arranque de una instancia recién creada: `init` la instaló, pero nadie le explicó todavía qué es
+este proyecto. Antes de empezar comprobá que siga vacía —`{{OPS_DIR}}organization/company.md` con sus
+«Por completar» y `{{OPS_DIR}}planning/roadmap/` sin épicas—: reescribir un contexto que alguien ya
+corrigió no deja rastro de lo que se perdió.
+
+Inventariá los subproyectos con manifiesto propio, sin entrar en la raíz ops ni en `node_modules`. De cada
+uno tomá su ruta, para qué sirve y los comandos de test, lint y build que él mismo declara. **Corré esos
+comandos**: un mapa copiado del README envejece sin avisar y el primer Verify de una tarea real descubre
+que el comando no existe. Nunca corras migraciones, deploys ni publicaciones, aunque un script se llame
+así.
+
+Con eso escribí `{{OPS_DIR}}organization/company.md` y `product.md`, la sección «Mapa real» de
+`{{OPS_DIR}}AGENTS.md` con el resultado que obtuviste por comando, y las raíces reales en
+`workspaceRoots` de `{{OPS_DIR}}ops.config.json`, que es lo que un guard usa para bloquear una escritura
+fuera de lugar. Lo deducido va marcado `(supuesto)` y lo que nada sostiene queda «Por definir»: no
+inventes clientes, ingresos ni objetivos.
+
+Credenciales, MCP y el permiso de push no te corresponden. Cada uno va como fila en
+`{{OPS_DIR}}planning/HUMAN_ACTIONS.md` con la acción concreta que lo desbloquea y sin proponer ningún
+valor; las preguntas abiertas, a la sección Ideas de `{{OPS_DIR}}planning/INBOX.md`.
+
+Cerrá escribiendo `epic-001` en `{{OPS_DIR}}planning/roadmap/`: su resultado es que una tarea pueda
+atravesar el ciclo entero, y sus criterios salen de lo que hoy falta —contexto sin supuestos, cada
+comando en verde, el guard de límites probado en las dos direcciones, una tarea piloto en DONE—. Validá
+con `node {{OPS_DIR}}tools/ops.js check planning`. **Nunca promuevas al BACKLOG**: esa firma es humana.

package/automatization/runners/claude/CLAUDE.md

@@ -7,8 +7,9 @@
 @{{OPS_DIR}}planning/rules/system/commits.md
 @{{OPS_DIR}}planning/rules/system/conduct.md
 
-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
+Los hooks de `.claude/settings.json` son obligatorios. En una instancia recién creada, `/onboard` escanea el
+repositorio y deja escrito el contexto de la empresa y la primera épica. Después, `/team` evalúa si una
+intención es viable y propone una épica, y `/autobuild` ejecuta trabajo ya promovido; `/integration-sync` e
 `/integration-promote` gestionan staging local sin escritura remota. Ninguno promueve al BACKLOG.
 
 Antes de iniciar, respeta `{{OPS_DIR}}planning/AWAITING_REVIEW.md` y el mutex de `{{OPS_DIR}}planning/WIP.md`. Si el protocolo y

package/automatization/runners/claude/manifest.json

@@ -29,6 +29,10 @@
       "source": "../../workflows/team.js",
       "target": ".claude/workflows/team.js"
     },
+    {
+      "source": "../../workflows/onboard.js",
+      "target": ".claude/workflows/onboard.js"
+    },
     {
       "source": "../../workflows/agent-eval.js",
       "target": ".claude/workflows/agent-eval.js"

package/automatization/runners/codex/AGENTS.md

@@ -31,6 +31,20 @@ node {{OPS_DIR}}tools/ops.js agents list
 Leé el `SKILL.md` del cargo que corresponda antes de actuar en su terreno, y respetá sus límites. Lo que
 ese cargo debe saber de esta empresa está en `{{OPS_DIR}}organization/roles/<slug>.md`.
 
+## El arranque
+
+En una instancia recién creada nadie le explicó todavía al toolkit qué es este proyecto:
+`{{OPS_DIR}}organization/` llega como molde y el roadmap está vacío. El primer recorrido lo llena, y una vez: reescribir un contexto
+que alguien ya corrigió no deja rastro de lo que se perdió.
+
+Inventariá los subproyectos con manifiesto propio y **corré** los comandos de test, lint y build que cada
+uno declara —un mapa copiado del README envejece sin avisar—. Con eso escribí `{{OPS_DIR}}organization/`,
+la sección «Mapa real» de `{{OPS_DIR}}AGENTS.md` con el resultado por comando, y las raíces reales en
+`workspaceRoots`. Lo deducido va marcado `(supuesto)`. Credenciales, MCP y el permiso de push van como
+filas en `{{OPS_DIR}}planning/HUMAN_ACTIONS.md`, sin proponer valores. Cerrá con `epic-001` en
+`{{OPS_DIR}}planning/roadmap/`: que una tarea pueda atravesar el ciclo entero, con criterios que salen de
+lo que falta. Nunca la promuevas.
+
 ## Los equipos
 
 Un equipo es una secuencia de cargos con etapas y exit gates, para evaluar una intención antes de que

package/automatization/runners/gemini/GEMINI.md

@@ -24,6 +24,20 @@ node {{OPS_DIR}}tools/ops.js agents list
 node {{OPS_DIR}}tools/ops.js team list
 ```
 
+## El arranque
+
+En una instancia recién creada nadie le explicó todavía al toolkit qué es este proyecto:
+`{{OPS_DIR}}organization/` llega como molde y el roadmap está vacío. El primer recorrido lo llena, y una vez: reescribir un contexto
+que alguien ya corrigió no deja rastro de lo que se perdió.
+
+Inventariá los subproyectos con manifiesto propio y **corré** los comandos de test, lint y build que cada
+uno declara —un mapa copiado del README envejece sin avisar—. Con eso escribí `{{OPS_DIR}}organization/`,
+la sección «Mapa real» de `{{OPS_DIR}}AGENTS.md` con el resultado por comando, y las raíces reales en
+`workspaceRoots`. Lo deducido va marcado `(supuesto)`. Credenciales, MCP y el permiso de push van como
+filas en `{{OPS_DIR}}planning/HUMAN_ACTIONS.md`, sin proponer valores. Cerrá con `epic-001` en
+`{{OPS_DIR}}planning/roadmap/`: que una tarea pueda atravesar el ciclo entero, con criterios que salen de
+lo que falta. Nunca la promuevas.
+
 Nunca omitas aprobaciones, inventes credenciales, escribas remoto, hagas push/deploy o promociones
 trabajo desde INBOX.
 

package/automatization/workflows/onboard.js

@@ -0,0 +1,256 @@
+// Arranque de una instancia recién creada: convierte un repositorio que nadie le explicó al toolkit en
+// contexto escrito —`organization/`, el mapa real de `AGENTS.md`, las raíces de código— y en la primera
+// épica. Es el paso que `init` no puede dar: instalar es determinista, y leer un repositorio para decidir
+// qué es el producto, qué carpeta es legacy y cuál es el comando que de verdad lo valida, no lo es.
+//
+// Escribe borradores y no decide por nadie: cada dato deducido queda marcado como supuesto, las
+// credenciales y los sistemas externos van a HUMAN_ACTIONS —R12 se los prohíbe a un runner— y la épica
+// queda en roadmap/ sin promover, que sigue siendo la firma humana.
+export const meta = {
+  name: 'onboard',
+  description: 'Escanea el repositorio y deja escrito el contexto de la empresa y la primera épica',
+  whenToUse: 'Primera corrida después de "cauce init", cuando organization/ y el roadmap están vacíos.',
+  phases: [
+    { title: 'Scan', detail: 'Servicios, manifiestos y comandos declarados' },
+    { title: 'Verify', detail: 'Los comandos se corren: el mapa no se copia del README' },
+    { title: 'Draft', detail: 'organization/, mapa real, raíces y acciones humanas' },
+    { title: 'Epic', detail: 'La épica que deja al ciclo poder correr' },
+    { title: 'Closing', detail: 'check y lo que queda esperando a una persona' },
+  ],
+}
+
+// El prefijo lo completa `automation install`. Igual que en los demás workflows: el runtime no expone
+// `process`, así que la ruta de la raíz ops viaja escrita, relativa a donde se abre la herramienta.
+const ROOT = '{{OPS_DIR}}'.replace(/\/+$/, '') || '.'
+const P = `${ROOT}/planning`
+const ORG = `${ROOT}/organization`
+const HUMAN = `${P}/HUMAN_ACTIONS.md`
+const INBOX = `${P}/INBOX.md`
+const ROADMAP = `${P}/roadmap`
+
+// Lo que la persona ya sabe y no hace falta deducir: `/onboard vendemos ruteo a PYMEs de logística`.
+// Entra como contexto, no como verdad: lo que diga acá se escribe como hecho, y lo deducido no.
+const input = typeof args === 'string' ? { context: args } : (args || {})
+const CONTEXT = String(input.context || '').trim()
+const FORCE = Boolean(input.force)
+
+const BASE = `Nunca inventes clientes, métricas, ingresos, plazos ni responsables. Distinguí siempre lo ` +
+  `que verificaste corriendo algo, lo que leíste en un archivo del repositorio y lo que estás ` +
+  `suponiendo: lo tercero va marcado como "(supuesto)" en el texto que escribas. No leas archivos de ` +
+  `credenciales —.env, *.pem, claves— ni copies su contenido a ningún lado; .env.example sí, y sólo los ` +
+  `nombres de las variables. No escribas en ningún sistema externo, no conectes nada y no promuevas ` +
+  `trabajo al BACKLOG.`
+
+function finish(result) {
+  log(`Fin: ${JSON.stringify(result)}`)
+  return result
+}
+
+const stop = (reason, detail = '') => {
+  log(`Checkpoint: ${reason}${detail ? ` — ${detail}` : ''}`)
+  return finish({ stopped: true, reason, detail })
+}
+
+const STATE = {
+  type: 'object', additionalProperties: false, required: ['fresh'],
+  properties: {
+    fresh: { type: 'boolean' },
+    reason: { type: 'string' },
+    mode: { type: 'string' },
+    workspaceRoots: { type: 'array', items: { type: 'string' } },
+  },
+}
+
+const INVENTORY = {
+  type: 'object', additionalProperties: false, required: ['services'],
+  properties: {
+    services: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['path', 'runtime'], properties: {
+        path: { type: 'string' }, runtime: { type: 'string' }, purpose: { type: 'string' },
+        test: { type: 'string' }, lint: { type: 'string' }, build: { type: 'string' },
+        source: { type: 'string' },
+      } } },
+    legacy: { type: 'array', items: { type: 'string' } },
+    ci: { type: 'array', items: { type: 'string' } },
+    externals: { type: 'array', items: { type: 'string' } },
+    secrets: { type: 'array', items: { type: 'string' } },
+    productHints: { type: 'string' },
+  },
+}
+
+const CHECKED = {
+  type: 'object', additionalProperties: false, required: ['path', 'results'],
+  properties: {
+    path: { type: 'string' },
+    results: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['kind', 'command', 'status'], properties: {
+        kind: { type: 'string', enum: ['test', 'lint', 'build'] },
+        command: { type: 'string' },
+        // `ausente` es un resultado, no un fallo: un servicio sin lint declarado no tiene nada roto.
+        status: { type: 'string', enum: ['verificado', 'falla', 'ausente'] },
+        detail: { type: 'string' },
+      } } },
+  },
+}
+
+const WRITTEN = {
+  type: 'object', additionalProperties: false, required: ['files', 'assumptions'],
+  properties: {
+    files: { type: 'array', items: { type: 'string' } },
+    assumptions: { type: 'array', items: { type: 'string' } },
+    humanActions: { type: 'array', items: { type: 'string' } },
+    openQuestions: { type: 'array', items: { type: 'string' } },
+  },
+}
+
+phase('Scan')
+
+// Arrancar dos veces sobre la misma instancia reescribiría contexto que una persona ya corrigió, y el
+// borrador se lee igual que el original: nada delataría la pérdida. Se comprueba antes de leer nada más.
+const state = await agent(
+  `${BASE}\n\nFrom the workspace root, report whether this instance is still untouched. Read ` +
+  `${ROOT}/ops.config.json for its mode and workspaceRoots, ${ORG}/company.md and ${ORG}/product.md, and ` +
+  `list ${ROADMAP}. Set fresh=true only if the organization files still carry the mold's "Por completar" ` +
+  `or "Por definir" placeholders and the roadmap holds nothing but its template and README. Otherwise ` +
+  `set fresh=false and say in reason what is already written.`,
+  { schema: STATE, label: 'estado-inicial' },
+)
+if (!state) return stop('estado-desconocido', 'no se pudo leer el estado de la instancia')
+if (!state.fresh && !FORCE) {
+  return stop('ya-arrancado', `${state.reason || 'la instancia ya tiene contexto escrito'}. ` +
+    `Pasá force:true si querés reescribir los borradores.`)
+}
+
+const inventory = await agent(
+  `${BASE}\n\nInventariá el repositorio desde la raíz del workspace, sin entrar en ${ROOT}/ ni en ` +
+  `node_modules, vendor, dist o build. Para cada subproyecto con manifiesto propio —package.json, ` +
+  `go.mod, pyproject.toml, Cargo.toml, composer.json, pom.xml, Gemfile, Makefile, Dockerfile o ` +
+  `docker-compose— reportá su ruta relativa, el runtime, para qué parece servir, y los comandos de test, ` +
+  `lint y build que el propio proyecto declara, con source apuntando al archivo y la clave de donde los ` +
+  `sacaste. Un comando que no está declarado se omite: no lo adivines.\n\n` +
+  `Reportá además qué directorios parecen legacy o fuera de alcance, qué corre en CI, qué servicios ` +
+  `externos aparecen nombrados en configuración o dependencias, y qué credenciales espera el proyecto ` +
+  `—sólo los nombres de variable, leídos de .env.example o de la configuración de CI—. En productHints ` +
+  `resumí lo que el repositorio deja ver sobre qué se construye.` +
+  `${CONTEXT ? `\n\nLa persona ya aportó este contexto, que vale como hecho: ${CONTEXT}` : ''}`,
+  { schema: INVENTORY, label: 'inventario' },
+)
+if (!inventory) return stop('inventario-vacio', 'el escaneo no devolvió resultado')
+const services = inventory.services || []
+
+// Un workspace sin código no es un error: alguien puede estar preparando la carpeta antes de clonar los
+// repos, y `init` en un directorio vacío es un arranque legítimo. Lo que no puede es terminar sin nada
+// escrito: lo que sí se pueda establecer se escribe igual, y traer el código pasa a ser la primera
+// historia en vez de un checkpoint que no deja nada.
+const VACIO = services.length ? '' : `\n\nNo hay ningún subproyecto con manifiesto propio en el ` +
+  `workspace: el código todavía no está acá. Escribí igual lo que el contexto aportado permita, dejá el ` +
+  `mapa real declarado como pendiente diciendo qué lo completa, y que la primera historia de la épica sea ` +
+  `traer los repos y declararlos en workspaceRoots.`
+log(services.length
+  ? `${services.length} servicio(s): ${services.map((service) => service.path).join(', ')}`
+  : 'Sin servicios en el workspace: el arranque escribe lo que se pueda y deja el mapa pendiente.')
+
+phase('Verify')
+
+// Un mapa copiado del README envejece sin avisar y el primer Verify de una tarea real descubre que el
+// comando no existe. Correrlos acá es barato y es lo que separa "documentado" de "verificado".
+const checks = (await parallel(services.map((service) => () => agent(
+  `${BASE}\n\nFrom the workspace root, check the commands declared by the service at "${service.path}": ` +
+  `test=${service.test || '(ninguno)'}, lint=${service.lint || '(ninguno)'}, ` +
+  `build=${service.build || '(ninguno)'}. Run each one that exists, from that directory, and report what ` +
+  `happened: "verificado" when it finished green, "falla" with the first meaningful error line when it ` +
+  `did not, "ausente" when the service declares none. Never run migrations, deploys, publishes, or ` +
+  `anything that writes outside this repository, even if a script has that name: report it as ausente ` +
+  `and say why.`,
+  { schema: CHECKED, label: `verify:${service.path}`, phase: 'Verify' },
+)))).filter(Boolean)
+
+const green = checks.flatMap((entry) => entry.results.filter((result) => result.status === 'verificado')).length
+const broken = checks.flatMap((entry) => entry.results.filter((result) => result.status === 'falla'))
+log(`${green} comando(s) verificados, ${broken.length} con fallo. Un fallo no detiene el arranque: se escribe.`)
+
+phase('Draft')
+
+const EVIDENCE = `Inventario:\n${JSON.stringify(inventory)}\n\n` +
+  `Comandos comprobados:\n${JSON.stringify(checks)}${VACIO}` +
+  `${CONTEXT ? `\n\nContexto aportado por la persona, que vale como hecho: ${CONTEXT}` : ''}`
+
+const drafted = await agent(
+  `${BASE}\n\n${EVIDENCE}\n\nEscribí los borradores de contexto de esta instancia. Reemplazá el molde, no ` +
+  `lo comentes:\n` +
+  `1. ${ORG}/company.md y ${ORG}/product.md: lo que el repositorio y el contexto aportado permiten ` +
+  `afirmar. Lo deducido va marcado "(supuesto)"; lo que nada sostiene queda como "Por definir" y su ` +
+  `pregunta va a openQuestions. No inventes clientes, ingresos ni objetivos.\n` +
+  `2. La sección "## Mapa real" de ${ROOT}/AGENTS.md: una entrada por servicio con su ruta, para qué ` +
+  `sirve y sus comandos, cada uno con el resultado que obtuviste —verificado, falla o ausente—. Enlazá ` +
+  `la fuente en vez de duplicar documentación técnica, y nombrá lo legacy y lo fuera de alcance.\n` +
+  `3. ${ROOT}/ops.config.json: dejá en workspaceRoots las raíces de código reales. Es lo que un guard usa ` +
+  `para bloquear una escritura fuera de lugar, así que una raíz de más lo apaga.\n` +
+  `Devolvé en files cada archivo que tocaste y en assumptions cada supuesto que dejaste marcado.`,
+  { schema: WRITTEN, label: 'contexto' },
+)
+if (!drafted) return stop('draft-unavailable', 'los borradores no devolvieron resultado')
+
+// Credenciales, MCP y permiso de push no son trabajo del runner: R12 se los prohíbe y R13 exige dejar
+// dicho quién los resuelve y con qué. La fila vale más que la negativa.
+const pending = await agent(
+  `${BASE}\n\n${EVIDENCE}\n\nRegistrá en ${HUMAN} una fila por cada cosa que necesita a una persona, con ` +
+  `la tarea, el estado pendiente, el origen "onboard" y la acción concreta que la desbloquea. Como mínimo, ` +
+  `una por cada credencial que el proyecto espera —diciendo dónde se cargan en este proyecto y quién lo ` +
+  `hace, sin proponer ningún valor—, una por cada servicio externo o MCP a conectar —con su alcance y ` +
+  `contra qué entorno—, y una por la autoridad del runner: hoy ops.config.json declara ` +
+  `runner.allowPush=false y cambiarlo es una decisión humana. Las preguntas que quedaron abiertas van a ` +
+  `la sección Ideas de ${INBOX}, sin promover: ${JSON.stringify(drafted.openQuestions || [])}`,
+  { schema: WRITTEN, label: 'acciones-humanas' },
+)
+
+phase('Epic')
+
+const epic = await agent(
+  `${BASE}\n\n${EVIDENCE}\n\nSupuestos que quedaron escritos: ${JSON.stringify(drafted.assumptions || [])}\n` +
+  `Comandos que fallaron: ${JSON.stringify(broken)}\n\n` +
+  `Escribí en ${ROADMAP} la épica epic-001-<slug>.md siguiendo el contrato de ${P}/PROTOCOL.md: ` +
+  `frontmatter epic/title/status/service con status open, criterios **CN** observables, "## Contexto ` +
+  `relevante" con rutas verificadas, e historias con (→ CN) y (service: ruta), cada una de menos de ` +
+  `cuatro horas.\n\n` +
+  `Su resultado es que una tarea pueda atravesar el ciclo entero sin que nadie tenga que volver a ` +
+  `explicar este proyecto. Los criterios salen de lo que hoy falta y son verificables: que ` +
+  `organization/ no tenga supuestos sin confirmar, que cada servicio del mapa tenga su comando ` +
+  `corriendo en verde, que las raíces declaradas hagan que el guard de límites bloquee una escritura ` +
+  `afuera y deje pasar una adentro, y que una tarea piloto real llegue a DONE con evidencia. Si algún ` +
+  `comando falló, arreglarlo es una historia, no un criterio aparte. En "## Riesgos y decisiones ` +
+  `humanas" citá las filas que dejaste en HUMAN_ACTIONS. No toques BACKLOG.md.`,
+  { schema: { type: 'object', additionalProperties: false, required: ['file', 'criteria', 'stories'],
+    properties: {
+      file: { type: 'string' }, title: { type: 'string' },
+      criteria: { type: 'array', items: { type: 'string' } },
+      stories: { type: 'array', items: { type: 'string' } },
+    } }, label: 'epica-001' },
+)
+if (!epic) return stop('epic-unavailable', 'la épica no devolvió resultado')
+
+phase('Closing')
+
+const closing = await agent(
+  `${BASE}\n\nFrom ${ROOT}, run "node tools/ops.js check planning" and report whether it passed. If it ` +
+  `failed, repair only what this run wrote —the epic, the config— so it satisfies the contract; never ` +
+  `weaken a criterion to force green.`,
+  { schema: { type: 'object', additionalProperties: false, 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')
+
+const supuestos = (drafted.assumptions || []).length
+const acciones = ((pending || {}).humanActions || []).length
+log(`Contexto escrito con ${supuestos} supuesto(s) por confirmar y ${acciones} acción(es) humana(s) en ${HUMAN}.`)
+log(`Épica en ${epic.file}, sin promover: revisala, promoví una historia a un hito del BACKLOG y corré /autobuild.`)
+
+return finish({
+  services: services.length,
+  verified: green,
+  broken: broken.length,
+  assumptions: supuestos,
+  humanActions: acciones,
+  epic: epic.file,
+  promoted: false,
+})

package/engine/cli/ops.js

@@ -226,6 +226,15 @@ function evaluationBench(root, agent, caso, force) {
   return dir
 }
 
+// Dónde va la instancia cuando nadie eligió destino. Parada frecuente: el dev ya creó `acme-ops/` y
+// corre `init` adentro. Sin esto la instancia caía en `acme-ops/ops/` —una carpeta del toolkit dentro
+// de otra— y el proyecto quedaba llamándose «acme-ops». La carpeta que ya nombra al toolkit es la
+// instancia; no hay una segunda adentro.
+function implicitTarget(cwd) {
+  const base = path.basename(cwd)
+  return base === DEFAULT_TARGET || base.endsWith('-ops') ? '.' : DEFAULT_TARGET
+}
+
 // El nombre sale de la carpeta del proyecto, no de la que aloja la instancia: `ops/` y `acme-ops/`
 // nombran al toolkit, y quien lee `project` en la configuración espera leer «acme».
 function defaultName(root) {
@@ -268,12 +277,15 @@ async function init(target, cli) {
   // nivel deja de distinguir qué es suyo y qué llegó del toolkit. Es el layout que `automation
   // install` ya asume —el wiring del runner va al padre, donde se abre la herramienta—, así que lo
   // único que faltaba era que fuera lo que pasa cuando no se elige nada.
-  const root = path.resolve(target || DEFAULT_TARGET)
+  const root = path.resolve(target || implicitTarget(process.cwd()))
   const mode = cli.value('--mode', target ? 'embedded' : 'sidecar')
   if (!['embedded', 'sidecar'].includes(mode)) fail('--mode debe ser embedded o sidecar.', 2)
   const name = cli.value('--name', defaultName(root))
   const force = cli.has('--force')
-  const existing = fs.existsSync(root) ? fs.readdirSync(root) : []
+  // `.git` no cuenta como contenido: es lo único que hay en la carpeta que alguien acaba de crear y
+  // versionar para la instancia, y el toolkit no escribe nada adentro. Sin esta excepción el camino
+  // más natural —`mkdir acme-ops && git init && cauce init`— pedía `--force` para no pisar nada.
+  const existing = (fs.existsSync(root) ? fs.readdirSync(root) : []).filter((entry) => entry !== '.git')
   if (existing.length && !force) {
     fail(`El destino no está vacío: ${root}. Usa --force para agregar solo archivos faltantes.`)
   }
@@ -306,6 +318,14 @@ async function init(target, cli) {
 
   if (resultado.instalado) {
     check(path.join(root, 'planning'), SIN_BANDERAS)
+    // Una instancia recién instalada funciona y no sabe nada de este proyecto: `organization/` es el
+    // molde y el roadmap está vacío. Llenarlo exige leer el repositorio y decidir qué es cada cosa, que
+    // es justo lo que un CLI determinista no puede hacer; el recorrido vive en el runner, así que lo
+    // único útil acá es decir cuál es y con qué se abre.
+    if (resultado.runner !== BOOT.SIN_RUNNER) {
+      console.log(`  siguiente: abrí ${resultado.runner} en este directorio y corré /onboard`)
+      console.log('    escanea el repositorio y deja escrito el contexto de la empresa y la primera épica')
+    }
     console.log(`  listo: el ciclo empieza en ${path.join(relative || '.', 'planning', 'FLOW.md')}`)
   }
   for (const paso of initSteps(enter, resultado)) console.log(paso)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",