@trycore/spec-build-harness 0.8.4 → 0.10.0

package/hooks/build/stack-guard.sh

@@ -6,6 +6,11 @@
 set -uo pipefail
 
 ROOT="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+# [EP-OR-08-B] El allowlist deja de ser un fichero que edita un humano: en dual/runtime lo
+# escribe context-sync.sh desde el asset gobernado del runtime. El guard sigue leyéndolo de
+# disco (cero red en PreToolUse); solo avisa si el contexto local está sin sincronizar.
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HERE/lib/projection.sh"
 ALLOW="$ROOT/.claude/config/stack-allowlist.json"
 [ -f "$ALLOW" ] || exit 0
 
@@ -80,6 +85,9 @@ if [ -n "$VIOL" ]; then
   echo "⛔ stack-guard: dependencias fuera del stack declarado del PRD (allowlist): $VIOL" >&2
   echo "   Si es intencional, actualiza .claude/config/stack-allowlist.json y deja nota en GOVERNANCE.md," >&2
   echo "   o consulta al agente stack-guardian. Allowlist: .claude/config/stack-allowlist.json" >&2
+  if [ "$(runtime_mode)" != "legacy" ] && projection_is_stale; then
+    echo "   ⚠ Contexto local sin sincronizar (stale): el allowlist puede estar desactualizado respecto al runtime." >&2
+  fi
   exit 2
 fi
 exit 0

package/hooks/build/statusline-bridge.sh

@@ -1,15 +1,36 @@
 #!/usr/bin/env bash
 # statusline-bridge.sh — statusLine command (canal CLI). Imprime la línea de estado
 # y escribe el puente de contexto que lee context-monitor.sh. Fail-open siempre.
+# [EP-OR-08-B] En dual/runtime añade el plano de contexto: versión sincronizada (✓ vN),
+# proyección sin refrescar (⚠ stale) y lease perdido (⚠ lease). Cero red: todo sale de
+# ficheros locales (caché de proyección y estado del daemon).
 set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 payload="$(cat)"
 command -v python3 >/dev/null 2>&1 || { echo "🏗️ build"; exit 0; }
-echo "$payload" | python3 -c '
+
+source "$HERE/lib/runtime-client.sh"
+source "$HERE/lib/projection.sh"
+
+CTXTAG=""
+if [ "$(runtime_mode)" != "legacy" ]; then
+  if projection_is_stale; then
+    CTXTAG=" · ⚠ stale"
+  else
+    ver="$(projection_get context.version "")"
+    [ -n "$ver" ] && CTXTAG=" · ✓ v$ver"
+  fi
+  if grep -q '"lease_lost": true' "$(config_root)/.claude/state/heartbeat-status.json" 2>/dev/null; then
+    CTXTAG="$CTXTAG · ⚠ lease"
+  fi
+fi
+
+echo "$payload" | CTXTAG="$CTXTAG" python3 -c '
 import json,sys,os,time,re,tempfile
 try:
     p=json.load(sys.stdin)
 except Exception:
-    print("🏗️ build"); sys.exit(0)
+    print("🏗️ build"+os.environ.get("CTXTAG","")); sys.exit(0)
 sid=str(p.get("session_id","default"))
 if re.search(r"[\\/]|\.\.", sid): sid=re.sub(r"[^A-Za-z0-9_-]","_",sid)  # sanitiza path traversal
 rem=None
@@ -28,5 +49,5 @@ if rem is not None:
             except OSError: pass
     except Exception: pass
 tag = f"🏗️ build · ctx {rem}%" if rem is not None else "🏗️ build"
-print(tag)
+print(tag+os.environ.get("CTXTAG",""))
 ' 2>/dev/null || echo "🏗️ build"

package/hooks/build-harness.json

@@ -4,6 +4,10 @@
       {
         "matcher": "startup|clear|compact",
         "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/session-start.sh\""
+          },
           {
             "type": "command",
             "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/load-build-state.sh\""
@@ -59,6 +63,10 @@
           {
             "type": "command",
             "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/context-monitor.sh\""
+          },
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/event-emitter.sh\""
           }
         ]
       }
