@ingeniomaps/cauce 0.28.0 → 0.30.0

package/CHANGELOG.md

@@ -14,6 +14,85 @@ 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.30.0] - 2026-08-18
+
+### Añadido
+
+- **`ops onboard`: qué le falta a una instancia para arrancar, y con qué pregunta empezar.** Determinista
+  y en milisegundos: dice si la instancia sigue vacía, qué hay en el workspace y qué queda por cubrir.
+  `init` lo imprime al terminar, que es donde mira quien acaba de instalar y todavía no sabe qué hace la
+  herramienta. Cuando `organization/` o el roadmap ya tienen contenido real no ofrece nada, porque habría
+  trabajo que pisar.
+
+### Cambiado
+
+- **El arranque pregunta en vez de negarse, y pregunta primero.** Invocado sin contexto, `/onboard`
+  terminaba diciendo «volvé a correrlo con contexto» —y gastaba un subagente para decirlo—. Ahora la
+  primera línea es la pregunta, sea el workspace vacío, un monorepo o diez repos, y el inventario viene
+  después: de qué trata el proyecto no depende de lo que haya en el disco. Cada runner recibe la
+  instrucción de abrir con esa pregunta antes de mirar nada.
+
+- **El recorrido tiene techo: una llamada cuando falta contexto, tres cuando hay con qué escribir.** Y
+  ninguna sale a explorar —tiene prohibido recorrer directorios, leer código fuente y abrir archivos que
+  no vaya a escribir—, porque lo que necesita ya está resuelto: un arranque que te hace esperar diez
+  minutos dejó de ser un arranque.
+
+- **El escaneo mira las raíces declaradas en `ops.config.json`, y nada por encima.** Antes suponía la
+  carpeta madre en modo sidecar; ahora acotar `workspaceRoots` acota también lo que se lee, que es más
+  rápido y es lo único que alguien autorizó.
+
+- **Y saltea lo que tu proyecto ya declaró basura.** Además de los directorios de paquetes y de los
+  ocultos, lee el `.gitignore` de cada raíz y omite los nombres de directorio que encuentre ahí. Los
+  interpreta de forma ancha —por nombre, a cualquier profundidad, salteando todo patrón con comodín—:
+  alcanza para decidir si vale la pena mirar adentro, y no es un parser de gitignore. Las listas largas
+  se recortan a veinte en pantalla diciendo cuántas quedaron afuera; `--json` las trae todas.
+
+- **El arranque declara para qué es.** Entender qué es el proyecto, dejar la instancia correcta para él y
+  que la primera tarea pueda empezar: eso, y nada más. El análisis profundo llega cuando alguien pide
+  algo concreto, y adelantarlo retrasa el único momento en que la herramienta todavía no sirve para nada.
+  Está escrito en cada prompt del recorrido y en las instrucciones de los cuatro runners.
+
+- **Las preguntas dejan de ser un formulario, y de dar por sentado que el proyecto vende algo.** Antes
+  eran cuatro fijas, y la primera preguntaba qué vende la empresa y a quién: a un proyecto libre, interno
+  o sin fines de lucro le pedían una respuesta que nadie había dado. Ahora hay una sola pregunta escrita
+  —de qué trata el proyecto, la única que no depende de ninguna respuesta— y lo que el motor fija después
+  son las dimensiones a cubrir: a quién sirve, cómo se sostiene, qué querés que pase, qué está fuera de
+  alcance, qué externos hay que conectar. Quien conduce la conversación las formula con las palabras de
+  ese proyecto, una por vez y hasta tres.
+
+- **El molde de `organization/company.md` deja de asumir un negocio.** «Modelo de negocio», «quién paga»
+  y «fuentes de ingreso» pasan a ser «De qué se trata», «A quién sirve» y «Cómo se sostiene», que nombra
+  donación, presupuesto interno y trabajo voluntario junto con la venta. Lo que no aplica se dice, no se
+  completa con algo plausible. Afecta a las instancias nuevas: `upgrade` sólo reemplaza `system/`, así
+  que el archivo que ya escribiste sigue siendo tuyo.
+
+## [0.29.0] - 2026-08-18
+
+### Añadido
+
+- **`ops scan`: qué hay en el workspace, resuelto por código.** Lista los subproyectos con manifiesto
+  propio, su runtime y los comandos de test, lint y build que cada uno declara, diciendo de qué archivo
+  salió cada comando. No corre ninguno y no inventa ninguno: un comando que nadie declaró se lee igual
+  que uno real, y el primer Verify de una tarea es donde eso se descubre. Saltea `node_modules` y todo
+  directorio oculto, que es lo que lo mantiene en milisegundos. Una instancia sidecar escanea su carpeta
+  madre, donde vive el código; cualquier otro modo, donde está parada.
+
+### Cambiado
+
+- **`/onboard` cuesta lo que encuentra.** Empezaba pidiéndole a un agente que explorara el repositorio y
+  terminaba corriendo la suite de tests de cada servicio: una corrida sobre una carpeta vacía gastó doce
+  minutos sin poder producir nada. Ahora arranca con `ops scan` —una llamada, milisegundos— y, si el
+  workspace no tiene código y nadie aportó contexto, termina ahí diciendo qué le falta, en vez de escribir
+  una empresa inventada.
+
+  El recorrido ya no ejecuta nada del proyecto. El mapa real anota cada comando **tal como está
+  declarado**, con su archivo de origen, y verificarlo corriéndolo pasa a ser una historia de la épica
+  001, donde tiene dueño y tiempo asignado. Lo que escribe y lo que deja a una persona no cambió:
+  borradores marcados como supuestos, credenciales y MCP en `HUMAN_ACTIONS.md`, épica sin promover.
+
+  Si ya tenés una instancia, el recorrido actualizado llega con `automation install`, no con `upgrade`:
+  los workflows viven en el runner.
+
 ## [0.28.0] - 2026-08-18
 
 ### Añadido

