@trycore/spec-build-harness 0.15.0 → 0.16.0

package/hooks/build/release-ops.sh

@@ -24,6 +24,7 @@ uso: release-ops.sh <subcomando> [opciones]
           [--resmoke pass|fail] [--evidence T | --evidence-file F]
 
 códigos de salida: 0 ok · 2 uso · 3 legacy · 5 offline · 6 rechazado
+                   · 9 identidad heredada (da de alta el worktree: `slice-ops.sh register`)
 USAGE
 }
 
@@ -135,9 +136,16 @@ HINT
 }
 
 # ── front-integration ────────────────────────────────────────────────────────────────
-# Cada worktree se registra como AGENTE PROPIO (mismo token de proyecto, `agent_key`
-# distinto): reporta la integración de SU miembro. Planificar, abrir, drenar y cerrar el
-# front siguen siendo humanos.
+# Cada worktree se registra como AGENTE PROPIO y reporta la integración de SU miembro.
+# Planificar, abrir, drenar y cerrar el front siguen siendo humanos.
+#
+# [#74] «Mismo token de proyecto, agent_key distinto» era falso y estuvo escrito aquí y en la
+# skill: el hub NO crea identidad en `POST /agents/register` — el `agent_key` es el `agent_id`
+# que el ADMIN grabó en el token al emitirlo. Un token por agente, o los dos worktrees son el
+# mismo agente. La compuerta va en el despacho (`ops_guard_own_identity`), no aquí: el
+# `[ -n "$akey" ]` de más abajo era inefectivo por construcción — leía la clave vía
+# `config_root()`, que en un worktree sin credenciales ya había heredado la del principal, así
+# que solo saltaba si el principal TAMPOCO estaba registrado.
 cmd_front_integration() {
   local front="${1:-}" merge="" resmoke="" ev="" evfile="" mode akey payload resp status
   [ -n "$front" ] || { usage; return $OPS_RC_USAGE; }
@@ -170,7 +178,10 @@ cmd_front_integration() {
     return $OPS_RC_OK
   fi
   akey="$(runtime_field agent_key)"
-  [ -n "$akey" ] || { echo "⛔ este worktree no está registrado como agente: corre \`trycore-build init\` en él" >&2; return $OPS_RC_REJECTED; }
+  [ -n "$akey" ] || {
+    echo "⛔ este árbol no tiene \`agent_key\`: da de alta el agente con" >&2
+    echo "   \`bash .claude/hooks/build/slice-ops.sh register\` (token propio del ADMIN)." >&2
+    return $OPS_RC_REJECTED; }
   resp="$(runtime_post "$(ops_path_front_integration "$(ops_urlenc "$front")" "$(ops_urlenc "$akey")")" "$payload")"
   status="$(runtime_http_status)"
   case "$status" in
@@ -192,6 +203,16 @@ cmd_front_integration() {
 
 SUB="${1:-}"
 [ $# -gt 0 ] && shift
+
+# [#74] Reportar la integración de un miembro del front es EL acto por-agente de este fichero
+# (la ruta lleva el `agent_key` en el path): desde un árbol con identidad heredada estaría
+# firmando por el agente del clon principal. `verdict` queda fuera de la compuerta a propósito
+# — un veredicto de release es del proyecto, no del agente, y se reporta desde el árbol
+# principal; `close-hint` no toca la red.
+case "$SUB" in
+  front-integration) ops_guard_own_identity "front-integration" || exit $? ;;
+esac
+
 case "$SUB" in
   verdict) cmd_verdict "$@"; exit $? ;;
   close-hint) cmd_close_hint "$@"; exit $? ;;

package/hooks/build/session-start.sh

@@ -11,6 +11,9 @@ HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "$HERE/lib/runtime-client.sh"
 source "$HERE/lib/projection.sh"
 source "$HERE/lib/agent-context.sh"
+# [#74] La versión del arnés y el catálogo de asset types viven en lib/harness-meta.sh:
+# `slice-ops.sh register` los necesita exactamente iguales para dar de alta un worktree.
+source "$HERE/lib/harness-meta.sh"
 
 cat >/dev/null 2>&1   # consumir el payload del hook (protocolo); no se usa aquí
 
@@ -19,67 +22,8 @@ MODE="$(runtime_mode)"
 command -v python3 >/dev/null 2>&1 || exit 0
 [ -n "$(runtime_url)" ] || exit 0   # sin `trycore-build init` (sub-slice D) no hay runtime
 
-# sst_pkg_root — raíz del PAQUETE (no del proyecto). Los hooks se instalan como symlinks
-# por fichero (linkChildren), así que hay que resolver la cadena de enlaces a mano:
-# `readlink -f` no es portable al BSD readlink de macOS.
-sst_pkg_root() {
-  local src="${BASH_SOURCE[0]}" target i=0
-  while [ -L "$src" ] && [ "$i" -lt 10 ]; do
-    target="$(readlink "$src" 2>/dev/null)" || break
-    case "$target" in
-      /*) src="$target" ;;
-      *)  src="$(dirname "$src")/$target" ;;
-    esac
-    i=$((i + 1))
-  done
-  (cd "$(dirname "$src")/../.." >/dev/null 2>&1 && pwd -P) 2>/dev/null
-}
-
-# sst_harness_version — versión instalada en el consumidor; si no, la del paquete.
-sst_harness_version() {
-  local f pkg
-  f="$(config_root)/.claude/.build-harness-version"
-  if [ -f "$f" ]; then
-    tr -d ' \n' < "$f"
-    return
-  fi
-  pkg="$(sst_pkg_root)"
-  if [ -n "$pkg" ] && [ -f "$pkg/VERSION" ]; then
-    tr -d ' \n' < "$pkg/VERSION"
-    return
-  fi
-  echo "0.0.0"
-}
-
-# sst_asset_types — el array `types` de asset-types.json del paquete (protocolo §6).
-# Cadena de resolución: plugin > copia en .claude/ (la siembra es del sub-slice D) >
-# paquete resuelto por symlink. Sin fichero: "[]" — el registro sigue funcionando.
-sst_asset_types() {
-  local pkg candidates f
-  pkg="$(sst_pkg_root)"
-  candidates="${CLAUDE_PLUGIN_ROOT:-}/asset-types.json
-$(config_root)/.claude/asset-types.json
-${pkg:-}/asset-types.json"
-  while IFS= read -r f; do
-    case "$f" in /asset-types.json|asset-types.json) continue ;; esac
-    [ -f "$f" ] || continue
-    python3 - "$f" <<'PY' 2>/dev/null && return
-import json,sys
-try:
-    d=json.load(open(sys.argv[1]))
-    t=d.get("types")
-    print(json.dumps(t if isinstance(t,list) else [],ensure_ascii=False))
-except Exception:
-    raise SystemExit(1)
-PY
-  done <<EOS
-$candidates
-EOS
-  echo "[]"
-}
-
-HV="$(sst_harness_version)"
-AT="$(sst_asset_types)"
+HV="$(harness_version)"
+AT="$(harness_asset_types)"
 
 runtime_register "$HV" "$AT"
 RC=$?

package/hooks/build/slice-ops.sh

@@ -17,12 +17,20 @@
 set -uo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "$HERE/lib/runtime-ops.sh"
+# [#74] `register` manda el mismo harness_version/asset_types que el arranque de sesión.
+source "$HERE/lib/harness-meta.sh"
 
 usage() {
   cat >&2 <<'USAGE'
 uso: slice-ops.sh <subcomando> [opciones]
 
   mode                                          imprime legacy|dual|runtime
+  register [--runtime-url U] [--force]          da de alta ESTE árbol como agente propio con
+                                                un token que el ADMIN emitió para él (el token
+                                                se pide por STDIN, nunca por argumento).
+                                                Obligatorio en un worktree antes de escribir:
+                                                sin él se opera con la identidad heredada del
+                                                clon principal.
   claim                                         reclama trabajo (solo modo runtime; el hub
                                                 reparte por orden de cola — no hay --epic)
   next-step                                     deriva la siguiente acción desde la caché
@@ -56,6 +64,7 @@ uso: slice-ops.sh <subcomando> [opciones]
   escalate «razón» | --file F [--gate G]        registra un bloqueo (la decisión es humana)
 
 códigos de salida: 0 ok · 2 uso · 3 legacy · 4 sin slice · 5 offline · 6 rechazado · 7 sin trabajo
+                   · 9 identidad heredada (este worktree no está dado de alta: `register`)
 USAGE
 }
 
@@ -1331,6 +1340,16 @@ cmd_status() {
     esac
   done
   mode="$(ops_mode)"
+  # [#74] `status` conserva el fallback a propósito — es la herramienta de diagnóstico de un
+  # worktree que todavía no se dio de alta, y negarle la lectura lo dejaría a ciegas. Pero se
+  # dice en la primera línea de quién es el estado que está mirando: sin el banner, un informe
+  # heredado es indistinguible de uno propio, y es exactamente así como se llega a creer que
+  # se tiene un lease que en realidad es de otro agente.
+  if config_is_inherited_root; then
+    echo "identidad:    ⚠ HEREDADA del clon principal ($(config_main_clone_root)) — solo lectura"
+    echo "              lo de abajo es el estado de ESE agente, no del tuyo. Antes de reclamar"
+    echo "              o reportar: \`slice-ops.sh register\` con un token propio del ADMIN."
+  fi
   echo "modo:         $mode"
   if [ "$mode" = "legacy" ]; then
     echo "estado:       el fichero .claude/state/build-state.json es la fuente de verdad (v0.8.5)"
@@ -1979,10 +1998,197 @@ cmd_checkpoint() {
   _ops_post_or_queue "$OPS_PATH_CHECKPOINTS" "$payload" checkpoint_recorded "$sid" "el checkpoint" "$queue_payload"
 }
 
+# ── register ─────────────────────────────────────────────────────────────────────────
+# [#74] Alta EXPLÍCITA de este árbol de trabajo como agente propio.
+#
+# El caso que lo motiva: dos agentes construyendo dos épicas en la misma máquina, cada uno en
+# su worktree. El hub reparte las dos sin objeción — el bloqueo estaba aquí: un worktree sin
+# `.claude/state/runtime.credentials` propio hereda el del clon principal por el fallback de
+# `config_root()` y trabaja con SU identidad sin decirlo.
+#
+# Tres decisiones de diseño que no son gratuitas:
+#   1. El token entra por STDIN (prompt si hay TTY), jamás por argumento: un `--token` queda
+#      en el historial del shell y en `ps`. Por eso `register` es un comando de terminal
+#      humano y NO se invoca desde dentro de un claim — los hooks y las tool calls no tienen
+#      TTY y un `read` ahí colgaría la llamada.
+#   2. Se siembra PRIMERO el fichero local, para que `config_root()` ancle en este árbol antes
+#      de cualquier merge. Al revés, `runtime_register` habría hecho upsert del token nuevo
+#      sobre el fichero del clon principal, pisándole la identidad al agente que trabaja ahí.
+#   3. Se valida que el `agent_key` obtenido DIFIERA del que tiene el principal. El hub no crea
+#      identidades en `/agents/register`: el `agent_key` es el `agent_id` que el ADMIN grabó en
+#      el token al emitirlo. Mismo token ⇒ mismo agente ⇒ el claim devolvería el trabajo del
+#      otro worktree. Un token por agente, siempre.
+#
+# Ante cualquier fallo se revierte: o el árbol queda con identidad propia y verificada, o
+# queda exactamente como estaba. Un fichero de credenciales a medias es peor que ninguno.
+
+# _reg_rollback <fichero> <backup> — deja el fichero local como estaba antes de `register`.
+_reg_rollback() {
+  local file="$1" backup="$2"
+  if [ -n "$backup" ] && [ -f "$backup" ]; then
+    cp "$backup" "$file" 2>/dev/null
+    rm -f "$backup"
+  else
+    rm -f "$file"
+  fi
+}
+
+cmd_register() {
+  local url="" force=0 wt main localfile mainfile mainkey newkey token backup="" hv at rc
+  while [ $# -gt 0 ]; do
+    case "$1" in
+      --runtime-url) url="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
+      --force) force=1; shift ;;
+      --token|--project-token|--runtime-token)
+        echo "⛔ el token NO se pasa por argumento: quedaría en el historial del shell y en \`ps\`." >&2
+        echo "   \`register\` lo pide por stdin. Córrelo en un terminal humano." >&2
+        return $OPS_RC_USAGE ;;
+      *) shift ;;
+    esac
+  done
+  command -v python3 >/dev/null 2>&1 || {
+    echo "⛔ register necesita python3 para escribir las credenciales." >&2; return $OPS_RC_OFFLINE; }
+
+  wt="$(config_candidate_root)"
+  main="$(config_main_clone_root)"
+  localfile="$wt/.claude/state/runtime.credentials"
+  mainfile=""
+  if [ -n "$main" ] && [ "$main" != "$wt" ]; then mainfile="$main/.claude/state/runtime.credentials"; fi
+
+  if [ -f "$localfile" ] && [ "$force" != 1 ]; then
+    echo "este árbol YA tiene identidad propia — no se toca nada:"
+    echo "  raíz:      $wt"
+    echo "  agente:    $(runtime_credentials_field_at "$localfile" agent_key)"
+    echo "  proyecto:  $(runtime_credentials_field_at "$localfile" project_id)"
+    echo "(para re-registrarlo con OTRO token: \`register --force\`)"
+    return $OPS_RC_OK
+  fi
+
+  # La URL no es secreta y es la MISMA del proyecto: se hereda del principal si no se da.
+  if [ -z "$url" ]; then
+    url="$(runtime_credentials_field_at "$localfile" runtime_url)"
+    [ -n "$url" ] || url="$(runtime_credentials_field_at "$mainfile" runtime_url)"
+  fi
+  case "$url" in
+    http://*|https://*) : ;;
+    *)
+      echo "⛔ no hay runtime_url que usar (ni --runtime-url, ni credenciales del clon principal)." >&2
+      echo "   Pásala explícita: \`register --runtime-url https://…\`" >&2
+      return $OPS_RC_USAGE ;;
+  esac
+
+  mainkey="$(runtime_credentials_field_at "$mainfile" agent_key)"
+
+  if [ -t 0 ]; then
+    printf 'Token de agente para este árbol (no se muestra en pantalla): ' >&2
+    IFS= read -rs token
+    printf '\n' >&2
+  else
+    IFS= read -r token || token=""
+  fi
+  token="$(printf '%s' "$token" | tr -d '[:space:]')"
+  [ -n "$token" ] || { echo "⛔ token vacío: no se registró nada." >&2; return $OPS_RC_USAGE; }
+
+  # Compuerta barata y decisiva, ANTES de la red: si el token es el del clon principal, el hub
+  # devolverá su misma identidad — el `agent_key` va grabado en el token, no se crea al
+  # registrar. Preguntarlo por HTTP solo añadiría una llamada al mismo veredicto.
+  if [ -n "$mainfile" ] && [ "$token" = "$(runtime_credentials_field_at "$mainfile" project_token)" ]; then
+    token=""
+    echo "⛔ ese token es la identidad del clon principal: registrarlo aquí daría el MISMO" >&2
+    echo "   agent_key y el claim te devolvería el trabajo que ya tiene reclamado el otro árbol." >&2
+    echo "   Pide al ADMIN un token con \`agent_id\` distinto (uno por agente)." >&2
+    echo "   El fichero del clon principal NO se ha tocado." >&2
+    return $OPS_RC_REJECTED
+  fi
+
+  if [ -f "$localfile" ]; then
+    backup="$(mktemp)" && cp "$localfile" "$backup" 2>/dev/null || backup=""
+  fi
+
+  if ! TRYCORE_REGISTER_TOKEN="$token" runtime_credentials_seed_at "$localfile" "$url"; then
+    token=""
+    _reg_rollback "$localfile" "$backup"
+    echo "⛔ no se pudo escribir $localfile — revisa permisos." >&2
+    return $OPS_RC_OFFLINE
+  fi
+  token=""   # el secreto ya está en el fichero 0600: fuera de las variables del shell
+
+  hv="$(harness_version)"
+  at="$(harness_asset_types)"
+  runtime_register "$hv" "$at"
+  rc=$?
+  if [ "$rc" -ne 0 ]; then
+    _reg_rollback "$localfile" "$backup"
+    if [ "$rc" -eq 2 ]; then
+      echo "⛔ el hub rechaza esta versión del arnés ($hv): incompatible_version." >&2
+      echo "   Actualiza el paquete y repite \`register\`." >&2
+      return $OPS_RC_REJECTED
+    fi
+    case "$(runtime_http_status)" in
+      401|403)
+        echo "⛔ el hub no acepta ese token (HTTP $(runtime_http_status)): pide al ADMIN uno válido" >&2
+        echo "   para este proyecto. Nada quedó escrito." >&2
+        return $OPS_RC_REJECTED ;;
+      *)
+        echo "OFFLINE: no se pudo registrar contra $url (HTTP $(runtime_http_status))." >&2
+        echo "  Nada quedó escrito: repite \`register\` cuando haya red." >&2
+        return $OPS_RC_OFFLINE ;;
+    esac
+  fi
+
+  newkey="$(runtime_credentials_field_at "$localfile" agent_key)"
+  if [ -z "$newkey" ]; then
+    _reg_rollback "$localfile" "$backup"
+    echo "⛔ el hub respondió 200 pero sin \`agent_key\`: sin identidad verificable no se da" >&2
+    echo "   de alta el árbol. Nada quedó escrito." >&2
+    return $OPS_RC_REJECTED
+  fi
+  if [ -n "$mainkey" ] && [ "$newkey" = "$mainkey" ]; then
+    _reg_rollback "$localfile" "$backup"
+    echo "⛔ ese token resuelve al MISMO agent_key que el clon principal ($mainkey): no es una" >&2
+    echo "   identidad nueva. El \`agent_key\` lo graba el ADMIN en el token al emitirlo —" >&2
+    echo "   pide uno con \`agent_id\` distinto. El fichero del clon principal NO se ha tocado." >&2
+    return $OPS_RC_REJECTED
+  fi
+  rm -f "$backup"
+
+  # A partir de aquí `config_root()` ancla en este árbol, y con él TODA la resolución de
+  # config: si `build-config.json` no viajó al worktree (no está versionado en el consumidor),
+  # `runtime.mode` caería al default `legacy` y el árbol recién dado de alta dejaría de hablar
+  # con el hub — el registro habría «funcionado» apagando justo lo que venía a encender. Se
+  # copia del principal solo si aquí no hay ninguno: nunca se pisa una config local.
+  if [ -n "$main" ] && [ ! -f "$wt/.claude/config/build-config.json" ] \
+     && [ -f "$main/.claude/config/build-config.json" ]; then
+    mkdir -p "$wt/.claude/config"
+    cp "$main/.claude/config/build-config.json" "$wt/.claude/config/build-config.json" 2>/dev/null \
+      && echo "  (build-config.json copiado del clon principal: modo $(ops_mode))"
+  fi
+
+  echo "árbol dado de alta con identidad propia:"
+  echo "  raíz:      $wt"
+  echo "  agente:    $newkey"
+  echo "  proyecto:  $(runtime_credentials_field_at "$localfile" project_id)"
+  [ -n "$mainkey" ] && echo "  (distinto del clon principal: $mainkey — su fichero no se tocó)"
+  echo "Desde aquí el claim, los gates y el heartbeat son de ESTE árbol. Siguiente paso:"
+  echo "  bash .claude/hooks/build/slice-ops.sh claim"
+  return $OPS_RC_OK
+}
+
 SUB="${1:-}"
 [ $# -gt 0 ] && shift
+
+# [#74] Compuerta de identidad ANTES de despachar. Las operaciones de ESCRITURA — todo lo que
+# firma un acto con el `agent_key` o toca la cola/los ledgers — abortan si este árbol heredó la
+# identidad del clon principal. Las LECTURAS (`mode`, `next-step`, `status`, los `*-status`)
+# quedan fuera a propósito: son el diagnóstico de un worktree que aún no se dio de alta, y
+# `status` avisa de quién es el estado que enseña. `register` tampoco entra: es la salida.
+case " claim phase gate submit archive wiring progress checkpoint fact propose-asset propose-epic epic-writeback graph-sync escalate " in
+  *" $SUB "*) ops_guard_own_identity "$SUB" || exit $? ;;
+esac
+
 case "$SUB" in
   mode) ops_mode; exit 0 ;;
+  register) cmd_register "$@"; exit $? ;;
   claim) cmd_claim "$@"; exit $? ;;
   next-step) cmd_next_step; exit $? ;;
   phase) cmd_phase "$@"; exit $? ;;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trycore/spec-build-harness",
-  "version": "0.15.0",
+  "version": "0.16.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": {

package/scripts/lib/front-plan.py

@@ -5,9 +5,19 @@
 (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]}]
+stdin: JSON [{"epica","layer","files_scope":[glob],"depends_on":[EP-XXX]}]
 stdout: {"selected":[...],"serialized":[{"epica","reason"}],"excluded_foundational":[...]}
 Determinista: orden por 'epica'. Solape de globs por prefijo de directorio o glob idéntico.
+
+Las tres compuertas, en orden (METODOLOGIA §5 «Compuertas del front»):
+  G1  `layer` fundacional  -> excluded_foundational (nunca en paralelo).
+  G2a `files_scope` vacío o ausente -> serialized. «Sin `files_scope` declarado, una épica no
+      es candidata al front» (METODOLOGIA:343): fail-CLOSED. Que dos épicas sin ámbito
+      declarado salieran «disjuntas» era exactamente el fallo que el front no puede permitirse.
+  G2b camino en el DAG de `depends_on` con una épica ya seleccionada -> serialized. Dos épicas
+      encadenadas no son paralelizables aunque sus ficheros no se toquen: la de abajo construye
+      sobre lo que la de arriba todavía no ha mergeado.
+  G2c solape de `files_scope` con una épica ya seleccionada -> serialized.
 """
 import json, sys, fnmatch
 
@@ -24,6 +34,37 @@ def overlap(a, b):
                 return True
     return False
 
+def is_foundational(cand):
+    """G1 normalizada. El bundle del grafo emite `layer` en MAYÚSCULA (graph-bundle.py lo
+    `.upper()`a porque el hub lo exige así) mientras METODOLOGIA lo escribe en minúscula: un
+    `== "foundational"` a secas dejaba pasar `FOUNDATIONAL` al front, en silencio y justo en la
+    compuerta que más caro sale saltarse."""
+    layer = cand.get("layer")
+    return isinstance(layer, str) and layer.strip().lower() == "foundational"
+
+def reachability(cands):
+    """Alcance transitivo de `depends_on` entre las candidatas (clausura por Floyd-Warshall
+    booleano; los conjuntos de épicas de un front son de decenas, no de miles).
+
+    Se calcula sobre TODAS las candidatas, fundacionales incluidas: un camino EP-A → EP-F → EP-B
+    encadena A y B aunque la fundacional del medio no entre al front. Las referencias a épicas
+    que no vienen en la entrada se ignoran — aquí no se inventa un grafo que no se ha visto."""
+    codes = [c.get("epica") for c in cands if isinstance(c.get("epica"), str)]
+    known = set(codes)
+    reach = {c: set() for c in codes}
+    for c in cands:
+        code = c.get("epica")
+        if code not in known:
+            continue
+        for dep in c.get("depends_on") or []:
+            if isinstance(dep, str) and dep in known and dep != code:
+                reach[code].add(dep)
+    for k in codes:
+        for i in codes:
+            if k in reach[i]:
+                reach[i] |= reach[k]
+    return reach
+
 def _empty_result():
     return {"selected": [], "serialized": [], "excluded_foundational": []}
 
@@ -33,15 +74,23 @@ def main():
         if not isinstance(cands, list) or not all(isinstance(c, dict) for c in cands):
             raise ValueError("entrada inválida: se esperaba una lista de objetos")
         cands = sorted(cands, key=lambda c: c.get("epica",""))
-        excluded = [c["epica"] for c in cands if c.get("layer") == "foundational"]
-        pool = [c for c in cands if c.get("layer") != "foundational"]
+        reach = reachability(cands)
+        excluded = [c["epica"] for c in cands if is_foundational(c)]
+        pool = [c for c in cands if not is_foundational(c)]
         selected, sel_scopes, serialized = [], [], []
         for c in pool:
+            code = c["epica"]
             sc = c.get("files_scope") or []
-            if any(overlap(sc, s) for s in sel_scopes):
-                serialized.append({"epica": c["epica"], "reason": "solape de files_scope con épica seleccionada"})
+            if not sc:
+                serialized.append({"epica": code,
+                                   "reason": "sin files_scope declarado: no es candidata al front (METODOLOGIA §5 G2)"})
+            elif any(code in reach.get(s, ()) or s in reach.get(code, ()) for s in selected):
+                serialized.append({"epica": code,
+                                   "reason": "dependencia en el grafo con una épica ya seleccionada"})
+            elif any(overlap(sc, s) for s in sel_scopes):
+                serialized.append({"epica": code, "reason": "solape de files_scope con épica seleccionada"})
             else:
-                selected.append(c["epica"]); sel_scopes.append(sc)
+                selected.append(code); sel_scopes.append(sc)
         print(json.dumps({"selected":selected,"serialized":serialized,"excluded_foundational":excluded}))
     except Exception:
         print(json.dumps(_empty_result()))

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-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
+for t in test-schema.sh test-config.sh test-runtime-client.sh test-hooks-runtime.sh test-skill-ops.sh test-worktree-identity.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/test-config.sh

@@ -63,4 +63,44 @@ got="$(cd "$BARE" && CLAUDE_PROJECT_DIR="$BARE" config_root)"
 [ "$got" = "$BARE" ] && echo "OK config_root sin estado devuelve el candidato" \
   || { echo "FAIL config_root sin estado ($got)"; fail=1; }
 
+# ── [#74] Señal de identidad heredada ─────────────────────────────────────────
+# El fallback de arriba es correcto para LEER y veneno para ESCRIBIR: sin una señal
+# que lo distinga, un worktree sin credenciales propias firma sus actos con la
+# identidad del clon principal y nadie se entera. Estos tres helpers son esa señal.
+
+got="$(cd "$WT" && CLAUDE_PROJECT_DIR="$WT" config_candidate_root)"
+WTP="$(cd "$WT" && pwd -P)"
+[ "$got" = "$WTP" ] && echo "OK config_candidate_root devuelve ESTE árbol, sin fallback" \
+  || { echo "FAIL config_candidate_root ($got, esperado $WTP)"; fail=1; }
+
+got="$(cd "$WT" && CLAUDE_PROJECT_DIR="$WT" config_main_clone_root)"
+[ "$got" = "$MAIN" ] && echo "OK config_main_clone_root ve el clon principal desde el worktree" \
+  || { echo "FAIL config_main_clone_root ($got, esperado $MAIN)"; fail=1; }
+
+(cd "$WT" && CLAUDE_PROJECT_DIR="$WT" config_is_inherited_root) \
+  && echo "OK config_is_inherited_root detecta el worktree sin credenciales propias" \
+  || { echo "FAIL config_is_inherited_root no detecta la herencia"; fail=1; }
+
+# El clon principal NUNCA hereda: es el dueño del estado.
+(cd "$MAIN" && CLAUDE_PROJECT_DIR="$MAIN" config_is_inherited_root) \
+  && { echo "FAIL config_is_inherited_root marca herencia en el clon principal"; fail=1; } \
+  || echo "OK config_is_inherited_root no marca al clon principal"
+
+# Un proyecto sin arnés tampoco: no hay identidad que heredar.
+(cd "$BARE" && CLAUDE_PROJECT_DIR="$BARE" config_is_inherited_root) \
+  && { echo "FAIL config_is_inherited_root marca herencia sin estado en ninguna parte"; fail=1; } \
+  || echo "OK config_is_inherited_root no marca un proyecto sin arnés"
+
+# Y en cuanto el worktree tiene credenciales PROPIAS, deja de heredar — sin tocar nada
+# más: es exactamente lo que `slice-ops.sh register` deja hecho.
+mkdir -p "$WT/.claude/state"
+echo '{"runtime_url":"http://localhost","agent_key":"ak-wt"}' > "$WT/.claude/state/runtime.credentials"
+(cd "$WT" && CLAUDE_PROJECT_DIR="$WT" config_is_inherited_root) \
+  && { echo "FAIL sigue heredando con credenciales propias"; fail=1; } \
+  || echo "OK con credenciales propias el worktree deja de heredar"
+got="$(cd "$WT" && CLAUDE_PROJECT_DIR="$WT" config_root)"
+[ "$got" = "$WT" ] && echo "OK config_root ancla en el worktree ya registrado" \
+  || { echo "FAIL config_root tras registrar ($got, esperado $WT)"; fail=1; }
+rm -f "$WT/.claude/state/runtime.credentials"
+
 exit $fail

package/scripts/tests/test-front-plan.sh

@@ -25,6 +25,59 @@ echo "$out" | python3 -c "import json,sys;d=json.load(sys.stdin);
 assert d['selected']==['EP-010'] and [m['epica'] for m in d['serialized']]==['EP-011'], d
 print('OK front-plan mid-wildcard overlap serializado')" || { echo "FAIL mid-wildcard overlap"; fail=1; }
 
+# ── [#74] G1 normalizada: el bundle del grafo emite `layer` en MAYÚSCULA ─────────────
+# graph-bundle.py hace `.upper()` porque el hub lo exige así; front-plan comparaba contra
+# "foundational" en minúscula. La exclusión G1 no disparaba, en silencio, justo en la
+# compuerta que más caro sale saltarse.
+out="$(run '[{"epica":"EP-001","layer":"FOUNDATIONAL","files_scope":["src/**"]},
+             {"epica":"EP-002","layer":"BUSINESS","files_scope":["src/a/**"]}]')"
+echo "$out" | python3 -c "import json,sys;d=json.load(sys.stdin);
+assert d['excluded_foundational']==['EP-001'], d
+assert d['selected']==['EP-002'], d
+print('OK front-plan G1 con layer en MAYÚSCULA')" || { echo "FAIL G1 mayúscula"; fail=1; }
+
+# ── [#74] G2 fail-CLOSED sin files_scope ─────────────────────────────────────────────
+# METODOLOGIA:343: «sin `files_scope` declarado, una épica no es candidata al front». El
+# código hacía lo contrario: con la lista vacía, `overlap([], …)` es falso y dos épicas sin
+# ámbito salían como disjuntas.
+out="$(run '[{"epica":"EP-020","layer":"business","files_scope":[]},
+             {"epica":"EP-021","layer":"business"},
+             {"epica":"EP-022","layer":"business","files_scope":["src/c/**"]}]')"
+echo "$out" | python3 -c "import json,sys;d=json.load(sys.stdin);
+assert d['selected']==['EP-022'], d
+assert {m['epica'] for m in d['serialized']}=={'EP-020','EP-021'}, d
+assert all('files_scope' in m['reason'] for m in d['serialized']), d
+print('OK front-plan sin files_scope -> serialized (fail-closed)')" || { echo "FAIL fail-closed sin files_scope"; fail=1; }
+
+# ── [#74] G2 por camino en el DAG de `depends_on` ────────────────────────────────────
+# Ficheros disjuntos no bastan: si EP-031 depende de EP-030, la de abajo construye sobre lo
+# que la de arriba todavía no ha mergeado. La transitividad cuenta, y el camino vale aunque
+# pase por una fundacional que no entra al front.
+out="$(run '[{"epica":"EP-030","layer":"business","files_scope":["src/x/**"]},
+             {"epica":"EP-031","layer":"business","files_scope":["src/y/**"],"depends_on":["EP-030"]},
+             {"epica":"EP-032","layer":"business","files_scope":["src/z/**"],"depends_on":["EP-031"]},
+             {"epica":"EP-033","layer":"business","files_scope":["src/w/**"],"depends_on":["EP-099"]}]')"
+echo "$out" | python3 -c "import json,sys;d=json.load(sys.stdin);
+assert d['selected']==['EP-030','EP-033'], d
+assert {m['epica'] for m in d['serialized']}=={'EP-031','EP-032'}, d
+assert all('grafo' in m['reason'] for m in d['serialized']), d
+print('OK front-plan serializa el camino transitivo del DAG')" || { echo "FAIL DAG depends_on"; fail=1; }
+
+out="$(run '[{"epica":"EP-040","layer":"business","files_scope":["src/x/**"]},
+             {"epica":"EP-041","layer":"FOUNDATIONAL","files_scope":["src/f/**"],"depends_on":["EP-040"]},
+             {"epica":"EP-042","layer":"business","files_scope":["src/z/**"],"depends_on":["EP-041"]}]')"
+echo "$out" | python3 -c "import json,sys;d=json.load(sys.stdin);
+assert d['selected']==['EP-040'], d
+assert [m['epica'] for m in d['serialized']]==['EP-042'], d
+print('OK front-plan ve el camino que pasa por una fundacional excluida')" || { echo "FAIL DAG a través de fundacional"; fail=1; }
+
+# Sin `depends_on` declarado nada cambia: el campo es opcional, no se inventa un grafo.
+out="$(run '[{"epica":"EP-050","layer":"business","files_scope":["src/p/**"]},
+             {"epica":"EP-051","layer":"business","files_scope":["src/q/**"]}]')"
+echo "$out" | python3 -c "import json,sys;d=json.load(sys.stdin);
+assert d['selected']==['EP-050','EP-051'] and d['serialized']==[], d
+print('OK front-plan sin depends_on no serializa de más')" || { echo "FAIL sin depends_on"; fail=1; }
+
 SK="$ROOT/skills/managing-parallel-front/SKILL.md"
 { [ -f "$SK" ] && grep -q 'git worktree add' "$SK" && grep -q 'front-plan.py' "$SK" \
   && grep -q 'merge_order' "$SK" && grep -q 'foundational' "$SK"; } \
@@ -35,4 +88,14 @@ SK="$ROOT/skills/managing-parallel-front/SKILL.md"
 grep -q 'files_scope' "$ROOT/skills/building-a-slice/references/dor.md" && echo "OK dor files_scope" || { echo "FAIL dor files_scope"; fail=1; }
 grep -q 'parallel_front' "$ROOT/agents/build/build-orchestrator.md" && echo "OK orquestador front" || { echo "FAIL orquestador front"; fail=1; }
 
+# [#74] La skill decía «mismo token de proyecto»: el hub lo refuta (el `agent_key` es el
+# `agent_id` grabado en el token por el ADMIN). Un token repetido = un solo agente.
+grep -q 'mismo token de proyecto' "$SK" \
+  && { echo "FAIL la skill sigue diciendo «mismo token de proyecto»"; fail=1; } \
+  || echo "OK la skill ya no manda reusar el token de proyecto"
+grep -q 'slice-ops.sh register' "$SK" && echo "OK la skill manda dar de alta el worktree con register" \
+  || { echo "FAIL la skill no menciona register"; fail=1; }
+grep -q 'depends_on' "$SK" && echo "OK la skill pide depends_on entre las candidatas" \
+  || { echo "FAIL la skill no pide depends_on"; fail=1; }
+
 exit $fail