@@ -90,9 +98,17 @@
             "type": "command",
             "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/release-gate-nudge.sh\""
           },
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/dual-compare.sh\""
+          },
           {
             "type": "command",
             "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/context-monitor.sh\""
+          },
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/session-stop.sh\""
           }
         ]
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trycore/spec-build-harness",
-  "version": "0.8.4",
+  "version": "0.10.0",
   "description": "Arnés agéntico de construcción de Trycore para Claude Code: pipeline de dos loops (slice por épica + release gate) con gates de calidad, estado compartido y OpenSpec. Compañero de @trycore/spec-product-flow. Agnóstico al proyecto.",
   "type": "module",
   "bin": {
@@ -17,7 +17,6 @@
     "state/",
     "templates/",
     "asset-types.json",
-    "internal/",
     "docs/",
     "!docs/superpowers",
     "scripts/",
@@ -32,7 +31,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build && bash scripts/check-version-sync.sh && bash scripts/check-agnostic.sh && bash scripts/check-state-clean.sh",
+    "test:unit": "tsc -p tsconfig.test.json && find dist-test -name '*.test.js' -print0 | xargs -0 node --test",
+    "prepublishOnly": "npm run build && npm run test:unit && bash scripts/check-version-sync.sh && bash scripts/check-agnostic.sh && bash scripts/check-runtime-purity.sh && bash scripts/check-state-clean.sh && bash scripts/check-pack-clean.sh",
     "test:smoke": "bash scripts/smoke-test.sh"
   },
   "keywords": [

package/scripts/check-agnostic.sh

@@ -47,6 +47,8 @@ TARGETS=(
   "$REPO_ROOT/config"
   "$REPO_ROOT/state"
   "$REPO_ROOT/templates"
+  "$REPO_ROOT/src"
+  "$REPO_ROOT/asset-types.json"
   "$REPO_ROOT/internal"
   "$REPO_ROOT/docs/customization"
   "$REPO_ROOT/METODOLOGIA.md"
@@ -59,7 +61,7 @@ TARGETS=(
 for target in "${TARGETS[@]}"; do
   [[ -e "$target" ]] || continue
   hits=$(grep -riEn -- "$PATTERN" "$target" 2>/dev/null \
-    --include='*.md' --include='*.json' --include='*.sh' --include='*.js' --include='*.mjs' \
+    --include='*.md' --include='*.json' --include='*.sh' --include='*.js' --include='*.mjs' --include='*.ts' \
     --exclude-dir='node_modules' || true)
   if [[ -n "$hits" ]]; then
     VIOLATIONS+=("$hits")

package/scripts/check-pack-clean.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# check-pack-clean: verifica que el tarball de npm NO incluya contenido no distribuible.
+# Regla del repo (CLAUDE.md): MAINTAINERS.md, internal/ y docs/superpowers/ no se distribuyen en npm.
+# Corre en prepublishOnly: si algo de eso entra al pack, bloquea la publicación.
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$REPO_ROOT"
+
+echo "▶ check-pack-clean: verificando el contenido del tarball (npm pack --dry-run)…"
+
+# Lista de rutas prohibidas en el paquete publicado (relativas a la raíz del tarball).
+FORBIDDEN='^(internal/|MAINTAINERS\.md$|docs/superpowers/)'
+
+FILES="$(npm pack --dry-run --json 2>/dev/null | python3 -c '
+import json, sys
+data = json.load(sys.stdin)
+for f in data[0]["files"]:
+    print(f["path"])
+')"
+
+LEAKS="$(printf '%s\n' "$FILES" | grep -E "$FORBIDDEN" || true)"
+
+if [ -n "$LEAKS" ]; then
+  echo "✗ Contenido NO distribuible dentro del tarball:" >&2
+  printf '%s\n' "$LEAKS" | sed 's/^/    /' >&2
+  echo "  Revisa package.json#files (regla: MAINTAINERS.md, internal/ y docs/superpowers/ no se publican)." >&2
+  exit 1
+fi
+
+echo "✓ Tarball limpio: sin internal/, MAINTAINERS.md ni docs/superpowers/."

package/scripts/check-runtime-purity.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# check-runtime-purity.sh — ratchet de la migración v0.9 [EP-OR-08-C].
+# Prohíbe que skills/, commands/ y agents/ instruyan el protocolo del FICHERO local
+# (.claude/state/build-state.json) fuera de dos excepciones declaradas:
+#   (a) los ficheros listados en scripts/runtime-purity-allow.txt — documentación del
+#       modo `legacy`, que vive mientras viva legacy (spec §4.2-E);
+#   (b) líneas que declaran explícitamente el modo `legacy` (una tabla de modos, una nota
+#       «en legacy … »): ahí la mención es correcta y necesaria.
+# Salida 0 si limpio, 1 si hay menciones fuera de esas excepciones. Corre en prepublishOnly.
+set -uo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+ALLOW="$ROOT/scripts/runtime-purity-allow.txt"
+PATTERN='build-state\.json|build-state\.schema\.json|build_state'
+
+hits="$(grep -rEn -- "$PATTERN" "$ROOT/skills" "$ROOT/commands" "$ROOT/agents" \
+  --include='*.md' --include='*.js' --include='*.json' 2>/dev/null || true)"
+
+fail=0
+violaciones=""
+while IFS= read -r linea; do
+  [ -n "$linea" ] || continue
+  archivo="${linea%%:*}"
+  rel="${archivo#$ROOT/}"
+  if [ -f "$ALLOW" ] && grep -qxF "$rel" "$ALLOW" 2>/dev/null; then continue; fi
+  # (b) la línea declara el modo legacy
+  case "$linea" in
+    *legacy*|*LEGACY*|*Legacy*) continue ;;
+  esac
+  violaciones="$violaciones
+$linea"
+  fail=1
+done <<< "$hits"
+
+if [ "$fail" = 0 ]; then
+  echo "✓ check-runtime-purity: skills/commands/agents no instruyen el fichero de estado fuera de legacy."
+  exit 0
+fi
+echo "✗ check-runtime-purity: menciones del fichero de estado fuera de las excepciones declaradas:"
+echo "$violaciones"
+echo ""
+echo "Migra el protocolo a slice-ops.sh/release-ops.sh, o declara la línea como modo legacy,"
+echo "o añade el fichero a scripts/runtime-purity-allow.txt si es documentación de legacy."
+exit 1

package/scripts/lib/front-plan.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 """front-plan.py — selecciona el conjunto disjunto máximo de épicas no fundacionales.
 
+[EP-OR-08-C] Este script SIGUE SIENDO LOCAL (spec §4.2-C rev. 4): es el generador del plan
+(conjunto disjunto + merge_order) que un humano aprueba al abrir el front en la consola del
+hub. No llama al runtime ni lee el estado: entra JSON por stdin, sale JSON por stdout.
+
 stdin: JSON [{"epica","layer","files_scope":[glob]}]
 stdout: {"selected":[...],"serialized":[{"epica","reason"}],"excluded_foundational":[...]}
 Determinista: orden por 'epica'. Solape de globs por prefijo de directorio o glob idéntico.

package/scripts/lib/graph-bundle.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""graph-bundle.py — prepara el BUNDLE DE GRAFO que un ADMIN sube en la consola del hub.
+
+[EP-OR-08-C] El import del grafo es un acto de GOBIERNO (spec §4.1-D rev. 4): la superficie
+`POST …/graph/import` exige sesión de ADMIN y rechaza el token de agente. Por eso el arnés
+**prepara y valida** el bundle en local — nunca lo sube — y `/build:onboard` se lo entrega a
+una persona.
+
+Uso:
+    python3 graph-bundle.py < epics.json > bundle.json      # avisos por stderr
+
+Entrada (stdin, JSON):
+    {"project_ref": "…",
+     "epics": [{"code","title","layer","files_scope":[],"depends_on":[],
+                "stories":[{"id","title"}]}],
+     "release_lines": [{"id","epics":[]}]}
+
+Salida (stdout, JSON): el bundle normalizado y DETERMINISTA (orden estable por código);
+los problemas no bloquean: se listan como avisos en stderr y en `warnings` del bundle, con
+el criterio del arnés — nada se pierde en silencio, nada bloquea la preparación.
+
+Códigos de salida: 0 = bundle generado (con o sin avisos) · 1 = entrada ilegible.
+"""
+import json
+import sys
+import datetime
+
+BUNDLE_VERSION = 1
+
+
+def norm_list(v):
+    return [x for x in v if isinstance(x, str)] if isinstance(v, list) else []
+
+
+def main():
+    avisos = []
+    try:
+        raw = json.load(sys.stdin)
+    except Exception as e:
+        print("graph-bundle: entrada ilegible (se esperaba JSON por stdin): %s" % e,
+              file=sys.stderr)
+        return 1
+    if not isinstance(raw, dict):
+        print("graph-bundle: la entrada debe ser un objeto JSON", file=sys.stderr)
+        return 1
+
+    epicas = {}
+    for e in raw.get("epics") or []:
+        if not isinstance(e, dict):
+            continue
+        code = e.get("code")
+        if not isinstance(code, str) or not code:
+            avisos.append("épica sin `code`: descartada")
+            continue
+        if code in epicas:
+            avisos.append("código duplicado %s: se conserva la PRIMERA aparición" % code)
+            continue
+        if not e.get("layer"):
+            avisos.append("%s sin `layer`: el DoR no podrá aplicar la regla de cimiento" % code)
+        historias = []
+        for h in e.get("stories") or []:
+            if isinstance(h, dict) and isinstance(h.get("id"), str):
+                historias.append({"id": h["id"], "title": h.get("title")})
+        epicas[code] = {
+            "code": code,
+            "title": e.get("title"),
+            "layer": e.get("layer"),
+            "files_scope": sorted(norm_list(e.get("files_scope"))),
+            "depends_on": sorted(norm_list(e.get("depends_on"))),
+            "stories": sorted(historias, key=lambda h: h["id"]),
+        }
+
+    for code, e in epicas.items():
+        for dep in e["depends_on"]:
+            if dep not in epicas:
+                avisos.append("%s depende de %s, que no está en el grafo" % (code, dep))
+
+    # Ciclos: DFS iterativa (nada de recursión: un grafo hostil no debe reventar la pila).
+    estado = {}
+    for raiz in sorted(epicas):
+        if estado.get(raiz):
+            continue
+        pila = [(raiz, iter(epicas[raiz]["depends_on"]))]
+        estado[raiz] = 1
+        while pila:
+            nodo, it = pila[-1]
+            avanzo = False
+            for dep in it:
+                if dep not in epicas:
+                    continue
+                if estado.get(dep) == 1:
+                    avisos.append("ciclo de dependencias detectado: %s → %s" % (nodo, dep))
+                    continue
+                if not estado.get(dep):
+                    estado[dep] = 1
+                    pila.append((dep, iter(epicas[dep]["depends_on"])))
+                    avanzo = True
+                    break
+            if not avanzo:
+                estado[nodo] = 2
+                pila.pop()
+
+    lineas = []
+    for r in raw.get("release_lines") or []:
+        if not isinstance(r, dict) or not isinstance(r.get("id"), str):
+            continue
+        miembros = [c for c in norm_list(r.get("epics"))]
+        for c in miembros:
+            if c not in epicas:
+                avisos.append("la línea %s referencia %s, que no está en el grafo" % (r["id"], c))
+        lineas.append({"id": r["id"], "epics": miembros})
+    lineas.sort(key=lambda r: r["id"])
+
+    bundle = {
+        "bundle_version": BUNDLE_VERSION,
+        "kind": "graph",
+        "project_ref": raw.get("project_ref"),
+        "generated_at": datetime.datetime.now(datetime.timezone.utc)
+                        .strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "generated_by": "trycore-build-harness/graph-bundle.py",
+        "epics": [epicas[c] for c in sorted(epicas)],
+        "release_lines": lineas,
+        "warnings": avisos,
+    }
+    json.dump(bundle, sys.stdout, indent=2, ensure_ascii=False, sort_keys=False)
+    sys.stdout.write("\n")
+    for a in avisos:
+        print("aviso: %s" % a, file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/runtime-purity-allow.txt

@@ -0,0 +1,5 @@
+# Ficheros que TODAVÍA instruyen el protocolo del fichero de estado local.
+# Es un ratchet: cada tarea de EP-OR-08-C quita los suyos y el check impide que vuelvan.
+# Al cerrar el sub-slice debe quedar SOLO el protocolo legacy, que vive mientras viva
+# legacy (spec §4.2-E).
+skills/building-a-slice/references/state-protocol.md

package/scripts/smoke-test.sh

@@ -5,7 +5,7 @@ DIR="$(cd "$(dirname "$0")" && pwd)"
 FAILED=0
 
 echo "── Tests del motor de contexto y front ──"
-for t in test-schema.sh test-reconciler.sh test-context-monitor.sh test-front-plan.sh test-install.sh; do
+for t in test-schema.sh test-config.sh test-runtime-client.sh test-hooks-runtime.sh test-skill-ops.sh test-reconciler.sh test-context-monitor.sh test-front-plan.sh test-install.sh; do
   if bash "$DIR/tests/$t"; then echo "smoke: $t OK"; else echo "smoke: $t FALLÓ"; FAILED=1; fi
 done
 

package/scripts/tests/lib/http-stub.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Stub HTTP mínimo del runtime para tests de runtime-client.sh, sin depender del hub
+real (que se construye en otro repo/sesión — EP-OR-13). Uso:
+  python3 http-stub.py <port> <routes.json> <calls-log.jsonl>
+routes.json: {"METHOD /path": {"status": 200, "body": {...}}, ...} — se relee EN CADA
+request (no solo al arrancar), así un test puede reescribir routes.json a mitad de
+ejecución para simular una segunda respuesta del mismo endpoint.
+Cada request recibida se apendiza como una línea JSON en calls-log.jsonl (método, path,
+header Authorization, body) para que el test verifique lo que el cliente envió.
+"""
+import sys, json, http.server
+
+PORT = int(sys.argv[1])
+ROUTES_PATH = sys.argv[2]
+CALLS_LOG = sys.argv[3]
+
+
+class Handler(http.server.BaseHTTPRequestHandler):
+    def _handle(self, method):
+        length = int(self.headers.get('Content-Length', 0) or 0)
+        body = self.rfile.read(length) if length else b''
+        with open(CALLS_LOG, 'a') as f:
+            f.write(json.dumps({
+                "method": method, "path": self.path,
+                "auth": self.headers.get('Authorization', ''),
+                "body": body.decode('utf-8', 'replace'),
+            }) + "\n")
+        try:
+            routes = json.loads(open(ROUTES_PATH).read())
+        except Exception:
+            routes = {}
+        key = f"{method} {self.path}"
+        route = routes.get(key, {"status": 404, "body": {"error": "not_found"}})
+        self.send_response(route["status"])
+        self.send_header('Content-Type', 'application/json')
+        self.end_headers()
+        self.wfile.write(json.dumps(route["body"]).encode('utf-8'))
+
+    def do_GET(self): self._handle("GET")
+    def do_POST(self): self._handle("POST")
+    def do_PUT(self): self._handle("PUT")
+    def log_message(self, *a): pass
+
+
+if __name__ == "__main__":
+    http.server.HTTPServer(("127.0.0.1", PORT), Handler).serve_forever()

package/scripts/tests/test-baseline-verdict.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# test-baseline-verdict.sh — prueba baseline-verdict.sh (skill building-a-slice) contra
+# un repo git temporal con remoto local y una suite fake de rojos controlados.
+set -uo pipefail
+ROOT="$(git rev-parse --show-toplevel)"
+SCRIPT="$ROOT/skills/building-a-slice/assets/baseline-verdict.sh"
+[ -f "$SCRIPT" ] || { echo "FAIL no existe baseline-verdict.sh"; exit 1; }
+fail=0
+TMP="$(mktemp -d)"; trap 'rm -rf "$TMP"' EXIT
+
+# ── Fixture: remoto bare + clon con suite fake ───────────────────────────────
+git init --quiet --bare "$TMP/remote.git"
+git clone --quiet "$TMP/remote.git" "$TMP/proj" 2>/dev/null
+cd "$TMP/proj"
+git config user.email t@t.local && git config user.name t
+git symbolic-ref HEAD refs/heads/main
+
+# Suite fake agnóstica: cada tests/*.txt con contenido "red" pinta "FAIL <fichero>".
+cat > suite.sh <<'SH'
+#!/usr/bin/env bash
+rc=0
+for f in tests/*.txt; do
+  if grep -q red "$f"; then echo "FAIL $f"; rc=1; else echo "PASS $f"; fi
+done
+exit $rc
+SH
+mkdir tests
+echo red   > tests/heredado.txt   # rojo ambiental heredado
+echo green > tests/sano.txt
+git add -A && git commit --quiet -m base && git push --quiet -u origin main 2>/dev/null
+
+export BASELINE_SUITE_CMD="bash suite.sh"
+export BASELINE_LINK_DIRS=""
+
+# ── capture contra origin/main escribe el JSON con el rojo heredado ──────────
+SHA="$(git rev-parse origin/main)"
+bash "$SCRIPT" capture origin/main >/dev/null 2>&1
+[ $? -eq 0 ] && echo "OK capture rc=0" || { echo "FAIL capture rc"; fail=1; }
+CACHE=".baseline/baseline-verdict.${SHA}.json"
+[ -f "$CACHE" ] && echo "OK capture escribe JSON por sha" || { echo "FAIL falta $CACHE"; fail=1; }
+python3 - "$CACHE" "$SHA" <<'PY' && echo "OK contenido del veredicto" || { echo "FAIL contenido del veredicto"; fail=1; }
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert d["sha"] == sys.argv[2], d["sha"]
+assert d["red_files"] == ["tests/heredado.txt"], d["red_files"]
+assert d["captured_at"] and d["suite_cmd"], d
+PY
+
+# ── compare sin cambios: heredado no cuenta como regresión ───────────────────
+out="$(bash "$SCRIPT" compare origin/main 2>&1)"; rc=$?
+[ $rc -eq 0 ] && echo "OK compare limpio rc=0" || { echo "FAIL compare limpio (rc=$rc)"; fail=1; }
+echo "$out" | grep -q "heredados sin cambio: 1" && echo "OK reporta heredado" || { echo "FAIL no reporta heredado"; fail=1; }
+
+# ── regresión nueva en el working tree → rc=1 y la nombra ────────────────────
+echo red > tests/sano.txt
+out="$(bash "$SCRIPT" compare origin/main 2>&1)"; rc=$?
+[ $rc -eq 1 ] && echo "OK compare detecta regresión (rc=1)" || { echo "FAIL rc regresión (rc=$rc)"; fail=1; }
+echo "$out" | grep -q "tests/sano.txt" && echo "OK nombra el fichero regresado" || { echo "FAIL no nombra la regresión"; fail=1; }
+
+# ── arreglo del heredado → rc=0 y cuenta 1 arreglado ─────────────────────────
+echo green > tests/sano.txt
+echo green > tests/heredado.txt
+out="$(bash "$SCRIPT" compare origin/main 2>&1)"; rc=$?
+[ $rc -eq 0 ] && echo "OK compare tras arreglo rc=0" || { echo "FAIL rc tras arreglo (rc=$rc)"; fail=1; }
+echo "$out" | grep -q "arreglados         : 1" && echo "OK cuenta arreglado" || { echo "FAIL no cuenta arreglado"; fail=1; }
+git checkout --quiet -- tests
+
+# ── GUARD: ref local rechazado con rc=2 ──────────────────────────────────────
+out="$(bash "$SCRIPT" capture main 2>&1)"; rc=$?
+[ $rc -eq 2 ] && echo "OK guard rechaza ref local (rc=2)" || { echo "FAIL guard ref local (rc=$rc)"; fail=1; }
+echo "$out" | grep -qi "origin/<destino>" && echo "OK guard explica el porqué" || { echo "FAIL guard sin mensaje"; fail=1; }
+
+# ── GUARD: sha solo-local (no pusheado) rechazado ────────────────────────────
+git checkout --quiet -b feature/local
+echo x > local.txt && git add local.txt && git commit --quiet -m local
+LOCAL_SHA="$(git rev-parse HEAD)"
+out="$(bash "$SCRIPT" capture "$LOCAL_SHA" 2>&1)"; rc=$?
+[ $rc -eq 2 ] && echo "OK guard rechaza sha no remoto (rc=2)" || { echo "FAIL guard sha local (rc=$rc)"; fail=1; }
+git checkout --quiet main
+
+# ── sha remoto verificado sí pasa el guard (capture por sha) ─────────────────
+bash "$SCRIPT" capture "$SHA" >/dev/null 2>&1
+[ $? -eq 0 ] && echo "OK acepta sha contenido en rama remota" || { echo "FAIL sha remoto rechazado"; fail=1; }
+
+# ── invalidación: el remoto avanza → compare pide re-capturar (rc=3) ─────────
+echo green > tests/nuevo.txt && git add tests/nuevo.txt && git commit --quiet -m avanza
+git push --quiet origin main 2>/dev/null
+out="$(bash "$SCRIPT" compare origin/main 2>&1)"; rc=$?
+[ $rc -eq 3 ] && echo "OK cache invalidado al avanzar el remoto (rc=3)" || { echo "FAIL invalidación (rc=$rc)"; fail=1; }
+echo "$out" | grep -q "re-captura" && echo "OK pide re-capturar" || { echo "FAIL no pide re-capturar"; fail=1; }
+
+exit $fail

package/scripts/tests/test-config.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -uo pipefail
+ROOT="$(git rev-parse --show-toplevel)"
+source "$ROOT/hooks/build/lib/config.sh" 2>/dev/null || { echo "FAIL no existe lib/config.sh"; exit 1; }
+fail=0
+TMP="$(mktemp -d)"; trap 'rm -rf "$TMP"' EXIT
+
+echo '{"context":{"warning_pct":40},"runtime":{"mode":"dual"}}' > "$TMP/cfg.json"
+got="$(BUILD_CONFIG_FILE="$TMP/cfg.json" config_get context.warning_pct 35)"
+[ "$got" = 40 ] && echo "OK config_get valor" || { echo "FAIL config_get valor ($got)"; fail=1; }
+got="$(BUILD_CONFIG_FILE="$TMP/cfg.json" config_get context.critical_pct 25)"
+[ "$got" = 25 ] && echo "OK config_get default" || { echo "FAIL config_get default ($got)"; fail=1; }
+got="$(BUILD_CONFIG_FILE="$TMP/cfg.json" config_get runtime.mode legacy)"
+[ "$got" = dual ] && echo "OK config_get anidado" || { echo "FAIL config_get anidado ($got)"; fail=1; }
+
+# Regresión: state-io.sh sigue exponiendo config_get vía sourcing, cero cambio de
+# comportamiento. Subshell AISLADO que solo sourcea state-io.sh (nunca config.sh
+# directamente) — si state-io.sh dejara de sourcear config.sh, config_get no existiría
+# aquí y el subshell fallaría. Sourcear ambos en el shell del test (como antes) no
+# probaba nada: config_get ya estaba definida por el primer source, pasara lo que
+# pasara con el segundo.
+got="$(bash -c 'source "$1/hooks/build/lib/state-io.sh" 2>/dev/null && BUILD_CONFIG_FILE="$2" config_get context.warning_pct 35' _ "$ROOT" "$TMP/cfg.json" 2>&1)"
+[ "$got" = 40 ] && echo "OK state-io re-exporta config_get" || { echo "FAIL state-io no re-exporta ($got)"; fail=1; }
+
+exit $fail