package/README.md

@@ -41,7 +41,24 @@ instala la dependencia, deja el wiring del runner puesto y valida la instancia a
 · npm install (el motor viene de la dependencia)
 ✓ claude: adaptador operativo (0 advertencia(s))
 ✓ planning válido: 0 épica(s), 0 tarea(s) en cola, 0 terminada(s)
-  listo: el ciclo empieza en ops/planning/FLOW.md
+
+2 servicio(s) en /home/vos/mi-repo: apps/api, apps/web
+
+¿De qué trata este proyecto? Una línea alcanza.
+
+Según lo que contestes salen hasta 3 preguntas más, con las palabras de
+este proyecto, hasta cubrir lo que haga falta de esto:
+
+  · a quién sirve y quién lo usa
+  · cómo se sostiene: venta, suscripción, donación, presupuesto interno o trabajo voluntario
+  · qué querés que pase en este período y cómo se va a notar
+  · qué servicios o carpetas están muertos o fuera de alcance
+  · qué sistema externo o MCP hace falta conectar, y contra qué entorno
+
+Mientras tanto, esto es lo que hay: apps/api, apps/web
+
+Abrí claude en este directorio para que las escriba por vos.
+El ciclo empieza en ops/planning/FLOW.md.
 ```
 
 El default de las dos preguntas es no hacer nada: instalar un runner escribe en tu repositorio y
@@ -101,10 +118,13 @@ vacío. Llenarlo exige leer el repositorio y decidir qué es cada cosa, que es l
 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.
+/onboard    te pregunta de qué trata el proyecto y, según lo que contestes, hasta tres más
+            con las palabras de ese proyecto —no un formulario que da por sentado que vendés
+            algo—. Con tus respuestas 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. No corre nada del
+            proyecto: verificar los comandos es una historia de esa épica.
 /team       evalúa si una intención posterior es viable y propone su épica.
 /autobuild  ejecuta una tarea ya promovida, fase por fase.
 ```
@@ -141,6 +161,8 @@ Lee [template/planning/PROTOCOL.md](template/planning/PROTOCOL.md) para el contr
 | Comando | Función |
 |---|---|
 | `ops init [destino]` | Materializa una instancia y la deja usable; sin destino, en `ops/` y modo sidecar. |
+| `ops scan [workspace]` | Inventaría servicios y comandos declarados, sin correr ninguno. |
+| `ops onboard [ops-root]` | Dice qué falta para arrancar y con qué pregunta empezar. |
 | `ops check <planning>` | Valida contratos, unicidad, trazabilidad y estados. |
 | `ops tree <planning>` | Muestra roadmap, backlog, WIP, inbox y done sin mutar nada. |
 | `ops context <planning>` | Emite el contexto mínimo de la tarea vigente para un runner. |

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

@@ -4,15 +4,25 @@ description: Escanea el repositorio y deja escrito el contexto de la empresa y l
 ---
 
 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ó.
+este proyecto.
 
-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í.
+Empezá por `node {{OPS_DIR}}tools/ops.js onboard`, que es instantáneo y te dice tres cosas: si la
+instancia sigue vacía, qué hay en el workspace y con qué pregunta empezar. Si ya tiene contexto escrito,
+no la pises: reescribir lo que alguien corrigió no deja rastro de lo que se perdió.
+
+La conversación empieza por una sola pregunta —de qué trata el proyecto, la primera línea que ese comando
+imprime— y la hacés antes de mirar el inventario, sea el workspace vacío, un monorepo o diez repos.
+Sigue según lo que conteste: hasta tres más, formuladas con las palabras de ese proyecto, hasta cubrir
+las dimensiones que el comando haya listado. Una por vez, esperando respuesta. El inventario ya viene
+resuelto: no recorras el árbol ni leas código para completarlo. No des por sentado que vende algo: puede sostenerse con
+donaciones, presupuesto interno o trabajo voluntario, y preguntarle a un proyecto libre quién le paga es
+empezar por una respuesta que nadie dio.
+
+El inventario no lo hagas a mano: `node {{OPS_DIR}}tools/ops.js scan --json` devuelve los subproyectos con
+manifiesto propio, su runtime y los comandos que cada uno declara, con el archivo del que salieron.
+Recorrer directorios es determinista y cuesta milisegundos; explorarlo vos cuesta minutos y encuentra lo
+mismo. No corras ningún comando del proyecto: el mapa dice lo que está declarado y de dónde, y
+verificarlo corriéndolo es una historia de la épica, con dueño y tiempo asignado.
 
 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
@@ -24,6 +34,10 @@ Credenciales, MCP y el permiso de push no te corresponden. Cada uno va como fila
 `{{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`.
 
+El arranque tiene tres objetivos y ninguno más: entender qué es el proyecto, dejar la instancia correcta
+para él y que la primera tarea pueda empezar. El análisis profundo viene después, cuando la persona pida
+algo concreto.
+
 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á

package/automatization/runners/claude/CLAUDE.md

@@ -7,8 +7,16 @@
 @{{OPS_DIR}}planning/rules/system/commits.md
 @{{OPS_DIR}}planning/rules/system/conduct.md
 
