@ingeniomaps/cauce 0.22.0 → 0.24.0

package/engine/config/validate.js

@@ -5,13 +5,8 @@ const MODES = ['embedded', 'sidecar', 'toolkit']
 // Campos que existieron y se retiraron. Se nombran en vez de caer en «propiedad desconocida» porque
 // quien actualiza merece saber qué hacer con la línea, no sólo que sobra.
 //
-// `planningDir` era obligatorio y nadie lo honraba: el renderizador de la plantilla lo resolvía
-// siempre a `planning`, y `findOpsRoot` y el registro de integraciones lo tienen escrito a mano. Un
-// campo así no configura, promete. En el propio toolkit decía `template/planning` —el molde que se
-// distribuye—, y un cargo que lo leyó concluyó que ahí vivía la planificación del proyecto.
-//
-// Se retira en vez de honrarse porque la ubicación no es opinable: `findOpsRoot` reconoce un
-// repositorio de operaciones justamente por tener `planning/` en la raíz.
+// `planningDir` no configuraba, prometía: nadie lo honraba y la ubicación no es opinable —`findOpsRoot`
+// reconoce una raíz ops justamente por tener `planning/` en la raíz—.
 const RETIRED = {
   planningDir: 'el motor siempre busca planning/ en la raíz del repositorio. Borrá la línea',
 }

package/engine/core/changelog.js

@@ -8,7 +8,7 @@ const path = require('node:path')
 
 const HEADING = /^##\s*\[([^\]]+)\]/
 
-// Compara versiones semver sin dependencias. Lo no numérico ordena antes que la release.
+// Lo no numérico ordena antes que la release.
 function compare(left, right) {
   const parse = (value) => String(value).split('-')[0].split('.').map((part) => Number(part) || 0)
   const [a, b] = [parse(left), parse(right)]

package/engine/core/ownership.js

@@ -32,7 +32,7 @@ const SYSTEM_FILES = [
   'organization/README.md',
   // Las reglas que un agente obedece y los atajos que envuelven al CLI. Ninguno tiene una línea de la
   // empresa, y envejecidos mienten: el `AGENTS.md` de una instancia seguía describiendo carpetas que
-  // `upgrade` había retirado, y el Makefile llama 16 veces a comandos que cambian.
+  // `upgrade` había retirado, y el Makefile envuelve comandos que cambian.
   'AGENTS.md',
   'Makefile',
   // El shim no tiene una línea de la empresa —dice él mismo que no se edita— y es por donde entra
@@ -95,10 +95,20 @@ function packagePath(root, relative) {
   return candidates.find((candidate) => fs.existsSync(candidate)) || ''
 }
 
-// Dónde quedó el motor. Es `packagePath` bajo `engine/`, y no una cascada propia: había dos copias de
-// la misma lista de candidatos en este archivo, una al lado de la otra, y nada obligaba a que
-// siguieran diciendo lo mismo. La tercera copia vive en el bridge de Antigravity, que corre antes de
-// poder cargar este módulo y por eso la repite a propósito.
+// El modo declarado, o '' si no hay configuración. `toolkit` es este repositorio: acá se fabrica
+// Cauce, así que los comandos que actualizan o instalan una instancia sólo pueden romper. Ausente e
+// ilegible no son lo mismo —devolver '' ante un archivo roto dejaba correr contra el toolkit justo
+// lo que reconocerlo impide—, así que lo segundo se levanta como error.
+function mode(root) {
+  const file = path.join(root, 'ops.config.json')
+  if (!fs.existsSync(file)) return ''
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')).mode || '' } catch (error) {
+    throw new Error(`ops.config.json no se puede leer (${error.message}).`)
+  }
+}
+
+// Dónde quedó el motor. El bridge de Antigravity repite esta cascada a mano porque corre antes de
+// poder cargar este módulo: si cambia acá, cambia allá.
 function engineAt(root, relative = '') {
   return packagePath(root, relative ? path.join('engine', relative) : 'engine')
 }
@@ -133,7 +143,6 @@ function entries(dir) {
   } catch { return [] }
 }
 
