@ingeniomaps/cauce 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -14,6 +14,58 @@ 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

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,11 +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    parte del inventario de `ops scan` y escribe organization/, el «Mapa real» de
-            AGENTS.md —cada comando como está declarado y de qué archivo salió— 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.
+/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.
 ```
@@ -143,6 +162,7 @@ Lee [template/planning/PROTOCOL.md](template/planning/PROTOCOL.md) para el contr
 |---|---|
 | `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,9 +4,19 @@ 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.
+
+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.
@@ -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ó.
 
-Empezá por `node {{OPS_DIR}}tools/ops.js scan --json`, que devuelve los subproyectos con manifiesto propio
-y los comandos que cada uno declara: recorrer el árbol vos mismo cuesta minutos y encuentra lo mismo. 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
+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ó.
 
-Empezá por `node {{OPS_DIR}}tools/ops.js scan --json`, que devuelve los subproyectos con manifiesto propio
-y los comandos que cada uno declara: recorrer el árbol vos mismo cuesta minutos y encuentra lo mismo. 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
+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

@@ -4,8 +4,13 @@
 //
 // 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 scan` en milisegundos; el modelo entra después, y sólo si hay algo
-// sobre lo que decidir. Cuando no lo hay, este recorrido termina en una llamada.
+// 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
@@ -15,11 +20,9 @@ export const meta = {
   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: 'Inventario determinista: ops scan, sin modelo recorriendo nada' },
-    { title: 'Draft', detail: 'organization/, mapa real y raíces de código' },
-    { title: 'Human', detail: 'Credenciales, MCP y permisos: lo que no le toca al runner' },
-    { 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' },
   ],
 }
 
@@ -42,7 +45,15 @@ const BASE = `Nunca inventes clientes, métricas, ingresos, plazos ni responsabl
   `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, sólo lee. No escribas en ningún sistema externo y no promuevas trabajo al BACKLOG.`
+  `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)}`)
@@ -59,6 +70,11 @@ const SCAN = {
   properties: {
     fresh: { type: 'boolean' },
     reason: { type: 'string' },
+    // 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'], properties: {
         path: { type: 'string' },
@@ -91,16 +107,14 @@ phase('Scan')
 // de lo que devuelva, así que gastar más antes de saberlo es gastar a ciegas.
 const state = await agent(
   `${BASE}\n\nFrom ${ROOT}, run exactly these two commands and report what they printed. Explore nothing ` +
-  `else and open no other file than the two named below.\n` +
-  `1. "node tools/ops.js scan --json": the workspace inventory. Copy each service with its path, its ` +
-  `runtimes and its declared commands, keeping the source file each command came from. Add nothing that ` +
-  `the command did not print.\n` +
+  `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` +
-  `Then read ${ORG}/company.md and list ${ROADMAP}. Set fresh=true only if the organization file still ` +
-  `carries the mold's "Por completar" placeholders and the roadmap holds nothing but its template and ` +
-  `README; otherwise fresh=false and say in reason what is already written. 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.`,
+  `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('scan-unavailable', 'no se pudo leer el estado del workspace')
@@ -113,12 +127,21 @@ const services = state.services || []
 const listado = services.map((service) => service.path).join(', ')
 log(`${services.length} servicio(s) en el workspace${listado ? `: ${listado}` : ''}`)
 
-// Sin código y sin contexto no hay nada que escribir que no sea inventado, y esa es exactamente la
-// corrida que no puede costar nada: se termina acá, diciendo qué falta y cómo darlo.
-if (!services.length && !CONTEXT) {
-  return stop('sin-contexto', `no hay servicios en el workspace y no me diste contexto, así que no hay ` +
-    `nada que escribir sin inventarlo. Volvé a correrlo cuando estén los repos, o dame el contexto en ` +
-    `una línea: /onboard qué vende la empresa, a quién, y cuál es el objetivo del trimestre.`)
+// 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 INVENTARIO = { services, externals: state.externals || [], secrets: state.secrets || [] }
@@ -129,10 +152,12 @@ const EVIDENCE = `Inventario del workspace:\n${JSON.stringify(INVENTARIO)}` +
 phase('Draft')
 
 const drafted = await agent(
-  `${BASE}\n\n${EVIDENCE}\n\nEscribí los borradores de contexto de esta instancia, reemplazando el molde ` +
-  `en vez de comentarlo:\n` +
-  `1. ${ORG}/company.md y ${ORG}/product.md: lo que el contexto aportado y los nombres del repositorio ` +
-  `permiten afirmar. Lo que nada sostiene queda "Por definir" y su pregunta va a openQuestions.\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` +
@@ -140,26 +165,16 @@ const drafted = await agent(
   `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')
 
-phase('Human')
-
-// 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 —dónde se cargan 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, que hoy declara runner.allowPush=false en ops.config.json. Las ` +
-  `preguntas 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(
@@ -176,29 +191,22 @@ const epic = await agent(
   `${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.`,
-  { schema: { type: 'object', additionalProperties: false, required: ['file'],
+  `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.`)
 

package/engine/cli/args.js

@@ -15,6 +15,7 @@ const VALUED_FLAGS = new Set([
 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

@@ -15,6 +15,7 @@ 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')
@@ -27,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)
@@ -37,6 +42,7 @@ function usage() {
   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]
@@ -318,41 +324,70 @@ 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.`)
 }
 
-// Qué hay en el workspace, antes de que nadie razone sobre él. La raíz ops se saltea: no es un servicio
-// del proyecto, y su `package.json` sólo declara el motor.
+// 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) {
-  // Sólo el sidecar tiene su workspace afuera: la instancia es hija de la carpeta donde vive el código.
-  // Cualquier otro modo —embedded, y este mismo repositorio, que es `toolkit`— escanea donde está
-  // parado. Confundirlos hacía que un `scan` sin argumentos se fuera a recorrer la carpeta de al lado.
-  const sidecar = O.mode(process.cwd()) === 'sidecar'
-  const root = path.resolve(target || (sidecar ? path.join(process.cwd(), '..') : '.'))
-  const result = SC.scan(root, sidecar ? process.cwd() : '')
+  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))
-  console.log(`workspace ${result.root}`)
-  if (result.rootManifests.length) {
-    console.log(`. ${result.rootManifests.join(', ')}${comandos(result.rootCommands)}`)
+  // 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)}`)
   }
-  for (const service of result.services) {
-    console.log(`${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`)
   }
-  const total = result.services.length + (result.rootManifests.length ? 1 : 0)
-  console.log(`${total} candidato(s). Cuál es el producto y cuál quedó muerto lo decide una persona.`)
+  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.
@@ -362,6 +397,39 @@ function comandos(commands) {
   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 = []
@@ -1169,6 +1237,7 @@ 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

@@ -15,9 +15,31 @@ const path = require('node:path')
 // 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',
 ])
 
-const skippable = (name) => name.startsWith('.') || IGNORED.has(name)
+// 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`.
@@ -82,6 +104,7 @@ function manifestsOf(dir) {
 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)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.29.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