-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
+Los hooks de `.claude/settings.json` son obligatorios. En una instancia recién creada, empezá corriendo
+`node {{OPS_DIR}}tools/ops.js onboard`: es instantáneo, y lo primero que imprime es la pregunta con la que
+tenés que abrir —de qué trata el proyecto—. Hacésela tal cual, antes de mirar el inventario y sea el
+workspace vacío, un monorepo o diez repos. Recién con esa respuesta formulá hasta tres más, con las
+palabras de ese proyecto y una por vez, hasta cubrir las dimensiones que haya listado. El inventario ya
+viene resuelto en esa salida: no recorras el árbol ni leas código para completarlo. No des por sentado que vende
+algo: puede sostenerse con donaciones, presupuesto interno o trabajo voluntario. Con las respuestas invocá
+`/onboard <lo que te contó>`, que escribe el contexto y la primera épica; invocarlo antes sólo devuelve la
+misma pregunta más caro. El arranque busca entender qué es el proyecto y dejar la instancia correcta para
+él, no auditarlo: el análisis profundo viene después, cuando se pida algo concreto. 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.
 

package/automatization/runners/codex/AGENTS.md

@@ -37,14 +37,22 @@ En una instancia recién creada nadie le explicó todavía al toolkit qué es es
 `{{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
+Empezá por `node {{OPS_DIR}}tools/ops.js onboard`, que es instantáneo: la primera línea que imprime es la
+pregunta con la que tenés que abrir —de qué trata el proyecto—, y después vienen el inventario y las
+dimensiones. Hacé esa pregunta tal cual antes de mirar nada, sea el workspace vacío, un monorepo o diez
+repos, y según lo que conteste formulá hasta tres más con las palabras de ese proyecto, una por vez. El
+inventario ya viene resuelto ahí: no recorras el árbol ni leas código para completarlo. No des por
+sentado que vende algo: puede sostenerse con donaciones, presupuesto interno o trabajo voluntario. Con eso escribí `{{OPS_DIR}}organization/`, la sección «Mapa real» de
+`{{OPS_DIR}}AGENTS.md` con cada comando tal como está declarado y de qué archivo salió —sin correrlo—, 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.
 
+El arranque tiene tres objetivos y ninguno más: entender qué es el proyecto, dejar la instancia correcta
+para él y que la primera tarea pueda empezar. El análisis profundo viene después, cuando la persona pida
+algo concreto.
+
 ## 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

@@ -30,14 +30,22 @@ En una instancia recién creada nadie le explicó todavía al toolkit qué es es
 `{{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
+Empezá por `node {{OPS_DIR}}tools/ops.js onboard`, que es instantáneo: la primera línea que imprime es la
+pregunta con la que tenés que abrir —de qué trata el proyecto—, y después vienen el inventario y las
+dimensiones. Hacé esa pregunta tal cual antes de mirar nada, sea el workspace vacío, un monorepo o diez
+repos, y según lo que conteste formulá hasta tres más con las palabras de ese proyecto, una por vez. El
+inventario ya viene resuelto ahí: no recorras el árbol ni leas código para completarlo. No des por
+sentado que vende algo: puede sostenerse con donaciones, presupuesto interno o trabajo voluntario. Con eso escribí `{{OPS_DIR}}organization/`, la sección «Mapa real» de
+`{{OPS_DIR}}AGENTS.md` con cada comando tal como está declarado y de qué archivo salió —sin correrlo—, 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.
 
+El arranque tiene tres objetivos y ninguno más: entender qué es el proyecto, dejar la instancia correcta
+para él y que la primera tarea pueda empezar. El análisis profundo viene después, cuando la persona pida
+algo concreto.
+
 Nunca omitas aprobaciones, inventes credenciales, escribas remoto, hagas push/deploy o promociones
 trabajo desde INBOX.
 

package/automatization/workflows/onboard.js

@@ -1,26 +1,33 @@
 // 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.
+// épica.
 //
-// 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.
+// El orden importa y se pagó caro: la primera versión le pedía a un agente que «inventariara el
+// repositorio», y en una carpeta vacía eso gastó doce minutos para no encontrar nada. Recorrer el árbol
+// es determinista y lo hace `ops onboard` en milisegundos; el modelo entra después, y sólo si hay algo
+// sobre lo que decidir.
+//
+// De ahí el techo: una llamada cuando falta contexto y tres cuando hay con qué escribir. No son fases
+// separadas por prolijidad —escribir el contexto y registrar lo que le toca a una persona salen de la
+// misma evidencia, así que salen juntas—, y ninguna sale a explorar: un arranque que hace esperar diez
+// minutos ya no es un arranque.
+//
+// Escribe borradores y no decide por nadie: lo 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 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',
+  description: 'Inventaría el workspace 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' },
+    { title: 'Scan', detail: 'Estado e inventario, resueltos por el CLI y no por un modelo' },
+    { title: 'Draft', detail: 'organization/, mapa real, raíces y acciones humanas, de una pasada' },
+    { title: 'Epic', detail: 'La épica que deja al ciclo poder correr, y su check' },
   ],
 }
 
