@trycore/spec-build-harness 0.10.0 → 0.11.0

package/scripts/lib/graph-bundle.py

@@ -6,13 +6,21 @@
 **prepara y valida** el bundle en local — nunca lo sube — y `/build:onboard` se lo entrega a
 una persona.
 
+[issue #41] `epics` sale en el FORMATO EXACTO del hub (`GraphService.import_graph`,
+`validate_graph`): `layer` en MAYÚSCULA (`VALID_LAYERS = {FOUNDATIONAL, BUSINESS}` — un layer
+inválido rechaza el grafo ENTERO, GraphIntegrityError), historias con `code` + `title`
+(el hub hace `story_in["code"]`), `title` obligatorio por épica e historia, y `release_line`
+como string POR ÉPICA (las `release_lines` de la entrada se pliegan aquí). Así el mismo
+objeto sirve para la pantalla de import del grafo y para embeberse como sección `graph`
+del bundle de estado (`trycore-build migrate`).
+
 Uso:
     python3 graph-bundle.py < epics.json > bundle.json      # avisos por stderr
 
-Entrada (stdin, JSON):
+Entrada (stdin, JSON — formato de discovery, sin cambios):
     {"project_ref": "…",
      "epics": [{"code","title","layer","files_scope":[],"depends_on":[],
-                "stories":[{"id","title"}]}],
+                "stories":[{"id"|"code","title"}]}],
      "release_lines": [{"id","epics":[]}]}
 
 Salida (stdout, JSON): el bundle normalizado y DETERMINISTA (orden estable por código);
@@ -25,7 +33,10 @@ import json
 import sys
 import datetime
 
-BUNDLE_VERSION = 1
+BUNDLE_VERSION = 2
+
+# El contrato del hub: `validate_graph` rechaza el grafo ENTERO si un layer no está aquí.
+VALID_LAYERS = {"FOUNDATIONAL", "BUSINESS"}
 
 
 def norm_list(v):
@@ -55,20 +66,52 @@ def main():
         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)