-// Entradas del proyecto que reemplazan a una del sistema con la misma identidad.
 function overrides(root) {
   const found = []
   for (const collection of SYSTEM_COLLECTIONS) {
@@ -192,7 +201,6 @@ function systemPaths(root) {
   return paths
 }
 
-// Archivos de un árbol, relativos a él, para comparar instancia contra paquete.
 function treeFiles(dir, prefix = '') {
   const found = []
   let list = []
@@ -205,7 +213,6 @@ function treeFiles(dir, prefix = '') {
   return found.sort()
 }
 
-// Rutas que Cauce mantiene y que por eso conviene registrar y vigilar.
 function trackedPaths() {
   return [...RUNTIME_PATHS, ...SYSTEM_COLLECTIONS.map((collection) => `${collection}/system`)]
 }
@@ -235,6 +242,7 @@ module.exports = {
   SYSTEM_COLLECTIONS,
   SYSTEM_FILES,
   localChanges,
+  mode,
   overrides,
   sourceOf,
   systemPaths,

package/engine/hooks/run.js

@@ -1,15 +1,21 @@
 #!/usr/bin/env node
 'use strict'
 
-const fs = require('fs')
-const os = require('os')
-const path = require('path')
-const { spawnSync } = require('child_process')
-
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const { spawnSync } = require('node:child_process')
+
+// Sin stdin no hay nada que leer y los guards caen a las variables de entorno; con stdin ilegible sí
+// hay algo y no se entiende, que es otra cosa. Devolver `{}` ahí dejaba a cada guard sin comando ni
+// archivos, o sea permitiendo todo, y en silencio.
 function readInput() {
   let raw = ''
-  try { raw = fs.readFileSync(0, 'utf8') } catch { /* no stdin */ }
-  try { return raw.trim() ? JSON.parse(raw) : {} } catch { return {} }
+  try { raw = fs.readFileSync(0, 'utf8') } catch { /* sin stdin */ }
+  if (!raw.trim()) return {}
+  try { return JSON.parse(raw) } catch (error) {
+    block(`la entrada del hook no es JSON válido (${error.message}).`)
+  }
 }
 
 function commandOf(input) {
@@ -55,6 +61,15 @@ function block(message) {
   throw error
 }
 
+// La configuración de la raíz ops. Un guard que no puede leerla bloquea: `findOpsRoot` sólo devuelve
+// una raíz si `ops.config.json` existe, así que llegar acá significa roto o ilegible, no ausente.
+// Dejarlo pasar convertía una coma de más en «sin límite de escritura».
+function configOf(root) {
+  try { return JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8')) } catch (error) {
+    block(`ops.config.json no se puede leer (${error.message}). Un guard no decide sin él.`)
+  }
+}
+
 function gitDirectory(command, cwd) {
   const flag = command.match(/(?:^|\s)git\s+-C\s+(['"]?)([^\s'";&|]+)\1/)
   const cd = command.match(/(?:^|[;&|]\s*)cd\s+(['"]?)([^\s'";&|]+)\1/)
@@ -70,10 +85,22 @@ function stagedFiles(dir) {
   return result.status === 0 ? result.stdout.trim().split('\n').filter(Boolean) : []
 }
 
+// R10 pide «la autorización configurada para el proyecto» y `runner.allowPush` es esa configuración:
+// sin esto era un interruptor que nadie leía, y un cargo que lo leyó dio por imposible un push que el
+// guard bloqueaba igual. Sin raíz legible no hay permiso que verificar, así que no se autoriza.
+function pushAllowed(input) {
+  const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
+  if (!root) return false
+  const runner = configOf(root).runner
+  return Boolean(runner && runner.allowPush === true)
+}
+
 function destructive(input) {
   const command = commandOf(input)
+  if (/\bgit\s+push\b/.test(command) && !pushAllowed(input)) {
+    block("'git push' publica cambios y requiere una acción humana. Se habilita con runner.allowPush.")
+  }
   const rules = [
-    [/\bgit\s+push\b/, "'git push' publica cambios y requiere una acción humana."],
     [/\bgit\s+reset\s+--hard\b/, "'git reset --hard' destruye cambios locales."],
     [/\bgit\s+clean\s+-[^\s]*f/, "'git clean -f' borra archivos sin seguimiento."],
     [
@@ -146,8 +173,7 @@ function generated(input) {
 function workspaceBoundary(input) {
   const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
   if (!root) return
-  let config
-  try { config = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8')) } catch { return }
+  const config = configOf(root)
   const allowed = [root, ...(config.workspaceRoots || []).map((entry) => path.resolve(root, entry.path))]
   for (const raw of filesOf(input)) {
     const file = path.resolve(cwdOf(input), raw)
@@ -228,22 +254,14 @@ function governance(input) {
   const command = commandOf(input)
   if (!isCommit(command)) return
   const dir = gitDirectory(command, cwdOf(input))
-  // El contrato de un cargo y lo que lo mide son gobernanza, igual que un ADR o una regla.
+  // El contrato de un cargo y lo que lo mide son gobernanza, igual que un ADR o una regla. La firma de
+  // «Aprobación humana» sólo estaba protegida por una frase en un prompt; `SKILL.md` y `references/`
+  // son lo que la propuesta cambia, y editarlos directo saltea el ciclo entero; y `evaluations/` es el
+  // denominador con que se juzga, así que moverlo ablanda toda medición pasada sin tocar una regla.
   //
-  // Lo puntual es la firma: `agent-promote` se niega si «Aprobación humana» no está firmada, pero lo
-  // único que impedía que la escribiera un agente era una frase en un prompt. Una instrucción, no un
-  // candado — y el archivo no estaba protegido por nada.
-  //
-  // Alrededor de la firma van las otras tres piezas del mismo acto. `SKILL.md` y `references/` son lo
-  // que la propuesta cambia: sin ellos, editar el contrato directo saltea el ciclo entero. Y
-  // `evaluations/` es el denominador con que se juzga —el propio recorrido de propuesta dice que
-  // cambiarlo «es parte de lo que se aprueba»—, así que moverlo en silencio ablanda toda medición
-  // pasada sin tocar una sola regla.
-  //
-  // Quedan afuera las dos clases de evidencia, y por la misma razón: registran lo que pasó un día en
-  // vez de decidir algo. `learning/reports/` es lo investigado esa semana, y `evaluations/results/` la
-  // transcripción de una corrida —que se escribe en cada evaluación, así que gobernarla pediría un
-  // override por corrida—. Por eso `evaluations/` se nombra por partes en vez de entero.
+  // Quedan afuera las dos clases de evidencia, que registran lo que pasó un día en vez de decidir algo:
+  // `learning/reports/` y `evaluations/results/` —esta última se escribe en cada corrida, así que
+  // gobernarla pediría un override por evaluación—. Por eso `evaluations/` se nombra por partes.
   const governedPattern = new RegExp(
     String.raw`^(?:(?:template\/)?planning\/(?:rules\/|adr\/|PROTOCOL\.md|` +
       String.raw`METHODOLOGY\.md|FLOW\.md)|automatization\/|engine\/` +
@@ -351,21 +369,16 @@ function planningDrift(input) {
   block(`Planning o integraciones quedaron desalineados:\n${result.output}`)
 }
 
-// El motor llega por npm y se actualiza por npm. `workspace-boundary` no lo cubre: en una instalación
-// `node_modules/` cae dentro de la raíz declarada, así que editar el motor le parece legítimo.
-//
-// Editarlo desde la empresa rompe dos veces. El próximo `npm install` borra el cambio sin avisar, así
-// que el arreglo se pierde justo cuando alguien creyó haberlo hecho; y hasta entonces la empresa corre
-// un motor que no coincide con la versión que declara, que es la clase de diferencia que aparece como
-// un bug irreproducible. Un problema del motor se reporta y se arregla arriba, no acá.
+// Hace falta un guard aparte porque `workspace-boundary` no lo cubre: `node_modules/` cae dentro de
+// la raíz declarada, así que editar el motor le parece legítimo.
 //
-// El toolkit se exceptúa, y esa distinción ya estaba escrita: en su `ops.config.json` el modo es
-// `toolkit`. Ahí el motor es el producto y editarlo es exactamente el trabajo.
+// Editarlo rompe dos veces: el próximo `npm install` borra el cambio sin avisar, y hasta entonces la
+// empresa corre un motor que no coincide con la versión que declara —la clase de diferencia que
+// aparece como un bug irreproducible—. En modo `toolkit` no aplica: ahí el motor es el producto.
 function engineWrites(input) {
   const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
   if (!root) return
-  let config
-  try { config = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8')) } catch { return }
+  const config = configOf(root)
   if (config.mode === 'toolkit') return
   const pkg = path.join(root, 'node_modules', '@ingeniomaps', 'cauce')
   for (const raw of filesOf(input)) {

package/engine/integrations/proposals.js

@@ -17,7 +17,9 @@ function read(root, provider) {
     const content = fs.readFileSync(path.join(dir, file), 'utf8')
     const fields = S.frontmatter(content)
     const body = content.replace(/^---[\s\S]*?---\s*/, '')
-    const summary = ((body.match(/^#\s+(.+)$/m) || [])[1] || '').trim()
+    // `[ \t]` y no `\s`: `\s` casa el salto de línea, así que un `#` vacío se comía la siguiente
+    // línea no vacía y devolvía «## Descripción» como título. Con eso, «falta título» no saltaba nunca.
+    const summary = ((body.match(/^#[ \t]+(.+)$/m) || [])[1] || '').trim()
     const description = ((body.match(
       /^##\s+Descripción\s*\n([\s\S]*?)(?=^##\s+|(?![\s\S]))/im,
     ) || [])[1] || '').trim()

package/engine/integrations/registry.js

@@ -2,8 +2,8 @@
 
 // Registro y ciclo común de proveedores externos.
 
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 const F = require('../core/files')
 const S = require('./state')
 const P = require('./proposals')
@@ -252,12 +252,15 @@ async function sync(root, name, options = {}) {
     F.atomicWrite(draftFile, draft)
     F.atomicWriteJson(snapshotFile, snapshot)
   }
-  const complete = options.complete !== false
-  if (complete) cleanupMissing(root, name, seen, result)
+  // Siempre se limpia: ningún adaptador puede devolver una lectura parcial. El de Jira lanza al
+  // exceder páginas, al repetir un token y ante cualquier HTTP que no sea 200, así que o trajo todo o
+  // no trajo nada. Había una bandera `complete` para saltearlo, sin forma de activarla desde el CLI y
+  // sin nadie que leyera el campo que escribía. Vuelve el día que un adaptador sepa decir «traje una
+  // parte», que es cuando protegería algo.
+  cleanupMissing(root, name, seen, result)
   F.atomicWriteJson(path.join(staging, 'sync-state.json'), {
     schemaVersion: 2,
     provider: name,
-    complete,
     pulledAt: new Date().toISOString(),
     keys: [...seen].sort(),
   })

package/engine/integrations/state.js

@@ -45,7 +45,7 @@ function replaceField(text, name, value) {
 
 function sections(text) {
   const body = String(text).replace(/^---[\s\S]*?---\s*/, '')
-  const title = ((body.match(/^#\s+(.+)$/m) || [])[1] || '').trim()
+  const title = ((body.match(/^#[ \t]+(.+)$/m) || [])[1] || '').trim()
   const result = { title }
   const names = ['Descripción', 'Aceptación', 'Comentarios', 'Decisiones', 'Problemas de preparación']
   for (const [index, name] of names.entries()) {

package/engine/planning/business-rules.js

@@ -6,6 +6,16 @@ const path = require('node:path')
 const REQUIRED = ['## Reglas', '## Por qué existe cada regla', '## Historial']
 const ID_PATTERN = /\|\s*(BR-[A-Z0-9]+-\d{3})\s*\|/g
 
+// El estado se valida contra un conjunto cerrado, y no es prolijidad: es la diferencia entre una regla
+// que rige y una que espera aprobación. Antes el patrón aceptaba cualquier texto y la plantilla traía
+// `vigente` cableado, así que un cargo que copiaba la plantilla recibía «vigente» gratis y tenía que
+// acordarse de debilitarlo — mientras la plantilla de ADR le presentaba el menú y lo obligaba a elegir.
+//
+// Esa asimetría produjo el mismo error en tres cargos distintos: reglas declarándose vigentes derivadas
+// de un ADR que los mismos cargos habían dejado en `Propuesto`. Hacían lo que cada plantilla les pedía.
+const STATES = ['propuesta', 'vigente', 'derogada']
+const METADATA = /> \*\*Dominio:\*\* (.+) \| \*\*Estado:\*\* (.+) \| \*\*Actualizado:\*\* (\d{4}-\d{2}-\d{2})/
+
 function markdownFiles(root) {
   if (!fs.existsSync(root)) return []
   const files = []
@@ -25,8 +35,10 @@ function validate(root) {
   for (const file of markdownFiles(root)) {
     const relative = path.relative(path.dirname(root), file)
     const source = fs.readFileSync(file, 'utf8')
-    if (!/> \*\*Dominio:\*\* .+ \| \*\*Estado:\*\* .+ \| \*\*Actualizado:\*\* \d{4}-\d{2}-\d{2}/.test(source)) {
-      errors.push(`${relative}: falta metadata Dominio/Estado/Actualizado`)
+    const metadata = source.match(METADATA)
+    if (!metadata) errors.push(`${relative}: falta metadata Dominio/Estado/Actualizado`)
+    else if (!STATES.includes(metadata[2].trim().toLowerCase())) {
+      errors.push(`${relative}: Estado «${metadata[2].trim()}» no es ${STATES.join(', ')}`)
     }
     for (const heading of REQUIRED) {
       if (!source.includes(heading)) errors.push(`${relative}: falta ${heading}`)

package/engine/planning/parser.js

@@ -2,8 +2,8 @@
 
 // Contratos deterministas de planning; no contiene estado de proyecto.
 
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 
 const EPIC_STATES = ['open', 'active', 'closed']
 
@@ -67,9 +67,13 @@ function readEpics(dir) {
     const field = frontmatter(text)
     const criteria = [...section(text, /Criterios/i).matchAll(/^-\s+\*\*(C\d+)(?:[^*]*)\*\*\s+[—-]\s+(.+)$/gm)]
       .map((match) => ({ id: match[1], text: match[2].trim() }))
+    // `(?![\s\S])` y no `$`: con la bandera `m` el `$` casa fin de **línea**, así que el cuerpo no ávido
+    // cortaba en el primer salto y una historia envuelta perdía su `(service: …)` y sus `(→ CN)`. El
+    // error que salía era «no declara (service: <ruta>)» — culpaba al autor de algo que sí había escrito.
+    // Dos cargos distintos lo encontraron reescribiendo su historia hasta que entrara en un solo renglón.
     const storyPattern = new RegExp(
       String.raw`^[-*]\s+(?:\[[ xX]\]\s+)?\*\*([^*]+)\*\*\s+([\s\S]*?)` +
-        String.raw`(?=\n[-*]\s+(?:\[[ xX]\]\s+)?\*\*|\n##|$)`,
+        String.raw`(?=\n[-*]\s+(?:\[[ xX]\]\s+)?\*\*|\n##|(?![\s\S]))`,
       'gm',
     )
     const stories = [...section(text, /Historias/i).matchAll(storyPattern)]
@@ -163,11 +167,19 @@ function readWip(dir) {
   }
 }
 
+// Un ítem se cuenta cuando empieza con su nombre en negrita, y el nombre existe para poder citarlo
+// —`HUMAN_ACTIONS.md` y las propuestas mensuales se refieren a un ítem por ese slug—. La convención se
+// conserva; lo que no se conserva es el silencio.
+//
+// La plantilla no traía ningún ejemplo, así que quien escribía viñetas planas veía cero ítems sobre un
+// archivo con doce y nada se lo decía. `skipped` es lo que vuelve visible esa diferencia.
 function readInbox(dir) {
-  const result = { deuda: 0, ideas: 0, propuestas: 0, lecciones: 0 }
+  const result = { deuda: 0, ideas: 0, propuestas: 0, lecciones: 0, skipped: 0 }
   for (const part of read(path.join(dir, 'INBOX.md')).split(/^##\s+/m)) {
     const title = part.split('\n')[0]
+    const bullets = (part.match(/^[-*]\s+(?:\[[ xX]\]\s+)?/gm) || []).length
     const count = (part.match(/^[-*]\s+(?:\[[ xX]\]\s+)?\*\*/gm) || []).length
+    if (/Deuda|Ideas|Visi[oó]n|Propuestas|Lecciones/i.test(title)) result.skipped += bullets - count
     if (/Deuda/i.test(title)) result.deuda = count
     if (/Ideas|Visi[oó]n/i.test(title)) result.ideas = count
     if (/Propuestas/i.test(title)) result.propuestas = count

package/engine/teams/registry.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 const catalog = require('../agents/catalog')
 
 const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
@@ -51,8 +51,12 @@ function validate(root, slug) {
   }
   if (!OUTCOMES.includes(manifest.outcome)) errors.push(`outcome debe ser ${OUTCOMES.join(' o ')}`)
   if (!Array.isArray(manifest.stages) || !manifest.stages.length) errors.push('stages debe contener etapas')
-  if (!Array.isArray(manifest.guardrails) || !manifest.guardrails.length) errors.push('guardrails debe contener controles')
-  if (!Array.isArray(manifest.completion) || !manifest.completion.length) errors.push('completion debe contener criterios')
+  if (!Array.isArray(manifest.guardrails) || !manifest.guardrails.length) {
+    errors.push('guardrails debe contener controles')
+  }
+  if (!Array.isArray(manifest.completion) || !manifest.completion.length) {
+    errors.push('completion debe contener criterios')
+  }
 
   const agents = new Set([manifest.entryAgent, manifest.facilitator])
   for (const agent of Object.values(manifest.decisionOwners || {})) agents.add(agent)

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
+  "keywords": [
+    "planning",
+    "agents",
+    "ai-agents",
+    "cli",
+    "workflow",
+    "governance"
+  ],
   "type": "commonjs",
   "bin": {
     "cauce": "engine/cli/ops.js"
@@ -12,27 +20,33 @@
     "agents/",
     "teams/",
     "automatization/",
-    ".github/workflows/",
-    "LICENSE",
     "CHANGELOG.md"
   ],
   "scripts": {
     "ops": "node engine/cli/ops.js",
     "check": "node engine/cli/ops.js check template/planning",
-    "tree": "node engine/cli/ops.js tree template/planning --no-color",
     "automation:check": "node engine/cli/ops.js automation check .",
     "integration:check": "node engine/cli/ops.js integration check template jira",
     "test": "bash test/hooks-smoke.sh && node --test test/*.test.js",
     "coverage": "bash test/coverage.sh",
-    "ci": "npm run check && npm run automation:check && npm run integration:check && npm run coverage"
+    "coverage:update": "bash test/coverage.sh --update",
+    "ci": "npm run check && npm run automation:check && npm run integration:check && npm run coverage",
+    "prepublishOnly": "npm run ci"
   },
   "engines": {
     "node": ">=24"
   },
   "packageManager": "npm@11.16.0",
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ingeniomaps/cauce.git"
   },
+  "homepage": "https://github.com/ingeniomaps/cauce#readme",
+  "bugs": {
+    "url": "https://github.com/ingeniomaps/cauce/issues"
+  },
   "license": "MIT"
 }

package/template/AGENTS.md

@@ -1,7 +1,9 @@
 # Reglas de construcción
 
 Este archivo gobierna el qué y el cuándo. `planning/PROTOCOL.md` gobierna el flujo y
-`planning/rules/` el cómo.
+`planning/rules/` el cómo: sus reglas rigen cada tarea y se leen antes de empezar, no cuando algo sale
+mal. Ahí está la conducta que no depende de este proyecto —trato con sistemas externos, qué se debe
+entregar aun al negarse—; acá, lo que sí depende.
 
 ## Mapa real
 
@@ -16,14 +18,8 @@ El mapa no debe duplicar documentación técnica: enlaza a la fuente de verdad d
 
 ## Integraciones y ambientes
 
-Por defecto, todo sistema externo se considera real y de solo lectura. Sin aprobación humana explícita:
-
-- no desplegar, publicar, enviar mensajes ni escribir en producción;
-- no cobrar, reembolsar, gastar créditos ni llamar APIs con costo de forma repetida;
-- no editar secretos, credenciales, DNS, permisos o cuentas;
-- no borrar datos ni ejecutar migraciones irreversibles.
-
-Documentar excepciones concretas aquí. Un entorno de desarrollo o sandbox debe nombrarse explícitamente.
+R12 fija el trato con todo sistema externo: real y de sólo lectura mientras no se lo nombre como
+sandbox. Las excepciones de este proyecto —y sólo ellas— van acá, con el entorno concreto.
 
 ## Cargos disponibles
 
@@ -32,7 +28,19 @@ decide, qué no le corresponde y cuál es su entrega mínima; sus métodos viven
 
 Antes de resolver algo que cae claramente en un cargo —una decisión de producto, un diseño de
 arquitectura, una estrategia de pruebas—, adoptá ese contrato en vez de improvisar el criterio. Los
-límites del cargo no son sugerencias: un cargo que no puede decidir solo, no decide solo.
+límites del cargo no son sugerencias: un cargo que no puede decidir solo, no decide solo. Su
+contraparte es R13: el que se niega bien y no deja nada tampoco cumplió.
+
+Para saber cuál es, una línea por cargo:
+
+```bash
+node tools/ops.js agents list                # quién hace qué y qué NO le corresponde
+```
+
+Se elige leyendo esa lista, no abriendo carpetas. Si ninguna línea encaja, el cargo no existe y el
+camino es escribir el propio en `agents/roles/<slug>/`; forzar el más parecido es peor que no usar
+ninguno. Si encaja pero lo querés más enfocado en esta empresa, el contexto va en
+`organization/roles/<slug>.md` y el contrato sigue siendo el de Cauce.
 
 En Claude y Antigravity los cargos aparecen como skills invocables por nombre. En Codex y Gemini no hay
 mecanismo nativo: leé directamente el `SKILL.md` del cargo. Los que trae
@@ -52,7 +60,7 @@ Los cargos **propios** son otra cosa: nadie más los va a investigar. Su ciclo e
 comando, sin cron —activarlo en tu repositorio es decisión tuya—:
 
 ```bash
-node tools/ops.js agents list --own          # sólo los tuyos, sin los 47 del catálogo
+node tools/ops.js agents list --own          # sólo los tuyos, sin los del catálogo
 node tools/ops.js learn <slug>               # arma el informe de la semana
 /agent-propose <slug>                        # escribe el cambio concreto sobre esos informes
 #   ↑ firmá «Aprobación humana» en la propuesta antes de seguir
@@ -64,26 +72,6 @@ Un cargo propio puede declarar en `learning/AUTOMATION.md` qué debe investigar
 Si su profesión no existe fuera de tu empresa, sus fuentes son internas: lo que aprende sale de sus
 propias decisiones, no de un estándar de afuera.
 
-## Negarse no es entregar
-
-Cada límite de un cargo tiene una contraparte positiva, y respetar el límite no exime de ella. Un cargo
-que se niega bien y no deja nada dejó el pedido sin resolver: hizo la mitad barata del trabajo.
-
-- **Ante falta de contexto, producir el borrador reversible marcado como supuesto, no bloquear pidiendo
-  insumos.** Pedir una decisión humana sólo cuando las opciones cambien materialmente el rumbo, el
-  gasto, una obligación externa o el riesgo. Un borrador que se puede tirar no cambia ninguna de esas
-  cosas; no entregarlo, sí.
-- **Delimitar el espacio de decisión no es decidir.** Enumerar las opciones y pedir que alguien elija
-  es trabajo a medias cuando ninguna de ellas cambia materialmente el rumbo: en ese caso se propone una,
-  con su razón, marcada como propuesta.
-- **Todo rechazo se acompaña de lo que sí corresponde hacer**, dicho como acción concreta y no como
-  categoría. «Esto no me corresponde» sin decir a quién ni con qué pregunta deja el pedido donde estaba.
-- **Nombrar lo que falta no reemplaza a entregar lo que se puede.** Lo que sí se pudo establecer se
-  escribe igual, aunque el resultado quede parcial y marcado como tal.
-
-Esto no afloja ningún límite: no promover, no prometer fechas, no inventar evidencia y no exceder la
-autoridad del cargo siguen siendo absolutos. Lo que se cierra es la salida de cumplirlos sin entregar.
-
 ## Qué se puede editar y qué no
 
 Todo directorio `system/` pertenece a Cauce y se reemplaza completo al actualizar. **Nunca editar nada

package/template/Makefile

@@ -1,13 +1,17 @@
 .DEFAULT_GOAL := help
 
 .PHONY: help check tree context upgrade automation-check
-.PHONY: require-agent agent-learn agent-propose agent-evaluate
+.PHONY: integration-check integration-sync require-key integration-promote
+.PHONY: require-agent agent-learn agent-propose agent-evaluate require-team team-check team-show
 .PHONY: install-claude install-codex install-gemini install-antigravity
 .PHONY: doctor-claude doctor-codex doctor-gemini doctor-antigravity
 
+# Jira es hoy el único proveedor; el día que haya otro se pasa PROVIDER=<slug>.
+PROVIDER ?= jira
+
 help: ## Muestra los comandos disponibles y su propósito
 	@awk 'BEGIN {FS = ":.*## "; printf "Uso: make <comando>\n\n"} \
-	/^[a-zA-Z0-9_-]+:.*## / {printf "  %-18s %s\n", $$1, $$2}' $(MAKEFILE_LIST)
+	/^[a-zA-Z0-9_-]+:.*## / {printf "  %-22s %s\n", $$1, $$2}' $(MAKEFILE_LIST)
 
 check: ## Valida planning e integraciones
 	@node tools/ops.js check planning
@@ -24,6 +28,18 @@ upgrade: ## Actualiza Cauce sin tocar lo del proyecto
 automation-check: ## Comprueba hooks, workflows y adaptadores
 	@node tools/ops.js automation check .
 
+integration-check: ## Valida configuración y staging, sin conectarse
+	@node tools/ops.js integration check .
+
+integration-sync: ## Lee el proveedor y actualiza staging; PROVIDER=<slug> para elegir otro
+	@node tools/ops.js integration sync . "$(PROVIDER)"
+
+require-key:
+	@test -n "$(KEY)" || (echo "Falta KEY=<clave-remota>" >&2; exit 2)
+
+integration-promote: require-key ## Promueve el draft KEY=<clave> al roadmap
+	@node tools/ops.js integration promote . "$(PROVIDER)" "$(KEY)"
+
 require-agent:
 	@test -n "$(AGENT)" || (echo "Falta AGENT=<slug>" >&2; exit 2)
 
@@ -36,6 +52,15 @@ agent-propose: require-agent ## Consolida una propuesta para AGENT=<slug>
 agent-evaluate: require-agent ## Evalúa controles y casos de AGENT=<slug>
 	@node tools/ops.js evaluate "$(AGENT)"
 
+require-team:
+	@test -n "$(TEAM)" || (echo "Falta TEAM=<slug>" >&2; exit 2)
+
+team-check: require-team ## Valida contrato, agentes y etapas de TEAM=<slug>
+	@node tools/ops.js team check "$(TEAM)"
+
+team-show: require-team ## Muestra el recorrido de TEAM=<slug>
+	@node tools/ops.js team show "$(TEAM)"
+
 install-claude: ## Instala hooks y workflows para Claude
 	@node tools/ops.js automation install . claude
 

package/template/planning/INBOX.md

@@ -2,6 +2,14 @@
 
 El runner puede agregar; solo una persona promueve y elimina.
 
+Cada ítem empieza con su nombre en negrita, porque ese nombre es con el que se lo cita después desde
+`HUMAN_ACTIONS.md`, desde una épica o desde una propuesta mensual. Una viñeta sin nombre no se cuenta, y
+`ops tree` avisa cuántas quedaron afuera:
+
+```markdown
+- **slug-del-item** — Qué es, y qué se decide o se resuelve con esto.
+```
+
 ## Deuda
 
 ## Ideas

package/template/planning/business-rules/000-template.md

@@ -1,6 +1,6 @@
 # Tema
 
-> **Dominio:** nombre | **Estado:** vigente | **Actualizado:** YYYY-MM-DD
+> **Dominio:** nombre | **Estado:** propuesta | vigente | derogada | **Actualizado:** YYYY-MM-DD
 
 Describir brevemente el comportamiento de negocio compartido y el riesgo que controla. Las fuentes no obvias
 se citan como `[fuente: ruta#sección|ADR-NNN|URL]`; lo desconocido se marca `[supuesto: explicación]`.

package/template/planning/rules/README.md

@@ -5,6 +5,7 @@
 - `system/process.md`: planificación, alcance, review y sincronización de estado.
 - `system/code-shape.md`: simplicidad y forma del cambio.
 - `system/commits.md`: historia versionada y entrega.
+- `system/conduct.md`: trato con sistemas externos y obligación de entregar al negarse.
 
 Las reglas propias del proyecto van en este directorio, junto a `system/`, y nunca se tocan al
 actualizar. Para cambiar una regla del sistema, escribí la tuya con el mismo nombre: la del proyecto

package/template/planning/rules/system/code-shape.md

@@ -12,3 +12,8 @@ No reformatear, renombrar ni reparar elementos ajenos a la tarea.
 
 Extraer responsabilidades cuando una unidad deja de poder entenderse y probarse aisladamente; no usar
 límites numéricos como sustituto del juicio.
+
+## R11 — Comentarios que explican el porqué
+
+Un comentario dice por qué el código es así, no qué hace: si el código ya lo dice, sobra. Cada razón
+vive en un solo lugar, y un bloque de más de tres líneas tiene que justificar su largo.