@trycore/spec-build-harness 0.12.0 → 0.14.0

package/scripts/lib/graph-bundle.py

@@ -14,8 +14,17 @@ como string POR ÉPICA (las `release_lines` de la entrada se pliegan aquí). As
 objeto sirve para la pantalla de import del grafo y para embeberse como sección `graph`
 del bundle de estado (`trycore-build migrate`).
 
+[issue #56] Las dependencias entre épicas viven como PROSA en `docs/03-backlog/epicas.md`
+(`**Depende de**: EP-001 (…)`), y delegar su lectura al modelo las dejó VACÍAS en el piloto
+(41/41 épicas con `depends_on: []`, Lienzo sin una sola arista). `--from-docs` extrae ese
+grafo de forma DETERMINISTA — regex de códigos `EP-…` sobre el campo `Depende de` de cada
+sección de épica, excluyendo la propia — y lo une a lo que traiga el JSON de entrada. Si la
+épica declara el campo estructurado `depende_de: [EP-001, …]`, ese gana sobre la prosa.
+
 Uso:
     python3 graph-bundle.py < epics.json > bundle.json      # avisos por stderr
+    python3 graph-bundle.py --from-docs docs/03-backlog/epicas.md < epics.json > bundle.json
+    python3 graph-bundle.py --print-deps docs/03-backlog/epicas.md   # solo el grafo extraído
 
 Entrada (stdin, JSON — formato de discovery, sin cambios):
     {"project_ref": "…",
@@ -27,9 +36,12 @@ Salida (stdout, JSON): el bundle normalizado y DETERMINISTA (orden estable por c
 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.
+Códigos de salida: 0 = bundle generado (con o sin avisos) · 1 = entrada ilegible
+(incluye una ruta `--from-docs` que no se puede leer: se pidió extraer y no se pudo, y un
+grafo sin aristas no falla solo — empobrece en silencio, que es justo lo que causó #56).
 """
 import json
+import re
 import sys
 import datetime
 
@@ -43,8 +55,128 @@ def norm_list(v):
     return [x for x in v if isinstance(x, str)] if isinstance(v, list) else []
 
 
+# ── Extractor determinista de dependencias desde los docs de discovery [issue #56] ──
+# Códigos de épica: EP-001 y también los compuestos del estilo EP-OR-08.
+RE_CODIGO = re.compile(r"\bEP-(?:[A-Za-z]{1,6}-)?\d{1,4}\b")
+# Encabezado de sección de épica: `## EP-001 — Título` (cualquier nivel).
+RE_ENCABEZADO = re.compile(r"^\s{0,3}(#{1,6})\s+(.*)$")
+# El campo en prosa que escribe la metodología: `**Depende de**: …` (puede ir a mitad de
+# línea, p. ej. `**Anexo A**: Fase 3 · **Depende de**: EP-002`).
+RE_DEPENDE_DE = re.compile(r"depende\s+de", re.IGNORECASE)
+# El campo estructurado (frontmatter o cuerpo): `depende_de: [EP-001, EP-002]`.
+RE_DEPENDE_DE_ESTRUCTURADO = re.compile(r"^\s*(?:-\s*)?depende_de\s*:", re.IGNORECASE)
+# Fin del párrafo del campo: encabezado, regla horizontal, viñeta/cita/tabla o campo nuevo.
+RE_FIN_DE_CAMPO = re.compile(r"^\s*(?:#{1,6}\s|-{3,}\s*$|\*{3,}\s*$|[-*+>|]\s|\*\*)")
+
+
+def extraer_dependencias(texto):
+    """Devuelve ({codigo: [deps ordenadas]}, {códigos con sección}, avisos).
+
+    Solo entran las épicas que DECLARAN el campo (en prosa o estructurado): "no lo declara"
+    y "declara que no depende de nada" son cosas distintas y ninguna se inventa aquí.
+    """
+    avisos = []
+    lineas = texto.splitlines()
+    # (código de la épica, línea donde abre su sección)
+    secciones = []
+    for i, linea in enumerate(lineas):
+        m = RE_ENCABEZADO.match(linea)
+        if not m:
+            continue
+        codigos = RE_CODIGO.findall(m.group(2))
+        if codigos:
+            secciones.append((codigos[0], i))
+    if not secciones:
+        avisos.append("no se reconoció ninguna sección de épica en los docs "
+                      "(se esperaban encabezados del estilo `## EP-001 — Título`)")
+        return {}, set(), avisos
+
+    deps = {}
+    for n, (codigo, inicio) in enumerate(secciones):
+        fin = secciones[n + 1][1] if n + 1 < len(secciones) else len(lineas)
+        cuerpo = lineas[inicio + 1:fin]
+        prosa, estructurado = None, None
+        for j, linea in enumerate(cuerpo):
+            if estructurado is None and RE_DEPENDE_DE_ESTRUCTURADO.match(linea):
+                estructurado = RE_CODIGO.findall(linea.split(":", 1)[1])
+                continue
+            if prosa is not None:
+                continue
+            m = RE_DEPENDE_DE.search(linea)
+            if not m:
+                continue
+            # El campo puede continuar en las líneas siguientes hasta el fin del párrafo.
+            trozos = [linea[m.end():]]
+            for siguiente in cuerpo[j + 1:]:
+                if not siguiente.strip() or RE_FIN_DE_CAMPO.match(siguiente):
+                    break
+                trozos.append(siguiente)
+            prosa = RE_CODIGO.findall(" ".join(trozos))
+        # El campo estructurado es determinista: gana sobre la heurística de la prosa.
+        encontrado = estructurado if estructurado is not None else prosa
+        if encontrado is None:
+            continue
+        deps[codigo] = sorted({c for c in encontrado if c != codigo})
+    return deps, {c for c, _ in secciones}, avisos
+
+
+def leer_dependencias_de_docs(ruta):
+    """Lee el fichero de épicas; lanza IOError/OSError si no se puede (rc 1 arriba)."""
+    with open(ruta, encoding="utf-8") as fh:
+        return extraer_dependencias(fh.read())
+
+
+def parsear_argumentos(argv):
+    """({from_docs, print_deps}, error) — sin dependencias, mismo estilo que el resto."""
+    opciones = {"from_docs": None, "print_deps": None}
+    i = 0
+    while i < len(argv):
+        arg = argv[i]
+        if arg in ("--from-docs", "--print-deps"):
+            if i + 1 >= len(argv) or argv[i + 1].startswith("--"):
+                return opciones, "%s exige la ruta del fichero de épicas" % arg
+            opciones["from_docs" if arg == "--from-docs" else "print_deps"] = argv[i + 1]
+            i += 2
+            continue
+        return opciones, "opción desconocida: %s" % arg
+    if opciones["from_docs"] and opciones["print_deps"]:
+        # Ignorar una de las dos en silencio es exactamente el error que corrige #56.
+        return opciones, "--from-docs y --print-deps son excluyentes"
+    return opciones, None
+
+
 def main():
     avisos = []
+    opciones, error = parsear_argumentos(sys.argv[1:])
+    if error:
+        print("graph-bundle: %s" % error, file=sys.stderr)
+        return 1
+
+    # `--print-deps`: solo el grafo extraído (diagnóstico; no toca stdin ni arma bundle).
+    if opciones["print_deps"]:
+        try:
+            deps, _, avisos_docs = leer_dependencias_de_docs(opciones["print_deps"])
+        except (IOError, OSError) as e:
+            print("graph-bundle: no se pudo leer %s: %s" % (opciones["print_deps"], e),
+                  file=sys.stderr)
+            return 1
+        json.dump(deps, sys.stdout, indent=2, ensure_ascii=False, sort_keys=True)
+        sys.stdout.write("\n")
+        for a in avisos_docs:
+            print("aviso: %s" % a, file=sys.stderr)
+        return 0
+
+    deps_docs = None
+    if opciones["from_docs"]:
+        try:
+            deps_docs, secciones_docs, avisos_docs = \
+                leer_dependencias_de_docs(opciones["from_docs"])
+        except (IOError, OSError) as e:
+            print("graph-bundle: no se pudo leer %s: %s" % (opciones["from_docs"], e),
+                  file=sys.stderr)
+            return 1
+        avisos.extend(avisos_docs)
+
     try:
         raw = json.load(sys.stdin)
     except Exception as e:
@@ -113,6 +245,36 @@ def main():
             epica["docs_ref"] = e["docs_ref"]
         epicas[code] = epica
 
+    # [issue #56] Las dependencias de los docs se UNEN a las declaradas: el extractor es la
+    # fuente fiable, y lo que ya venía en el JSON no se pierde (se avisa si no está en docs).
+    if deps_docs is not None:
+        aristas = 0
+        for code, e in epicas.items():
+            if code not in deps_docs:
+                if code in secciones_docs:
+                    avisos.append("%s tiene sección en %s pero no declara el campo "
+                                  "`Depende de`: sus dependencias quedan como vinieran en el "
+                                  "JSON" % (code, opciones["from_docs"]))
+                else:
+                    avisos.append("%s no aparece como sección de épica en %s: sus "
+                                  "dependencias no se pudieron extraer de los docs"
+                                  % (code, opciones["from_docs"]))
+                continue
+            solo_json = [d for d in e["depends_on"] if d not in deps_docs[code]]
+            if solo_json:
+                avisos.append("%s: %s viene del JSON de entrada pero no del campo `Depende de` "
+                              "de los docs: verifica cuál manda"
+                              % (code, ", ".join(solo_json)))
+            e["depends_on"] = sorted(set(e["depends_on"]) | set(deps_docs[code]))
+            aristas += len(e["depends_on"])
+        for code in sorted(deps_docs):
+            if code not in epicas:
+                avisos.append("%s está en %s pero no en el JSON de entrada: el grafo del hub "
+                              "quedaría sin esa épica" % (code, opciones["from_docs"]))
+        print("info: dependencias extraídas de %s -> %d épicas con campo `Depende de`, "
+              "%d aristas en el grafo" % (opciones["from_docs"], len(deps_docs), aristas),
+              file=sys.stderr)
+
     for code, e in epicas.items():
         for dep in e["depends_on"]:
             if dep not in epicas:
@@ -167,6 +329,8 @@ def main():
         "generated_at": datetime.datetime.now(datetime.timezone.utc)
                         .strftime("%Y-%m-%dT%H:%M:%SZ"),
         "generated_by": "trycore-build-harness/graph-bundle.py",
+        "depends_on_source": ("docs:%s" % opciones["from_docs"]) if deps_docs is not None
+                             else "input",
         "epics": [epicas[c] for c in sorted(epicas)],
         "warnings": avisos,
     }

package/scripts/tests/test-config.sh

@@ -22,4 +22,45 @@ got="$(BUILD_CONFIG_FILE="$TMP/cfg.json" config_get runtime.mode legacy)"
 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; }
 
+# ── config_root en worktrees ──────────────────────────────────────────────────
+# El estado del arnés está en .gitignore (secretos + working state), así que NO
+# viaja a un `git worktree add`. Resolviendo la raíz solo por --show-toplevel, el
+# agente que arranca en un worktree se queda sin credenciales y opera huérfano:
+# sin identidad, sin lease y con los guards inhibidos. Nadie lo probaba, y por eso
+# sobrevivió hasta 0.13.0.
+# `git rev-parse --git-common-dir` devuelve la ruta ya resuelta, y en macOS /var es
+# un symlink a /private/var: se compara contra la ruta FÍSICA (pwd -P) para no
+# medir la forma en que se escribió el path.
+MAIN="$(mkdir -p "$TMP/main" && cd "$TMP/main" && pwd -P)"
+mkdir -p "$MAIN/.claude/state"
+git -C "$MAIN" init -q 2>/dev/null
+git -C "$MAIN" config user.email t@t.io; git -C "$MAIN" config user.name t
+echo x > "$MAIN/f"; git -C "$MAIN" add -A >/dev/null 2>&1; git -C "$MAIN" commit -qm init >/dev/null 2>&1
+echo '{"runtime_url":"http://localhost"}' > "$MAIN/.claude/state/runtime.credentials"
+WT="$TMP/wt"   # lo crea `git worktree add`, se normaliza al usarlo
+git -C "$MAIN" worktree add -q "$WT" -b wt-test >/dev/null 2>&1
+
+got="$(cd "$WT" && unset CLAUDE_PROJECT_DIR; config_root)"
+[ "$got" = "$MAIN" ] && echo "OK config_root cae al clon principal desde un worktree" \
+  || { echo "FAIL config_root en worktree ($got, esperado $MAIN)"; fail=1; }
+
+# Con CLAUDE_PROJECT_DIR apuntando al worktree (que es lo que hace el harness de
+# Claude Code al abrir una sesión ahí) el resultado debe ser el mismo: la variable
+# dice dónde trabaja el agente, no dónde vive el estado del arnés.
+got="$(cd "$WT" && CLAUDE_PROJECT_DIR="$WT" config_root)"
+[ "$got" = "$MAIN" ] && echo "OK config_root ignora CLAUDE_PROJECT_DIR sin estado" \
+  || { echo "FAIL config_root con CLAUDE_PROJECT_DIR ($got, esperado $MAIN)"; fail=1; }
+
+# Idempotencia: en un clon normal con estado propio, nada cambia.
+got="$(cd "$MAIN" && CLAUDE_PROJECT_DIR="$MAIN" config_root)"
+[ "$got" = "$MAIN" ] && echo "OK config_root respeta el clon con estado propio" \
+  || { echo "FAIL config_root en clon normal ($got)"; fail=1; }
+
+# Y sin estado en ninguna parte (proyecto que aún no usa el arnés) se devuelve el
+# candidato tal cual: no se inventa una raíz ajena.
+BARE="$TMP/bare"; mkdir -p "$BARE"
+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; }
+
 exit $fail

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

@@ -126,6 +126,45 @@ got="$(projection_get active_slice.slice_id "")"
 [ "$got" = "sl-9" ] && echo "OK fetch_and_cache escribe la cache" || { echo "FAIL cache tras fetch ($got)"; fail=1; }
 if projection_is_stale; then echo "FAIL cache recien traida es stale"; fail=1; else echo "OK cache recien traida es fresca"; fi
 
+# [#63] La versión de grafo se normaliza igual que el manifest_hash: un solo sitio conoce la
+# forma cruda del servidor.
+python3 - "$TMP/routes-ac.json" <<'PY'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+r=d["GET /agent/context"]["body"]
+r.setdefault("context",{})["graph_version"]=42
+json.dump(d,open(p,"w"))
+PY
+agent_context_fetch_and_cache >/dev/null 2>&1
+got="$(projection_get context.graph_version "")"
+[ "$got" = 42 ] && echo "OK agent-context normaliza context.graph_version" \
+  || { echo "FAIL graph_version sin normalizar ($got)"; fail=1; }
+[ "$(_runtime_graph_version)" = 42 ] && echo "OK _runtime_graph_version lee la version conocida" \
+  || { echo "FAIL _runtime_graph_version"; fail=1; }
+
+# Hub que NO versiona: graph_version queda null y nada cambia.
+python3 - "$TMP/routes-ac.json" <<'PY'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["GET /agent/context"]["body"]["context"].pop("graph_version",None)
+json.dump(d,open(p,"w"))
+PY
+agent_context_fetch_and_cache >/dev/null 2>&1
+[ "$(projection_get context.graph_version "")" = "" ] && [ "$(_runtime_graph_version)" = "" ] \
+  && echo "OK sin versión en el hub, graph_version queda vacia" \
+  || { echo "FAIL graph_version inventada sin hub que versione"; fail=1; }
+
+# Marcador de desfase: se anota y se limpia.
+runtime_graph_note_stale 42 45
+runtime_graph_status_read | python3 -c "
+import json,sys
+d=json.load(sys.stdin)
+print('SI' if d.get('local')==42 and d.get('server')==45 and d.get('seen_at') else 'NO')" | grep -q SI \
+  && echo "OK runtime_graph_note_stale anota el desfase" || { echo "FAIL note_stale"; fail=1; }
+runtime_graph_clear_stale
+[ "$(runtime_graph_status_read)" = "{}" ] && echo "OK runtime_graph_clear_stale borra el marcador" \
+  || { echo "FAIL clear_stale"; fail=1; }
+
 kill "$STUB_AC" 2>/dev/null; wait "$STUB_AC" 2>/dev/null
 # Servidor caído: rc 1 y la caché ANTERIOR intacta (nunca se pisa con vacío).
 agent_context_fetch_and_cache
@@ -284,9 +323,142 @@ sleep 4
 kill -0 "$HBPID3" 2>/dev/null && { echo "FAIL daemon sobrevive sin sesiones"; fail=1; } || echo "OK daemon muere con la ultima sesion"
 [ ! -f "$PROJ/.claude/state/heartbeat.pid" ] && echo "OK daemon limpia el pidfile" || { echo "FAIL pidfile huerfano"; fail=1; }
 
+# [#61] Con el daemon vivo, un cambio en /agent/context llega a la proyección local SIN
+# reiniciar la sesión ni hacer claim: hoy la caché solo se hidrataba en session-start y claim.
+export TRYCORE_CONTEXT_REFRESH_S=1
+cat > "$TMP/routes-hb.json" <<JSON
+{"PUT /leases/renew": {"status": 200, "body": {"expires_at": "2099-01-01T00:00:00Z"}},
+ "GET /agent/context": {"status": 200, "body": {"project": {"scaffold": {"confirmed": true}}, "active_slice": {"slice_id": "sl-9", "epic_code": "EP-077", "phase": "green"}, "nudges": [{"kind": "info", "message": "épica EP-077 aprobada"}], "context": {"manifest_hash": "sha256:v2", "version": 9}}},
+ "POST /events": {"status": 200, "body": {"results": []}}}
+JSON
+sleep 60 & SESSC=$!
+bash "$ROOT/hooks/build/heartbeat.sh" --ensure "$SESSC" >/dev/null 2>&1
+sleep 4
+got="$(python3 -c "
+import json
+d=json.load(open('$PROJ/.claude/state/runtime-projection.json'))
+print((d.get('active_slice') or {}).get('epic_code'))" 2>/dev/null)"
+[ "$got" = "EP-077" ] && echo "OK el daemon refresca la proyeccion sin claim ni reinicio" \
+  || { echo "FAIL la proyeccion no se refresco ($got)"; fail=1; }
+got="$(python3 -c "
+import json
+d=json.load(open('$PROJ/.claude/state/runtime-projection.json'))
+print((d.get('nudges') or [{}])[0].get('message'))" 2>/dev/null)"
+[ "$got" = "épica EP-077 aprobada" ] && echo "OK el nudge del hub llega a la proyeccion local" \
+  || { echo "FAIL el nudge no llego ($got)"; fail=1; }
+# [Ronda final] `last_context_status` tiene UN tipo: cadena. El éxito lo escribía como número
+# y el fallo como cadena — el mismo campo con dos tipos según cómo fue, y quien lo lee no
+# puede compararlo sin adivinar.
+tipo="$(python3 -c "
+import json
+print(type(json.load(open('$PROJ/.claude/state/heartbeat-status.json')).get('last_context_status')).__name__)" 2>/dev/null)"
+[ "$tipo" = str ] && echo "OK last_context_status es siempre una cadena (tambien en el exito)" \
+  || { echo "FAIL last_context_status cambia de tipo segun el resultado ($tipo)"; fail=1; }
+
+# Fallo de red en el refresco: la caché ANTERIOR queda intacta y marcada stale. Nunca dejar
+# al agente sin proyección: eso lo convierte en huérfano (regresión del PR #60).
+cat > "$TMP/routes-hb.json" <<JSON
+{"PUT /leases/renew": {"status": 200, "body": {"expires_at": "2099-01-01T00:00:00Z"}},
+ "GET /agent/context": {"status": 500, "body": {"error": "boom"}},
+ "POST /events": {"status": 200, "body": {"results": []}}}
+JSON
+sleep 4
+got="$(python3 -c "
+import json
+d=json.load(open('$PROJ/.claude/state/runtime-projection.json'))
+print((d.get('active_slice') or {}).get('epic_code'))" 2>/dev/null)"
+[ "$got" = "EP-077" ] && echo "OK un refresco fallido conserva la cache anterior" \
+  || { echo "FAIL la cache se perdio con el fallo de red ($got)"; fail=1; }
+stale="$(python3 -c "
+import json
+print(json.load(open('$PROJ/.claude/state/heartbeat-status.json')).get('context_stale'))" 2>/dev/null)"
+[ "$stale" = True ] && echo "OK un refresco fallido marca la proyeccion stale" \
+  || { echo "FAIL refresco fallido sin marcar stale ($stale)"; fail=1; }
+
+# Los guards nunca leen una caché a medio escribir: mientras el daemon refresca en bucle,
+# un lector concurrente parsea el fichero 300 veces sin un solo JSON inválido.
+cat > "$TMP/routes-hb.json" <<JSON
+{"PUT /leases/renew": {"status": 200, "body": {"expires_at": "2099-01-01T00:00:00Z"}},
+ "GET /agent/context": {"status": 200, "body": {"project": {}, "active_slice": {"slice_id": "sl-9", "epic_code": "EP-077", "phase": "green"}, "nudges": [], "context": {"manifest_hash": "sha256:v2", "version": 9}}},
+ "POST /events": {"status": 200, "body": {"results": []}}}
+JSON
+bad="$(python3 - "$PROJ/.claude/state/runtime-projection.json" <<'PY'
+import json,sys,time
+path=sys.argv[1]; bad=0
+for _ in range(300):
+    try:
+        json.load(open(path))
+    except Exception:
+        bad+=1
+    time.sleep(0.01)
+print(bad)
+PY
+)"
+[ "$bad" = 0 ] && echo "OK el lector concurrente nunca ve la cache a medio escribir" \
+  || { echo "FAIL $bad lecturas parciales de la proyeccion"; fail=1; }
+
+# [#61 · ronda final] El refresco tiene DOS fallos distintos y no se pueden anunciar igual:
+# «el hub no respondió» y «respondió 200 pero no pudimos escribir la proyección». Con un solo
+# código, `slice-ops.sh status` imprimía «no pudo refrescar (último intento: 200)» y mandaba a
+# mirar la red teniendo el problema en el disco. Fixture: la proyección es un DIRECTORIO, así
+# que el `os.replace` final falla con el 200 ya en la mano.
+rm -f "$PROJ/.claude/state/runtime-projection.json"
+mkdir -p "$PROJ/.claude/state/runtime-projection.json"
+sleep 4
+ctxst="$(python3 -c "
+import json
+print(json.load(open('$PROJ/.claude/state/heartbeat-status.json')).get('last_context_status'))" 2>/dev/null)"
+[ "$ctxst" = "write_error" ] && echo "OK un 200 que no se pudo escribir no se reporta como 200" \
+  || { echo "FAIL el fallo de escritura se anuncia como estado HTTP ($ctxst)"; fail=1; }
+rmdir "$PROJ/.claude/state/runtime-projection.json" 2>/dev/null
+sleep 3
+
+# Sin red, `runtime_http_status` vale `000` — que NO es un número JSON válido. Emitido sin
+# comillas rompía el fragmento entero y `hb_write_status` no escribía NADA: ni el estado ni el
+# `context_stale: true`, o sea el fallo desaparecía en silencio. El campo es SIEMPRE cadena.
+python3 -c "
+import json
+d=json.load(open('$PROJ/.claude/state/heartbeat-status.json'))
+d['context_stale']=False
+json.dump(d,open('$PROJ/.claude/state/heartbeat-status.json','w'))"
+kill "$STUB_HB" 2>/dev/null; wait "$STUB_HB" 2>/dev/null
+sleep 4
+ctx000="$(python3 -c "
+import json
+d=json.load(open('$PROJ/.claude/state/heartbeat-status.json'))
+print(repr(d.get('last_context_status')), d.get('context_stale'))" 2>/dev/null)"
+[ "$ctx000" = "'000' True" ] && echo "OK sin red el estado del refresco se registra como cadena \"000\"" \
+  || { echo "FAIL el fragmento con 000 no se registro ($ctx000)"; fail=1; }
+python3 "$ROOT/scripts/tests/lib/http-stub.py" "$PORT_HB" "$TMP/routes-hb.json" "$TMP/calls-hb.jsonl" &
+STUB_HB=$!
+sleep 0.5
+
+# legacy|dual: el daemon NO refresca (AC de #61).
+bash "$ROOT/hooks/build/heartbeat.sh" --stop >/dev/null 2>&1
+python3 -c "
+import json
+json.dump({'fetched_at':'2020-01-01T00:00:00Z','active_slice':{'slice_id':'sl-9','epic_code':'EP-VIEJA'},'nudges':[]},
+          open('$PROJ/.claude/state/runtime-projection.json','w'))"
+: > "$TMP/calls-hb.jsonl"
+TRYCORE_RUNTIME_MODE=dual bash "$ROOT/hooks/build/heartbeat.sh" --ensure "$SESSC" >/dev/null 2>&1
+sleep 4
+got="$(python3 -c "
+import json
+d=json.load(open('$PROJ/.claude/state/runtime-projection.json'))
+print((d.get('active_slice') or {}).get('epic_code'))" 2>/dev/null)"
+[ "$got" = "EP-VIEJA" ] && echo "OK en dual el daemon no refresca el contexto" \
+  || { echo "FAIL el daemon refresco en dual ($got)"; fail=1; }
+bash "$ROOT/hooks/build/heartbeat.sh" --stop >/dev/null 2>&1
+kill "$SESSC" 2>/dev/null; wait "$SESSC" 2>/dev/null
+unset TRYCORE_CONTEXT_REFRESH_S
+
 # 409 en el renew: se marca lease perdido y NO se apaga el daemon (spec §4.3).
+# [#61] heartbeat-status.json es un MERGE, no un reemplazo: dos deberes del tick (lease y
+# contexto) escriben el mismo fichero y ninguno puede borrar el diagnóstico del otro.
+export TRYCORE_CONTEXT_REFRESH_S=1
 cat > "$TMP/routes-hb.json" <<JSON
 {"PUT /leases/renew": {"status": 409, "body": {"error": "lease_conflict"}},
+ "GET /agent/context": {"status": 200, "body": {"project": {"scaffold": {"confirmed": true}}, "active_slice": {"slice_id": "sl-9", "phase": "green"}, "nudges": [], "context": {"manifest_hash": "sha256:v2", "version": 9}}},
  "POST /events": {"status": 200, "body": {"results": []}}}
 JSON
 sleep 60 & SESS3=$!
@@ -297,12 +469,22 @@ lost="$(python3 -c "import json;print(json.load(open('$PROJ/.claude/state/heartb
 HBPID4="$(cat "$PROJ/.claude/state/heartbeat.pid" 2>/dev/null)"
 kill -0 "$HBPID4" 2>/dev/null && echo "OK daemon sigue vivo tras 409" || { echo "FAIL daemon murio por 409"; fail=1; }
 
+# El daemon lleva ya un 409 anotado (lease_lost: true). Un refresco de contexto posterior
+# NO puede borrarlo.
+sleep 4
+merged="$(python3 -c "
+import json
+d=json.load(open('$PROJ/.claude/state/heartbeat-status.json'))
+print('SI' if d.get('lease_lost') is True and 'context_stale' in d else 'NO')" 2>/dev/null)"
+[ "$merged" = SI ] && echo "OK heartbeat-status conserva lease_lost tras el refresco de contexto" \
+  || { echo "FAIL heartbeat-status se reemplaza en vez de mezclarse ($merged)"; fail=1; }
+
 bash "$ROOT/hooks/build/heartbeat.sh" --stop >/dev/null 2>&1
 sleep 1
 kill -0 "$HBPID4" 2>/dev/null && { echo "FAIL --stop no apago el daemon"; fail=1; } || echo "OK --stop apaga el daemon"
 kill "$SESS3" 2>/dev/null; wait "$SESS3" 2>/dev/null
 kill "$STUB_HB" 2>/dev/null; wait "$STUB_HB" 2>/dev/null
-unset TRYCORE_HEARTBEAT_TICK_S TRYCORE_HEARTBEAT_INTERVAL_S
+unset TRYCORE_HEARTBEAT_TICK_S TRYCORE_HEARTBEAT_INTERVAL_S TRYCORE_CONTEXT_REFRESH_S
 
 # --- session-start.sh ---
 PORT_SS="$(python3 -c "import socket;s=socket.socket();s.bind(('',0));print(s.getsockname()[1]);s.close()")"
@@ -458,10 +640,23 @@ rm -f "$PROJ/.claude/state/build-state.json"
 # --- guards desde la caché de proyección (modo runtime) ---
 HOOK_IN='{"tool_name":"Write","tool_input":{"file_path":"'"$PROJ"'/src/x.ts","content":"x"}}'
 
-# Sin caché: auto-arme, no bloquea (nada que vigilar todavía).
+# Sin caché hay DOS escenarios opuestos y el guard debe distinguirlos. Hasta 0.13.0
+# los dos caían en el mismo exit 0, y por eso un agente desconectado del hub (todo
+# worktree lo está: el estado no viaja) podía escribir código sin que nada lo
+# parase, que es como dos workers acaban pisándose.
 rm -f "$PROJ/.claude/state/runtime-projection.json"
+
+# (a) Con credenciales = proyecto registrado que NO ve al hub → bloquea.
+echo "$HOOK_IN" | bash "$ROOT/hooks/build/scaffold-guard.sh" >/dev/null 2>&1
+[ $? -eq 2 ] && echo "OK scaffold-guard bloquea si está desconectado del hub" \
+  || { echo "FAIL scaffold-guard no bloquea desconectado"; fail=1; }
+
+# (b) Sin credenciales = el proyecto aún no usa el arnés → auto-arme, deja pasar.
+mv "$PROJ/.claude/state/runtime.credentials" "$PROJ/.claude/state/creds.bak"
 echo "$HOOK_IN" | bash "$ROOT/hooks/build/scaffold-guard.sh" >/dev/null 2>&1
-[ $? -eq 0 ] && echo "OK scaffold-guard sin cache no bloquea" || { echo "FAIL scaffold-guard bloqueo sin cache"; fail=1; }
+[ $? -eq 0 ] && echo "OK scaffold-guard respeta el auto-arme sin credenciales" \
+  || { echo "FAIL scaffold-guard rompe el auto-arme"; fail=1; }
+mv "$PROJ/.claude/state/creds.bak" "$PROJ/.claude/state/runtime.credentials"
 
 # Fase de código + scaffold NO confirmado -> bloquea.
 runtime_projection_write "{\"fetched_at\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"project\":{\"scaffold_confirmed\":false,\"design_source_applies\":true,\"design_source_confirmed\":false},\"active_slice\":{\"slice_id\":\"sl-11\",\"phase\":\"green\",\"gates\":{\"fidelity\":false},\"wiring_failing\":[]},\"nudges\":[]}"

package/scripts/tests/test-install.sh

@@ -173,6 +173,29 @@ else
   echo "FAIL install: .gitignore no protege los artefactos del runtime"
   fail=1
 fi
+# [Ronda de arreglo 1, Minor 7 / #63] El ledger de propuestas y el marcador de desfase de
+# grafo son estado derivado del hub, igual que los de arriba: mismo blindaje.
+if [ -f "$GI" ] \
+  && grep -q '^\.claude/state/epic-proposals\.json$' "$GI" \
+  && grep -q '^\.claude/state/graph-status\.json$' "$GI"; then
+  echo "OK install: .gitignore protege epic-proposals/graph-status"
+else
+  echo "FAIL install: .gitignore no protege epic-proposals.json/graph-status.json"
+  fail=1
+fi
+# [Ronda final · C5] Los tres ficheros del daemon de heartbeat (EP-OR-08-B) son estado LOCAL
+# de la máquina —un pid y unos ppids no significan nada en otro clon— y llevaban desde
+# entonces fuera de la semilla: un consumidor los commiteaba y el siguiente `git pull` traía
+# un pidfile ajeno que el relanzamiento del daemon toma por bueno hasta el `kill -0`.
+if [ -f "$GI" ] \
+  && grep -q '^\.claude/state/heartbeat\.pid$' "$GI" \
+  && grep -q '^\.claude/state/heartbeat-sessions\.json$' "$GI" \
+  && grep -q '^\.claude/state/heartbeat-status\.json$' "$GI"; then
+  echo "OK install: .gitignore protege los tres ficheros del heartbeat"
+else
+  echo "FAIL install: .gitignore no protege heartbeat.pid/heartbeat-sessions.json/heartbeat-status.json"
+  fail=1
+fi
 rm -rf "$TMP_BF"
 
 # 6) Ambiguo: manifiesto + código pero SIN repo git (sin historial) → project_kind null.