-// 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.
+// El prefijo lo completa `automation install`: 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`
@@ -28,18 +35,25 @@ 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.
+// Lo que la persona ya sabe y el repositorio no puede decir: `/onboard vendemos ruteo a PYMEs de
+// logística`. Entra como hecho; lo que se deduce, 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.`
+const BASE = `Nunca inventes clientes, métricas, ingresos, plazos ni responsables. Distinguí lo que leíste ` +
+  `en un archivo de lo que estás suponiendo: lo segundo va marcado "(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 corras comandos del proyecto: este recorrido ` +
+  `no ejecuta nada. No escribas en ningún sistema externo y no promuevas trabajo al BACKLOG.\n\n` +
+  `Trabajá con lo que ya tenés: el inventario que devolvió el comando y lo que contestó la persona. No ` +
+  `recorras directorios, no leas código fuente y no abras más archivos que los que vas a escribir. Esto ` +
+  `es un arranque de cinco minutos, no una auditoría: lo que no esté a la vista se marca como supuesto o ` +
+  `queda como pregunta abierta, que es más barato y más honesto que averiguarlo.\n\n` +
+  `El arranque tiene tres objetivos y ninguno más: entender qué es este proyecto, dejar la instancia ` +
+  `correcta para él —contexto, mapa, raíces, lo que espera a una persona— y que la primera tarea pueda ` +
+  `empezar. El análisis profundo llega después, cuando alguien pida algo concreto; adelantarlo acá ` +
+  `retrasa el único momento en que la herramienta todavía no sirve para nada.`
 
 function finish(result) {
   log(`Fin: ${JSON.stringify(result)}`)
@@ -51,50 +65,34 @@ const stop = (reason, detail = '') => {
   return finish({ stopped: true, reason, detail })
 }
 
-const STATE = {
-  type: 'object', additionalProperties: false, required: ['fresh'],
+const SCAN = {
+  type: 'object', additionalProperties: false, required: ['fresh', 'services'],
   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: {
+    // La conversación la enmarca el motor, no este recorrido: `ops onboard` da con qué pregunta empezar
+    // y qué dimensiones hay que cubrir, y duplicarlas acá dejaría dos listas que envejecen por separado.
+    opening: { type: 'string' },
+    followUps: { type: 'integer' },
+    dimensions: { type: 'array', items: { type: 'string' } },
     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' },
+      required: ['path'], properties: {
+        path: { type: 'string' },
+        runtimes: { type: 'array', items: { type: 'string' } },
+        // Comando declarado y de qué archivo salió. Verificar que además corra es una historia de la
+        // épica: correr la suite de cada servicio acá convertía el arranque en una espera larga.
+        commands: { type: 'array', items: { type: 'object', additionalProperties: false,
+          required: ['kind', 'command', 'source'], properties: {
+            kind: { type: 'string' }, command: { 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'],
+  type: 'object', additionalProperties: false, required: ['files'],
   properties: {
     files: { type: 'array', items: { type: 'string' } },
     assumptions: { type: 'array', items: { type: 'string' } },
@@ -105,150 +103,115 @@ const WRITTEN = {
 
 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.
+// Una sola llamada, y todo lo que hace es correr dos comandos y mirar dos archivos. Lo que sigue depende
+// de lo que devuelva, así que gastar más antes de saberlo es gastar a ciegas.
 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' },
+  `${BASE}\n\nFrom ${ROOT}, run exactly these two commands and report what they printed. Explore nothing ` +
+  `else and open no file other than .env.example at the workspace root.\n` +
+  `1. "node tools/ops.js onboard --json": the instance state, the workspace inventory, the opening ` +
+  `question and the dimensions still uncovered. Copy fresh, opening, followUps, the "need" of each ` +
+  `dimension, and every service with its path, its runtimes and its declared commands keeping the source ` +
+  `file each command came from. Add nothing it did not print.\n` +
+  `2. "node tools/ops.js check planning".\n` +
+  `If .env.example exists at the workspace root, report the variable names in secrets —names only— and ` +
+  `the external services they point at in externals.`,
+  { schema: SCAN, label: 'inventario' },
 )
-if (!state) return stop('estado-desconocido', 'no se pudo leer el estado de la instancia')
+if (!state) return stop('scan-unavailable', 'no se pudo leer el estado del workspace')
 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')
+const services = state.services || []
+const listado = services.map((service) => service.path).join(', ')
+log(`${services.length} servicio(s) en el workspace${listado ? `: ${listado}` : ''}`)
 
-// 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)
+// Sin contexto no hay nada que escribir que no sea inventado. Lo que se devuelve no es una negativa
+// sino la conversación: quien recién instaló no sabe qué es «volvé a correrlo con contexto», y adivinar
+// qué se espera de él es exactamente el trabajo que esta herramienta viene a sacarle de encima.
+//
+// Y se devuelve una pregunta con sus dimensiones, no un cuestionario: preguntarle «qué vende» a un
+// proyecto libre, interno o sin fines de lucro es empezar por una respuesta que nadie dio.
+const dimensions = state.dimensions || []
+if (!CONTEXT && state.opening) {
+  log(`Falta lo que el repositorio no puede decir. Preguntale primero, con estas palabras:`)
+  log(`  ${state.opening}`)
+  const faltan = dimensions.map((need) => `  · ${need}`).join('\n')
+  log(`Después, según lo que conteste, hasta ${state.followUps || 3} preguntas más, formuladas para este ` +
+    `proyecto y no como formulario, hasta cubrir lo que haga falta de:\n${faltan}`)
+  log('Con sus respuestas, volvé a invocar el arranque pasándoselas como contexto.')
+  return finish({ needsContext: true, opening: state.opening, dimensions, services: services.length })
+}
 
-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.`)
+const INVENTARIO = { services, externals: state.externals || [], secrets: state.secrets || [] }
+const EVIDENCE = `Inventario del workspace:\n${JSON.stringify(INVENTARIO)}` +
+  `${CONTEXT ? `\n\nContexto aportado por la persona, que vale como hecho: ${CONTEXT}` : ''}` +
+  `${services.length ? '' : '\n\nNo hay ningún servicio en el workspace: el código todavía no está acá.'}`
 
 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` +
+  `${BASE}\n\n${EVIDENCE}\n\nEscribí de una sola pasada el contexto de esta instancia, reemplazando el ` +
+  `molde en vez de comentarlo:\n` +
+  `1. ${ORG}/company.md y ${ORG}/product.md: lo que la persona contó y los nombres del repositorio ` +
+  `permiten afirmar. Lo que nada sostiene queda "Por definir" y su pregunta va a openQuestions. No des ` +
+  `por sentado que el proyecto vende algo: puede sostenerse con donaciones, presupuesto interno o ` +
+  `trabajo voluntario, y una sección que no aplica se dice, no se completa con algo plausible.\n` +
+  `2. La sección "## Mapa real" de ${ROOT}/AGENTS.md: una entrada por servicio con su ruta, su runtime y ` +
+  `sus comandos **tal como los declara**, diciendo de qué archivo salió cada uno. No afirmes que ` +
+  `funcionan: nadie los corrió. Un servicio sin comandos declarados se escribe así, que es información.\n` +
+  `3. ${ROOT}/ops.config.json: dejá en workspaceRoots las raíces de código reales, que es lo que un guard ` +
+  `usa para bloquear una escritura fuera de lugar. Una raíz de más lo apaga.\n` +
+  `${services.length ? '' : 'Sin servicios, el mapa queda declarado como pendiente, diciendo qué lo ' +
+    'completa.\n'}` +
+  `4. ${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 —dónde se cargan y quién lo hace, sin proponer ningún valor—, una por cada sistema ` +
+  `externo o MCP a conectar, y una por la autoridad del runner, que hoy declara runner.allowPush=false.\n` +
+  `5. Las preguntas que queden abiertas, en la sección Ideas de ${INBOX}, sin promover.\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` +
+  `${BASE}\n\n${EVIDENCE}\n\nSupuestos que quedaron escritos: ${JSON.stringify(drafted.assumptions || [])}\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` +
+  `relevante" con rutas reales 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'],
+  `explicar este proyecto. Los criterios salen de lo que hoy falta y son verificables: que organization/ ` +
+  `no tenga supuestos sin confirmar, que cada comando del mapa esté verificado corriéndolo y anotado con ` +
+  `su resultado, 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. ` +
+  `${services.length
+    ? 'Verificar los comandos es una historia: nadie los corrió todavía.'
+    : 'La primera historia es traer los repos y declararlos en workspaceRoots.'} ` +
+  `En "## Riesgos y decisiones humanas" citá las filas que quedaron en HUMAN_ACTIONS. No toques ` +
+  `BACKLOG.md.\n\n` +
+  `Cerrá corriendo "node tools/ops.js check planning" desde ${ROOT} y, si falla, reparando sólo lo que ` +
+  `esta corrida escribió; nunca debilites un criterio para forzar el verde.`,
+  { schema: { type: 'object', additionalProperties: false, required: ['file', 'passed'],
     properties: {
-      file: { type: 'string' }, title: { type: 'string' },
+      file: { type: 'string' }, passed: { type: 'boolean' }, details: { 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')
+if (!epic.passed) return stop('check-failed', epic.details || 'check no pasó tras escribir la épica')
 
 const supuestos = (drafted.assumptions || []).length
-const acciones = ((pending || {}).humanActions || []).length
+const acciones = (drafted.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,

package/engine/cli/args.js

@@ -14,6 +14,8 @@ const VALUED_FLAGS = new Set([
 // —un agente, típicamente— recibía texto sin ninguna señal de que su bandera no existía.
 const FLAGS = {
   init: ['--name', '--mode', '--force', '--runner', '--integration', '--install', '--no-install'],
+  scan: ['--json'],
+  onboard: ['--json'],
   check: ['--json'],
   tree: ['--json', '--no-color'],
   context: ['--json'],

package/engine/cli/ops.js

@@ -14,6 +14,8 @@ const F = require('../core/files')
 const O = require('../core/ownership')
 const CL = require('../core/changelog')
 const M = require('../core/manifest')
+const SC = require('../core/scan')
+const OB = require('../core/onboarding')
 const C = require('../config/validate')
 const T = require('../teams/registry')
 const AG = require('../agents/catalog')
@@ -26,6 +28,10 @@ const PROJECT_ROOT = path.resolve(__dirname, '..', '..')
 // Dónde aterriza una instancia cuando nadie eligió: una carpeta propia junto al código.
 const DEFAULT_TARGET = 'ops'
 
+// Cuántos servicios se listan en pantalla antes de recortar. El resto sigue en `--json`, que es lo que
+// consume el recorrido de arranque: recortar la lista es para leerla, no para acotar lo que se sabe.
+const LISTA = 20
+
 function fail(message, code = 1) {
   console.error(message)
   process.exit(code)
@@ -35,6 +41,8 @@ function usage() {
   console.log(`Uso:
   ops init [destino] [--name <nombre>] [--mode embedded|sidecar] [--force]
            [--runner claude|codex|gemini|antigravity] [--integration <proveedor>] [--install|--no-install]
+  ops scan [workspace] [--json]
+  ops onboard [ops-root] [--json]
   ops check <planning-dir> [--json]
   ops tree <planning-dir> [--no-color] [--json]
   ops context <planning-dir> [--json]
@@ -316,22 +324,112 @@ async function init(target, cli) {
     })
   } catch (error) { fail(error.message, 2) }
 
-  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')}`)
+  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; lo que sí puede es decir qué falta y qué preguntar.
+  //
+  // Se imprime siempre, incluso cuando la dependencia no se instaló: lo resuelve el motor que está
+  // corriendo `init`, no cuesta nada, y es lo único que le dice a alguien qué hacer con lo que acaba de
+  // crear. Dejarlo adentro del camino feliz lo escondía justo de quien más lo necesita.
+  console.log('')
+  onboard(root, SIN_BANDERAS)
+  if (resultado.instalado && resultado.runner !== BOOT.SIN_RUNNER) {
+    console.log(`\nAbrí ${resultado.runner} en este directorio para que las escriba por vos.`)
   }
+  console.log('')
   for (const paso of initSteps(enter, resultado)) console.log(paso)
+  if (resultado.instalado) {
+    console.log(`El ciclo empieza en ${path.join(relative || '.', 'planning', 'FLOW.md')}.`)
+  }
   if (resultado.error) fail(`${resultado.error}: la instancia quedó creada pero todavía no funciona.`)
 }
 
+// Dónde puede mirar una instancia: exactamente las raíces que declara, y nada por encima de ellas. Sale
+// de `ops.config.json` en vez de suponerse —el sidecar declara `..`, el embebido `.`— para que acotar las
+// raíces acote también el escaneo, y para que nadie termine recorriendo la carpeta de al lado.
+function workspaceRoots(root) {
+  try {
+    const config = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8'))
+    const declared = (config.workspaceRoots || []).map((entry) => path.resolve(root, entry.path || '.'))
+    return declared.length ? declared : [root]
+  } catch { return [root] }
+}
+
+// Qué hay en las raíces declaradas, antes de que nadie razone sobre ello. La raíz ops se saltea: no es
+// un servicio del proyecto, y su `package.json` sólo declara el motor.
+function inventory(root) {
+  const found = []
+  for (const workspace of workspaceRoots(root)) {
+    const result = SC.scan(workspace, root)
+    if (result.rootManifests.length) {
+      found.push({ path: '.', root: workspace, runtimes: ['raíz'], commands: result.rootCommands })
+    }
+    for (const service of result.services) found.push({ ...service, root: workspace })
+  }
+  return found
+}
+
+function scan(target, cli) {
+  const root = path.resolve(target || '.')
+  const result = target
+    ? { root: path.resolve(target), services: SC.scan(path.resolve(target)).services }
+    : { root, services: inventory(root) }
+  if (cli.has('--json')) return console.log(JSON.stringify(result, null, 2))
+  // Un monorepo de sesenta paquetes no se lee en pantalla. Se recorta, y se dice cuánto: un corte que no
+  // se anuncia hace pasar lo listado por todo lo que hay.
+  for (const service of result.services.slice(0, LISTA)) {
+    const donde = service.root && service.root !== result.root ? `${path.basename(service.root)}/` : ''
+    console.log(`${donde}${service.path} [${(service.runtimes || []).join(', ')}]${comandos(service.commands)}`)
+  }
+  if (result.services.length > LISTA) {
+    console.log(`… y ${result.services.length - LISTA} más, todos en --json`)
+  }
+  console.log(`${result.services.length} candidato(s). Cuál es el producto y cuál quedó muerto lo ` +
+    'decide una persona.')
+}
+
+// Sólo lo declarado y de dónde salió: un comando inventado se lee igual que uno real.
+function comandos(commands) {
+  const entries = Object.entries(commands || {})
+  if (!entries.length) return ' — sin comandos declarados'
+  return ` — ${entries.map(([kind, value]) => `${kind}: ${value.command} (${value.source})`).join(', ')}`
+}
+
+// La guía de arranque: qué hay, qué falta y qué preguntar. Determinista y en milisegundos, porque es lo
+// primero que ve alguien que acaba de instalar y todavía no sabe qué hace la herramienta.
+function onboard(rootArg, cli) {
+  const root = path.resolve(rootArg || '.')
+  const services = inventory(root)
+  const state = OB.guide(root, services)
+  if (cli.has('--json')) {
+    return console.log(JSON.stringify({ ...state, roots: workspaceRoots(root), servicios: services }, null, 2))
+  }
+  // La pregunta primero, y el inventario después: de qué trata el proyecto es lo mismo esté vacío,
+  // sea un monorepo o sean diez repos, y empezar por lo que se encontró invierte de qué se trata esto.
+  if (state.fresh) {
+    console.log(`${state.opening}\n`)
+    console.log(`Según lo que contestes salen hasta ${state.followUps} preguntas más, con las palabras de`)
+    console.log('este proyecto, hasta cubrir lo que haga falta de esto:\n')
+    for (const dimension of state.dimensions) console.log(`  · ${dimension.need}`)
+    console.log('')
+  }
+  const nombres = services.slice(0, LISTA).map((service) => service.path).join(', ')
+  const resto = services.length > LISTA ? ` y ${services.length - LISTA} más` : ''
+  console.log(services.length
+    ? `Mientras tanto, esto es lo que hay: ${nombres}${resto}`
+    : 'Mientras tanto, en el workspace todavía no hay ningún proyecto.')
+  if (!state.fresh) {
+    const escrito = [state.written.organization && 'organization/', state.written.roadmap && 'el roadmap']
+      .filter(Boolean).join(' y ')
+    console.log(`Esta instancia ya tiene ${escrito} escrito: el arranque no la va a pisar.`)
+    return
+  }
+  console.log('\nCon tus respuestas, el arranque escribe organization/, el mapa real de AGENTS.md y la')
+  console.log('primera épica. Con un runner instalado: /onboard, que te las hace una por una.')
+}
+
 function check(dir, cli) {
   const root = path.resolve(dir || '.')
   const errors = []
@@ -1138,6 +1236,8 @@ async function run(cli) {
   }
   const arg = cli.positional
   if (command === 'init') await init(arg[1], cli)
+  else if (command === 'scan') scan(arg[1], cli)
+  else if (command === 'onboard') onboard(arg[1], cli)
   else if (command === 'check') check(arg[1], cli)
   else if (command === 'tree') tree(arg[1], cli)
   else if (command === 'context') context(arg[1], cli)

package/engine/core/onboarding.js

@@ -0,0 +1,67 @@
+'use strict'
+
+// Qué le falta a una instancia para poder arrancar, y qué preguntarle a quien la creó. Vive en el motor
+// —y no en el recorrido del runner— porque es determinista y tiene que costar cero: la versión anterior
+// gastaba un subagente de un minuto para terminar diciendo «volvé a correrlo con contexto», que a quien
+// no conoce la herramienta no le dice nada. Una pregunta escrita es la diferencia entre guiar y mandar
+// a averiguar.
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+// El molde llega con estos marcadores. Que sigan ahí es la señal de que nadie escribió todavía.
+const PLACEHOLDERS = /Por completar|Por definir/
+
+// La única pregunta que no depende de ninguna respuesta, y por eso la única que se puede escribir de
+// antemano. Las cuatro fijas que había antes daban por sentado que el proyecto vende algo: a uno libre,
+// interno o sin fines de lucro le preguntaban quién paga antes de saber de qué se trataba.
+const OPENING = '¿De qué trata este proyecto? Una línea alcanza.'
+
+// Lo que hay que cubrir para poder escribir `organization/`, no cómo preguntarlo: la pregunta concreta
+// la formula quien conduce la conversación, con las palabras de este proyecto, y en un proyecto libre
+// «cómo se sostiene» se pregunta de una manera que en una empresa no tendría sentido. Son dimensiones,
+// no un formulario, y quien pregunta puede cubrir dos con una sola pregunta si vienen juntas.
+const DIMENSIONS = [
+  { key: 'quien', need: 'a quién sirve y quién lo usa' },
+  { key: 'sostiene',
+    need: 'cómo se sostiene: venta, suscripción, donación, presupuesto interno o trabajo voluntario' },
+  { key: 'exito', need: 'qué querés que pase en este período y cómo se va a notar' },
+  { key: 'alcance', need: 'qué servicios o carpetas están muertos o fuera de alcance' },
+  { key: 'externos', need: 'qué sistema externo o MCP hace falta conectar, y contra qué entorno' },
+  { key: 'codigo', need: 'dónde está el código, que todavía no aparece en el workspace' },
+]
+
+// Tres seguidas ya son una conversación; más, un formulario. La apertura no cuenta: es la que decide
+// cuáles de las demás valen la pena.
+const FOLLOW_UPS = 3
+
+function organizationWritten(root) {
+  const file = path.join(root, 'organization', 'company.md')
+  try { return !PLACEHOLDERS.test(fs.readFileSync(file, 'utf8')) } catch { return false }
+}
+
+function roadmapWritten(root) {
+  const dir = path.join(root, 'planning', 'roadmap')
+  try {
+    return fs.readdirSync(dir).some((name) => /^epic-\d+/.test(name) && !/^epic-000/.test(name))
+  } catch { return false }
+}
+
+// El estado de una instancia, la pregunta con la que se empieza y lo que queda por cubrir. `services`
+// viene del escaneo: sin código, preguntar por el alcance no tiene sobre qué caer, y preguntar dónde
+// está el código sí.
+function guide(root, services = []) {
+  const written = { organization: organizationWritten(root), roadmap: roadmapWritten(root) }
+  const fresh = !written.organization && !written.roadmap
+  const irrelevant = services.length ? 'codigo' : 'alcance'
+  return {
+    fresh,
+    written,
+    services: services.length,
+    opening: fresh ? OPENING : '',
+    followUps: fresh ? FOLLOW_UPS : 0,
+    dimensions: fresh ? DIMENSIONS.filter((dimension) => dimension.key !== irrelevant) : [],
+  }
+}
+
+module.exports = { guide, OPENING, DIMENSIONS, FOLLOW_UPS, PLACEHOLDERS }

package/engine/core/scan.js

@@ -0,0 +1,143 @@
+'use strict'
+
+// Qué hay en el workspace, resuelto por código y no por un modelo. Existe porque el arranque empezaba
+// pidiéndole a un agente que «inventariara el repositorio»: en una carpeta vacía eso gastó doce minutos
+// para no encontrar nada. Recorrer directorios y leer manifiestos es determinista, y lo que no lo es
+// —qué de todo esto es el producto, qué está muerto— recién vale la pena preguntárselo a un modelo
+// cuando esta lista existe.
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+// Lo que nunca es un servicio del proyecto. `node_modules` es el que hace la diferencia entre
+// milisegundos y minutos: adentro hay un manifiesto por dependencia. Los directorios ocultos se saltean
+// enteros —regla, no lista—: ahí viven la configuración del runner, el banco de evaluación y las cachés,
+// y un servicio del producto no se esconde detrás de un punto.
+const IGNORED = new Set([
+  'node_modules', 'vendor', 'dist', 'build', 'target', 'out', 'coverage', 'venv', '__pycache__', 'tmp',
+  'bower_components', 'jspm_packages', 'Pods', 'DerivedData', 'elm-stuff', '_build', 'deps', 'obj',
+  'site-packages', 'dist-newstyle', 'htmlcov', 'storybook-static', 'logs',
+])
+
+// Lo que este proyecto ya declaró que no es suyo. Leer el `.gitignore` de la raíz sale gratis y ahorra
+// mantener una lista de basura ajena: cada proyecto tiene la suya, y el nuestro no la puede adivinar.
+//
+// Se toman sólo los patrones que nombran un directorio sin comodines —`build/`, `/dist`, `.cache`—, y se
+// aplican por nombre en cualquier nivel, que es más ancho que la semántica real de git. Para decidir si
+// vale la pena entrar a mirar un directorio alcanza; para cualquier otra cosa, no es un parser de
+// gitignore y no hay que usarlo como si lo fuera.
+function ignoredByGit(root) {
+  let text = ''
+  try { text = fs.readFileSync(path.join(root, '.gitignore'), 'utf8') } catch { return [] }
+  return text.split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#') && !line.startsWith('!') && !/[*?[\]]/.test(line))
+    .map((line) => line.replace(/^\/+/, '').replace(/\/+$/, ''))
+    .filter((line) => line && !line.includes('/'))
+}
+
+const skipper = (root) => {
+  const declared = new Set(ignoredByGit(root))
+  return (name) => name.startsWith('.') || IGNORED.has(name) || declared.has(name)
+}
+
+// Un servicio anidado más hondo que esto es una excepción, y recorrer el árbol entero para encontrarlo
+// cuesta más que declararlo a mano en `AGENTS.md`.
+const DEPTH = 3
+
+const MANIFESTS = [
+  { file: 'package.json', runtime: 'node' },
+  { file: 'go.mod', runtime: 'go' },
+  { file: 'pyproject.toml', runtime: 'python' },
+  { file: 'requirements.txt', runtime: 'python' },
+  { file: 'Cargo.toml', runtime: 'rust' },
+  { file: 'composer.json', runtime: 'php' },
+  { file: 'pom.xml', runtime: 'java' },
+  { file: 'build.gradle', runtime: 'java' },
+  { file: 'Gemfile', runtime: 'ruby' },
+  { file: 'Makefile', runtime: 'make' },
+  { file: 'docker-compose.yml', runtime: 'compose' },
+  { file: 'docker-compose.yaml', runtime: 'compose' },
+  { file: 'Dockerfile', runtime: 'docker' },
+]
+
+// Sólo lo declarado, con su archivo: un comando inventado se lee igual que uno real, y el primer Verify
+// de una tarea es donde se descubre que no existe.
+function npmScripts(file) {
+  try {
+    const scripts = JSON.parse(fs.readFileSync(file, 'utf8')).scripts || {}
+    return ['test', 'lint', 'build'].reduce((found, key) => (
+      scripts[key] ? { ...found, [key]: { command: `npm run ${key}`, source: 'package.json' } } : found
+    ), {})
+  } catch { return {} }
+}
+
+function makeTargets(file) {
+  try {
+    const text = fs.readFileSync(file, 'utf8')
+    return ['test', 'lint', 'build'].reduce((found, key) => (
+      new RegExp(`^${key}:`, 'm').test(text)
+        ? { ...found, [key]: { command: `make ${key}`, source: 'Makefile' } }
+        : found
+    ), {})
+  } catch { return {} }
+}
+
+function commandsOf(dir) {
+  const packageJson = path.join(dir, 'package.json')
+  const makefile = path.join(dir, 'Makefile')
+  return {
+    // El Makefile gana sobre los scripts cuando los dos existen: el que envuelve al otro es el que el
+    // proyecto quiere que se corra.
+    ...(fs.existsSync(packageJson) ? npmScripts(packageJson) : {}),
+    ...(fs.existsSync(makefile) ? makeTargets(makefile) : {}),
+  }
+}
+
+function manifestsOf(dir) {
+  return MANIFESTS.filter((entry) => fs.existsSync(path.join(dir, entry.file)))
+}
+
+// Servicios candidatos bajo `root`, sin entrar en `skip` —típicamente la raíz ops, que no es un
+// servicio del proyecto—. El resultado es una lista, no un veredicto: decidir cuál es el producto y
+// cuál quedó muerto sigue siendo trabajo de una persona o de un cargo.
+function services(root, skip = '') {
+  const found = []
+  const excluded = skip ? path.resolve(skip) : ''
+  const skippable = skipper(root)
+  const walk = (dir, depth) => {
+    const manifests = manifestsOf(dir)
+    if (manifests.length && path.resolve(dir) !== path.resolve(root)) {
+      found.push({
+        path: path.relative(root, dir).split(path.sep).join('/'),
+        runtimes: manifests.map((entry) => entry.runtime),
+        manifests: manifests.map((entry) => entry.file),
+        commands: commandsOf(dir),
+      })
+    }
+    if (depth >= DEPTH) return
+    let entries = []
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { return }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || skippable(entry.name)) continue
+      const child = path.join(dir, entry.name)
+      if (excluded && path.resolve(child) === excluded) continue
+      walk(child, depth + 1)
+    }
+  }
+  walk(root, 0)
+  return found
+}
+
+// El primer nivel del workspace también puede ser un solo proyecto sin subcarpetas: se reporta aparte
+// para no confundir «un servicio en la raíz» con «no hay nada».
+function scan(root, skip = '') {
+  return {
+    root: path.resolve(root),
+    rootManifests: manifestsOf(root).map((entry) => entry.file),
+    rootCommands: commandsOf(root),
+    services: services(root, skip),
+  }
+}
+
+module.exports = { scan, services, IGNORED, DEPTH }

package/package.json

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

package/template/organization/company.md

@@ -1,22 +1,29 @@
-# Empresa — {{PROJECT_NAME}}
+# Organización — {{PROJECT_NAME}}
 
-Este archivo es específico de la empresa. Completar hechos; marcar lo desconocido como `Por definir`.
+Este archivo es el contexto estable de quien construye. Completar hechos; marcar lo desconocido como
+`Por definir`. Una empresa, un equipo interno y un proyecto libre lo llenan distinto: lo que no aplica
+se dice, no se inventa.
 
-## Misión y visión
+## De qué se trata
 
 Por completar.
 
-## Modelo de negocio
+## A quién sirve
 
-- Clientes y usuarios:
-- Quién paga:
-- Propuesta de valor:
-- Fuentes de ingreso:
+- Usuarios:
+- Quién decide que se use:
+- Qué mejora para ellos:
+
+## Cómo se sostiene
+
+Venta, suscripción, donación, presupuesto interno, trabajo voluntario o una mezcla. Lo que corresponda:
+
+- Origen de los recursos:
 - Costos o restricciones relevantes:
 
 ## Objetivos actuales
 
-Por completar. Incluir horizonte, responsable y métrica cuando existan.
+Por completar. Incluir horizonte, responsable y cómo se va a notar.
 
 ## Estructura y derechos de decisión