@ingeniomaps/cauce 0.90.0 → 0.92.0

package/engine/hooks/files.js

@@ -14,7 +14,7 @@ const {
 const AP = require('./approval')
 const CHAT = require('./chat')
 const { selfApproval } = require('./self-approval')
-const { readWip } = require('../planning/parser')
+const { readWip, readWips } = require('../planning/parser')
 const { runner } = require('../planning/claims')
 const { hasTasks } = require('../planning/state')
 const { TEMPLATE_PREFIXES } = require('../core/ownership')
@@ -235,14 +235,33 @@ function planFirst(input) {
   // Que el guard quede inerte lo dice `automation check`, porque una condición invisible es peor que
   // no tenerla.
   if (!hasTasks(planning)) return
+  // No tener plan y no ver el propio piden cosas opuestas: escribirlo, o volver al id desde el que ya se
+  // escribió. `runner()` sale del árbol donde corre el proceso, así que con una instancia al lado de dos
+  // repositorios el mismo cambio cae de un lado o del otro según el directorio, y el mensaje mandaba a
+  // escribir un plan que estaba a la vista (caso 152).
+  //
+  // Se lista recién acá, después de las dos salidas de arriba: quien tiene su plan sale por la primera y
+  // no paga esta lectura, que es la misma razón por la que `hasTasks` se pregunta donde se pregunta.
+  const ajenos = readWips(planning).filter((one) => one.complete + one.pending > 0)
   const estado = wip ? `WIP tiene la tarea ${wip.task} y ningún paso` : 'WIP está en IDLE'
-  const why = `${estado}, así que el plan todavía no está escrito.\n`
-    + 'Escribí en tu planning/wip/<runner>.md la tarea y su plan aprobado —pasos numerados, cada uno con un estado '
-    + 'verificable— y volvé al cambio. Si esto no es trabajo de una tarea, aprobá la ruta.\n'
+  const why = ajenos.length
+    ? `hay plan escrito, pero bajo otro id: ${ajenos.map((one) => `${one.runner} (${one.task})`).join(', ')}.\n`
+      + 'Si ese plan es tuyo, volvé a su id con `export CAUCE_RUNNER=<id>` —`ops runners <planning>` los lista '
+      + 'con su tarea y su avance— y repetí el cambio. Si vas a trabajar en paralelo, montá tu propio árbol '
+      + 'con `ops worktree <planning> <tarea>`, que te devuelve el id hecho.\n'
+    : `${estado}, así que el plan todavía no está escrito.\n`
+      + 'Escribí en tu planning/wip/<runner>.md la tarea y su plan aprobado —pasos numerados, cada uno con '
+      + 'un estado verificable— y volvé al cambio. Si esto no es trabajo de una tarea, aprobá la ruta.\n'
   for (const raw of filesOf(input)) {
     if (!isProduct(root, path.resolve(cwdOf(input), raw))) continue
     if (approved(input, raw)) continue
-    block(`${raw} cambia el producto sin plan. ${why}${AP.HOW('OPS_PLAN_FIRST_OVERRIDE', [raw], input)}`)
+    // Con un plan a la vista no se ofrece ninguna de las dos salidas: aprobar la ruta escribe «esto no es
+    // trabajo de una tarea», que ahí es falso, y anunciar la variable ofrece el permiso más ancho cuando
+    // la acción correcta es angosta y concreta —el mismo criterio con que `HOW` decide no nombrarla—.
+    const how = ajenos.length
+      ? AP.HOW(null, [], input, [])
+      : AP.HOW('OPS_PLAN_FIRST_OVERRIDE', [raw], input)
+    block(`${raw} cambia el producto sin plan. ${why}${how}`)
   }
 }
 

package/engine/hooks/shell.js

@@ -10,13 +10,14 @@ const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const {
   commandOf, cwdOf, block, isCommit, stagedForCommit,
-  writableRoots, outsideRoots, DECLARE_IT, unquoted, opsRoot, withoutGitGlobals,
+  writableRoots, outsideRoots, DECLARE_IT, unquoted, opsRoot, withoutGitGlobals, configOf,
 } = require('./input')
 const AP = require('./approval')
 const CHAT = require('./chat')
 const { publish } = require('./push')
 const { selfApprovalShell } = require('./self-approval')
 const EV = require('../core/evidence')
+const SC = require('../core/scope')
 
 // Dónde empieza y dónde termina una palabra dentro de un comando. Tres reglas de la tabla de abajo lo
 // decidían por su cuenta admitiendo sólo un espacio, el principio o el fin, y en un shell una palabra
@@ -418,13 +419,25 @@ const RECREABLE = new RegExp('(^|/)(?:dist|build|out|coverage|__pycache__'
 //
 // No se usa `git stash --keep-index`, que sería más corto: toca el árbol de quien está trabajando, y un
 // gate que muere a la mitad le deja el stash puesto.
-function commitTree(dir) {
+function commitTree(dir, input) {
   const status = run('git', ['-C', dir, 'status', '--porcelain', '--ignored'], dir)
   if (!status.ok) {
     block(`no se pudo leer el estado de ${dir}, así que no hay cómo saber qué va a grabar el commit.`)
   }
   const lines = status.output.split('\n').filter(Boolean)
-  if (!lines.some((line) => !line.startsWith('!!') && line[1] !== ' ')) {
+  const delta = lines.filter((line) => !line.startsWith('!!') && line[1] !== ' ')
+  if (!delta.length) {
+    return { root: dir, temp: null, env: {} }
+  }
+  // La de arriba pregunta *si hay* delta; ésta, *qué* delta: lo que ninguna puerta lee no puede cambiar
+  // su veredicto, y ahí el árbol vuelve a servir. Las reglas y el porqué viven en `core/scope.js`; sin
+  // una raíz que declare su alcance esto no cambia nada (caso 156).
+  //
+  // La raíz ops no es `dir` —una instancia sidecar las tiene separadas—, así que se resuelve como en el
+  // resto de los guards en vez de suponer un `ops.config.json` colgando del repositorio: deducir el
+  // layout en lugar de leer el declarado es lo que costó el caso 158.
+  const ops = opsRoot(input)
+  if (SC.staysInTree(ops ? configOf(ops).workspaceRoots : [], dir, delta)) {
     return { root: dir, temp: null, env: {} }
   }
 
@@ -488,11 +501,17 @@ function commitTree(dir) {
   // el lockfile de la copia y reinstala, lo que **empieza borrando** el `node_modules` del proyecto.
   //
   // Lo que se apaga es esa comprobación previa, que es el motivo por el que quiere tocar nada.
-  // `verify-deps-before-run` la gobierna y tiene tres valores: `install` reinstala solo —el que trae
-  // pnpm 11 y el que hace el daño—, `error` se niega y frena el gate cuando el lockfile de la copia
-  // difiere de lo instalado, que es justo lo que pasa al commitear un cambio de lockfile por partes, y
-  // `false` corre el script sin mirar. La copia no tiene que sincronizar nada: tiene que medir el
-  // código.
+  // `verify-deps-before-run` la gobierna y tiene cinco valores —`install`, `warn`, `prompt`, `error` y
+  // `false`—. El que hace el daño es `install`, que reinstala solo y es el default desde pnpm 11. `error`
+  // tampoco serviría: frena el gate cuando el lockfile de la copia difiere de lo instalado, que es justo
+  // lo que pasa al commitear un cambio de lockfile por partes. La copia no tiene que sincronizar nada:
+  // tiene que medir el código.
+  //
+  // El prefijo es `pnpm_config_` y no `npm_config_`, y esa sola palabra es la diferencia entre apagar la
+  // comprobación y no apagar nada: pnpm lee sus ajustes del entorno con su propio prefijo, así que con el
+  // de npm la variable llega igual y se ignora en silencio. Acá estuvo `npm_config_` desde el arreglo del
+  // 070 y no surtió efecto nunca (caso 151), con lo cual la protección que ese arreglo creyó poner no
+  // estuvo puesta. Medido sobre pnpm 10.30.2 y 11.20.0, iguales las dos.
   //
   // Acá estuvo `CI: 'true'` y fue una regresión (caso 070). Resolvía el síntoma del 068 —pnpm dejaba de
   // preguntar antes de purgar— desarmando la confirmación en vez de quitarle el motivo, y esa
@@ -502,7 +521,7 @@ function commitTree(dir) {
   //
   // La regla que queda: no se desarma la confirmación de una herramienta, se le quita el motivo de
   // preguntar. Una confirmación que estorba casi siempre está cuidando algo.
-  return { root: temp, temp, env: { npm_config_verify_deps_before_run: 'false' } }
+  return { root: temp, temp, env: { pnpm_config_verify_deps_before_run: 'false' } }
 }
 
 function verify(input) {
@@ -529,7 +548,7 @@ function verify(input) {
       + AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input))
   }
   if (!staged.some((file) => /\.(?:ts|tsx|js|jsx|mjs|cjs|go|py|html|css|scss|prisma)$/.test(file))) return
-  const { root, temp, env } = commitTree(dir)
+  const { root, temp, env } = commitTree(dir, input)
   try {
     verifyGates(root, dir, sinAprobar, env, input)
   } finally {

package/engine/schemas/ops-config.schema.json

@@ -49,6 +49,15 @@
           "verify": {
             "type": "string",
             "description": "Comando que corre la puerta de esta raíz —pruebas, lint, typecheck, build—, tal como se invoca desde ella. Sin él, quien verifica tiene que descubrirlo leyendo el repositorio en cada tarea, y eso es trabajo de modelo repetido para siempre sobre una respuesta que no cambia."
+          },
+          "scope": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "string",
+              "minLength": 1
+            },
+            "description": "Qué rutas lee la puerta de esta raíz, relativas a ella, con * ? y **. Sirve para que un archivo sucio que el gate no va a abrir no fuerce la copia del índice. Sin él, cualquier diferencia entre árbol e índice la fuerza, que es el comportamiento de siempre."
           }
         },
         "additionalProperties": false

package/package.json

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

package/template/organization/workspace.md

@@ -32,3 +32,15 @@ migraciones, un repo donde sí puede commitear directo, un entorno de pruebas qu
 
 Lo que no se puede ampliar acá: promover trabajo propio, prometer fechas, inventar evidencia o exceder
 la autoridad de un cargo. Eso no depende del proyecto.
+
+### Límites
+
+Una línea por límite, y cada una tiene que poder obedecerse sola: es lo que viaja al preámbulo de cada
+agente, sin el párrafo que la rodea. El ejemplo va comentado a propósito — un ejemplo que se obedece es
+peor que ninguno, así que descomentalo recién cuando sea tuyo de verdad.
+
+<!-- - En `api/` no se tocan migraciones sin aprobación de quien administra la base. -->
+
+Fuera de esta lista también cuenta lo que arranque con «El runner», «Debe» o «Nunca», que es como estaba
+escrito antes de que esta sección existiera. `ops check` avisa de cualquier párrafo que no entre por
+ninguno de los dos caminos, porque un límite perdido no se ve: la lista sale más corta y se lee igual.