+        # `title` es obligatorio en el hub (EpicIn, min_length=1): cae al código.
+        titulo = e.get("title")
+        if not isinstance(titulo, str) or not titulo:
+            avisos.append("%s sin `title`: se usa el código (el hub lo exige)" % code)
+            titulo = code
+        # `layer` viaja en MAYÚSCULA; ausente o inválido, el import del hub
+        # rechaza el grafo ENTERO (GraphIntegrityError) — se avisa, no se inventa.
+        layer = e.get("layer")
+        if isinstance(layer, str) and layer:
+            layer = layer.upper()
+            if layer not in VALID_LAYERS:
+                avisos.append("%s con layer %r fuera de FOUNDATIONAL|BUSINESS: "
+                              "el hub rechazará el grafo entero" % (code, e.get("layer")))
+        else:
+            layer = None
+            avisos.append("%s sin `layer`: el hub rechazará el grafo entero "
+                          "(FOUNDATIONAL|BUSINESS)" % 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] = {
+            if not isinstance(h, dict):
+                continue
+            # El hub hace `story_in["code"]`; la entrada de discovery trae `id`.
+            hcode = h.get("code") if isinstance(h.get("code"), str) else h.get("id")
+            if not isinstance(hcode, str) or not hcode:
+                continue
+            htitle = h.get("title")
+            if not isinstance(htitle, str) or not htitle:
+                avisos.append("%s: historia %s sin `title`: se usa el código" % (code, hcode))
+                htitle = hcode
+            historias.append({"code": hcode, "title": htitle})
+        epica = {
             "code": code,
-            "title": e.get("title"),
-            "layer": e.get("layer"),
+            "title": titulo,
+            "layer": 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"]),
+            "release_line": e.get("release_line")
+                            if isinstance(e.get("release_line"), str) else None,
+            "stories": sorted(historias, key=lambda h: h["code"]),
         }
+        # Opcionales del contrato del hub: pasan tal cual si vienen bien tipados.
+        if isinstance(e.get("priority"), int):
+            epica["priority"] = e["priority"]
+        if isinstance(e.get("docs_ref"), str):
+            epica["docs_ref"] = e["docs_ref"]
+        epicas[code] = epica
 
     for code, e in epicas.items():
         for dep in e["depends_on"]:
@@ -100,16 +143,22 @@ def main():
                 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:
+    # Las `release_lines` de la entrada se PLIEGAN al `release_line` (string) por
+    # épica que el hub persiste — gana la primera asignación (orden estable por id).
+    lineas = [r for r in (raw.get("release_lines") or [])
+              if isinstance(r, dict) and isinstance(r.get("id"), str)]
+    lineas.sort(key=lambda r: r["id"])
+    for r in lineas:
+        for c in norm_list(r.get("epics")):
             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"])
+                continue
+            if epicas[c]["release_line"] is None:
+                epicas[c]["release_line"] = r["id"]
+            elif epicas[c]["release_line"] != r["id"]:
+                avisos.append("%s ya está en la línea %s: se ignora %s "
+                              "(el hub guarda UNA línea por épica)"
+                              % (c, epicas[c]["release_line"], r["id"]))
 
     bundle = {
         "bundle_version": BUNDLE_VERSION,
@@ -119,7 +168,6 @@ def main():
                         .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)

package/scripts/tests/test-hooks-runtime.sh

@@ -380,44 +380,19 @@ echo '{"tool_name":"Edit","tool_input":{"file_path":"'"$PROJ"'/src/a.ts"}}' \
 n="$(find "$PROJ/.claude/state/outbox" -maxdepth 1 -name '*.json' 2>/dev/null | wc -l | tr -d ' ')"
 [ "$n" = 0 ] && echo "OK event-emitter no-op en legacy" || { echo "FAIL event-emitter encolo en legacy ($n)"; fail=1; }
 
-echo '{"tool_name":"Edit","tool_input":{"file_path":"'"$PROJ"'/src/a.ts"}}' \
-  | bash "$ROOT/hooks/build/event-emitter.sh" >/dev/null 2>&1
-ev="$(python3 -c "
-import json,glob
-files=sorted(p for p in glob.glob('$PROJ/.claude/state/outbox/*.json') if not p.endswith('.dispatch-state.json'))
-d=json.load(open(files[0]))
-print(d['type'], d.get('slice_id'), d['payload'].get('path'), d['payload'].get('tool'))
-" 2>/dev/null)"
-[ "$ev" = "tool_use_recorded sl-11 src/a.ts Edit" ] && echo "OK event-emitter encola ruta relativa con slice_id" || { echo "FAIL evento ($ev)"; fail=1; }
-
-# Bash: solo el binario, jamás el comando completo (puede llevar secretos — protocolo §8).
-rm -f "$PROJ"/.claude/state/outbox/*.json
-echo '{"tool_name":"Bash","tool_input":{"command":"curl -H \"Authorization: Bearer SECRETO\" https://x"}}' \
-  | bash "$ROOT/hooks/build/event-emitter.sh" >/dev/null 2>&1
-body="$(cat "$PROJ"/.claude/state/outbox/*.json 2>/dev/null)"
-echo "$body" | grep -q 'SECRETO' && { echo "FAIL event-emitter filtra el comando completo"; fail=1; } || echo "OK event-emitter no filtra el comando"
-echo "$body" | grep -q '"argv0": *"curl"' && echo "OK event-emitter reporta solo argv0" || { echo "FAIL argv0 ($body)"; fail=1; }
-
-# Bash: secreto en asignación de entorno inline al frente del comando (`VAR=valor cmd ...`)
-# tampoco debe filtrarse — argv0 debe ser el binario, no la asignación (protocolo §8).
-rm -f "$PROJ"/.claude/state/outbox/*.json
-echo '{"tool_name":"Bash","tool_input":{"command":"API_TOKEN=sk-live-XYZ curl https://api.example.com"}}' \
-  | bash "$ROOT/hooks/build/event-emitter.sh" >/dev/null 2>&1
-body="$(cat "$PROJ"/.claude/state/outbox/*.json 2>/dev/null)"
-echo "$body" | grep -q 'sk-live-XYZ' && { echo "FAIL event-emitter filtra secreto en asignacion de entorno"; fail=1; } || echo "OK event-emitter no filtra secreto en asignacion de entorno"
-echo "$body" | grep -q 'API_TOKEN' && { echo "FAIL event-emitter filtra nombre de variable de entorno"; fail=1; } || echo "OK event-emitter no filtra nombre de variable de entorno"
-echo "$body" | grep -q '"argv0": *"curl"' && echo "OK event-emitter salta asignacion de entorno y reporta binario" || { echo "FAIL argv0 con asignacion de entorno ($body)"; fail=1; }
-
-# Bash: el valor citado de la asignación de entorno inline lleva un espacio interno
-# (`KEY="a b" cmd`) — una tokenización naïve por espacios trocearía el valor citado y el
-# segundo fragmento (parte del secreto) se colaría como argv0. shlex debe tratarlo como
-# un solo token y seguir saltándolo.
-rm -f "$PROJ"/.claude/state/outbox/*.json
-echo '{"tool_name":"Bash","tool_input":{"command":"AWS_SECRET_ACCESS_KEY=\"abc def-secretpart\" aws s3 ls"}}' \
-  | bash "$ROOT/hooks/build/event-emitter.sh" >/dev/null 2>&1
-body="$(cat "$PROJ"/.claude/state/outbox/*.json 2>/dev/null)"
-echo "$body" | grep -q 'def-secretpart' && { echo "FAIL event-emitter filtra fragmento de secreto citado con espacio"; fail=1; } || echo "OK event-emitter no filtra fragmento de secreto citado con espacio"
-echo "$body" | grep -q '"argv0": *"aws"' && echo "OK event-emitter reporta binario con asignacion de entorno citada" || { echo "FAIL argv0 con asignacion citada ($body)"; fail=1; }
+# [#44] `tool_use_recorded` no existe en el catálogo v2 del hub: el hook YA NO encola
+# nada en ningún modo (era ruido garantizado en outbox/rejected/). Con ello desaparece
+# también toda superficie de fuga de secretos por payload (los casos de argv0/asignación
+# de entorno de v0.10.x quedan cubiertos por «no se encola nada»). Si el hub añade el
+# tipo al catálogo, se reactiva la emisión y estos casos vuelven en su forma granular.
+for tin in '{"tool_name":"Edit","tool_input":{"file_path":"'"$PROJ"'/src/a.ts"}}' \
+           '{"tool_name":"Bash","tool_input":{"command":"curl -H \"Authorization: Bearer SECRETO\" https://x"}}' \
+           '{"tool_name":"Bash","tool_input":{"command":"API_TOKEN=sk-live-XYZ curl https://api.example.com"}}'; do
+  echo "$tin" | bash "$ROOT/hooks/build/event-emitter.sh" >/dev/null 2>&1
+done
+n="$(find "$PROJ/.claude/state/outbox" -maxdepth 1 -name '*.json' 2>/dev/null | wc -l | tr -d ' ')"
+[ "$n" = 0 ] && echo "OK event-emitter en runtime no encola tool_use_recorded (fuera del catálogo v2, #44)" \
+  || { echo "FAIL event-emitter encolo un tipo fuera de catálogo ($n)"; fail=1; }
 
 # Sin slice reclamado: no se encola nada de ámbito slice (el servidor lo rechazaría).
 rm -f "$PROJ"/.claude/state/outbox/*.json

package/scripts/tests/test-install.sh

@@ -231,4 +231,50 @@ else
   fail=1
 fi
 
+# 8) `migrate --pre-harness` (issue #42): épicas construidas antes del arnés se
+#    importan archivadas SIN gates y con acta; el conflicto con un slice
+#    existente se rechaza.
+cat > "$TMP/.pre-harness.json" <<'EOF'
+{"epics": [{"code": "EP-001", "note": "MVP en producción"}], "as_of": "2026-04-01T00:00:00Z"}
+EOF
+node "$ROOT/dist/cli.js" migrate "$TMP" --project-ref acme --pre-harness "$TMP/.pre-harness.json" >"$TMP/.migrate-pre.log" 2>&1
+rc=$?
+if [ $rc -eq 0 ] && python3 -c "
+import json
+d=json.load(open('$BUNDLE'))
+assert len(d['history'])==1, d['history']
+entry=d['history'][0]
+assert entry['epic_code']=='EP-001', entry
+types=[e['event_type'] for e in entry['events']]
+assert 'gate_verdict' not in types, types
+assert types[0]=='slice_opened' and types[-1]=='slice_archived', types
+assert types.count('phase_advanced')==9, types
+notes=[e['payload']['note'] for e in entry['events'] if e['event_type']=='progress_noted']
+assert any('pre-arnés' in n and 'MVP en producción' in n for n in notes), notes
+" 2>/dev/null; then
+  echo "OK install: migrate --pre-harness importa la épica archivada sin gates y con acta"
+else
+  echo "FAIL install: migrate --pre-harness no generó la secuencia esperada (rc=$rc)"
+  cat "$TMP/.migrate-pre.log"
+  fail=1
+fi
+
+# Conflicto: la misma épica ya con slice en history[] debe rechazarse.
+python3 -c "
+import json
+p='$TMP/.claude/state/build-state.json'
+d=json.load(open(p))
+d['history']=[{'epica':'EP-001','phase':'archived','gates':{},'updated_at':'2026-08-14T00:00:00Z'}]
+json.dump(d, open(p,'w'))
+"
+node "$ROOT/dist/cli.js" migrate "$TMP" --project-ref acme --pre-harness "$TMP/.pre-harness.json" >"$TMP/.migrate-conf.log" 2>&1
+rc=$?
+if [ $rc -ne 0 ] && grep -q "pre-arnés" "$TMP/.migrate-conf.log"; then
+  echo "OK install: migrate --pre-harness rechaza la épica que ya tiene slice en history[]"
+else
+  echo "FAIL install: el conflicto pre-arnés/slice existente no se rechazó (rc=$rc)"
+  cat "$TMP/.migrate-conf.log"
+  fail=1
+fi
+
 exit $fail