@trycore/spec-build-harness 0.13.0 → 0.14.0

package/hooks/build/heartbeat.sh

@@ -18,10 +18,19 @@ set -uo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "$HERE/lib/runtime-client.sh"
 source "$HERE/lib/projection.sh"
+source "$HERE/lib/agent-context.sh"
 
 HB_TICK_S="${TRYCORE_HEARTBEAT_TICK_S:-5}"
 case "$HB_TICK_S" in ''|*[!0-9]*) HB_TICK_S=5 ;; esac
 
+# Cadencia del refresco de contexto [#61]. NO es el tick: renovar un lease es barato, pero
+# `GET /agent/context` es una proyección entera del proyecto — a 5 s castigaría al hub sin
+# ganar nada. 45 s es del orden de la latencia con la que un humano aprueba una épica.
+# `0` lo desactiva (vuelta al comportamiento previo a #61).
+HB_CONTEXT_S="${TRYCORE_CONTEXT_REFRESH_S:-}"
+[ -n "$HB_CONTEXT_S" ] || HB_CONTEXT_S="$(config_get runtime.context_refresh_s 45)"
+case "$HB_CONTEXT_S" in ''|*[!0-9]*) HB_CONTEXT_S=45 ;; esac
+
 hb_pidfile()   { echo "$(config_root)/.claude/state/heartbeat.pid"; }
 hb_sessions()  { echo "$(config_root)/.claude/state/heartbeat-sessions.json"; }
 hb_statusfile() { echo "$(config_root)/.claude/state/heartbeat-status.json"; }
@@ -115,7 +124,11 @@ PY
   echo "$n"
 }
 
-# hb_write_status <json> — estado observable del daemon (lo lee statusline-bridge.sh).
+# hb_write_status <fragmento-json> — UPSERT del fragmento sobre el estado observable del
+# daemon (lo lee statusline-bridge.sh y `slice-ops.sh status`). Es merge y no reemplazo
+# desde #61: el fichero lo escriben DOS deberes distintos del tick — la renovación del lease
+# y el refresco de contexto — y con reemplazo el último en escribir borraba el diagnóstico
+# del otro (un refresco correcto tapaba un `lease_lost: true` recién detectado).
 hb_write_status() {
   local body f
   body="$1"
@@ -126,14 +139,22 @@ hb_write_status() {
 import json,sys,os,tempfile
 path,body=sys.argv[1],sys.argv[2]
 try:
-    d=json.loads(body)
+    d=json.load(open(path))
 except Exception:
     d={}
+if not isinstance(d,dict):
+    d={}
+try:
+    frag=json.loads(body)
+except Exception:
+    frag={}
+if isinstance(frag,dict):
+    d.update(frag)
 dirn=os.path.dirname(path) or "."
 fd,tmp=tempfile.mkstemp(dir=dirn,prefix=".heartbeat-status.",suffix=".tmp")
 try:
     with os.fdopen(fd,"w") as out:
-        json.dump(d,out,indent=2)
+        json.dump(d,out,indent=2); out.flush(); os.fsync(out.fileno())
     os.replace(tmp,path)
 except Exception:
     try: os.unlink(tmp)
@@ -168,8 +189,40 @@ hb_renew() {
   esac
 }
 
+# hb_refresh_context — refresca la caché de proyección desde GET /agent/context. Es el ÚNICO
+# camino por el que una terminal ABIERTA se entera de algo nuevo: `session-start.sh` hidrata
+# una vez al arrancar y `slice-ops.sh` solo en claim/status — y el claim ocurre una vez por
+# slice, así que sin esto una sesión larga trabaja horas contra una foto vieja (#61).
+# Solo en modo `runtime`: en legacy|dual el fichero local es primario y el comportamiento no
+# cambia. `agent_context_fetch_and_cache` NUNCA pisa la caché anterior si falla (fail-open);
+# aquí solo se anota el diagnóstico, para que `status` distinga «vieja» de «no se pudo».
+#
+# `last_context_status` es SIEMPRE una cadena. El diagnóstico no es solo un código HTTP
+# (`"write_error"` no lo es) y `"000"` —el valor de «sin red» de `runtime_http_status`— no es
+# un número JSON válido: emitirlo sin comillas rompía el parseo del fragmento entero y
+# `hb_write_status` acababa no escribiendo NADA, ni siquiera el `context_stale: true`.
+hb_refresh_context() {
+  local status rc
+  [ "$(runtime_mode)" = "runtime" ] || return 0
+  agent_context_fetch_and_cache >/dev/null 2>&1
+  rc=$?
+  if [ "$rc" -eq 0 ]; then
+    hb_write_status "{\"context_stale\": false, \"last_context_status\": \"200\", \"last_context_refresh_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}"
+    return 0
+  fi
+  # [#61 · ronda final] Un 200 que no se pudo normalizar o escribir NO es un fallo de red:
+  # anotarlo como «último intento: 200» mandaba a mirar el sitio equivocado.
+  if [ "$rc" -eq 2 ]; then
+    status="write_error"
+  else
+    status="$(runtime_http_status)"
+  fi
+  hb_write_status "{\"context_stale\": true, \"last_context_status\": \"$status\"}"
+  return 1
+}
+
 hb_daemon() {
-  local pidf interval ttl last now n
+  local pidf interval ttl last last_ctx now n
   pidf="$(hb_pidfile)"
   mkdir -p "$(dirname "$pidf")"
   printf '%s' "$$" > "$pidf"
@@ -184,6 +237,9 @@ hb_daemon() {
       ;;
   esac
   last=0
+  # `session-start.sh` acaba de hidratar la caché: arrancar el contador AHORA evita un
+  # refresco redundante en el primer tick del daemon.
+  last_ctx="$(date +%s)"
   while :; do
     sleep "$HB_TICK_S"
     n="$(hb_prune_sessions)"
@@ -194,6 +250,10 @@ hb_daemon() {
       runtime_dispatch_outbox >/dev/null 2>&1
     fi
     now="$(date +%s)"
+    if [ "$HB_CONTEXT_S" -gt 0 ] && [ $(( now - last_ctx )) -ge "$HB_CONTEXT_S" ]; then
+      hb_refresh_context
+      last_ctx="$now"
+    fi
     if [ $(( now - last )) -ge "$interval" ]; then
       hb_renew
       runtime_dispatch_outbox >/dev/null 2>&1

package/hooks/build/lib/agent-context.sh

@@ -102,8 +102,12 @@ out = {
         "checkpoint": checkpoint,
     },
     "nudges": nudges,
+    # [#63] `graph_version` viaja junto al manifest_hash: es la foto del BACKLOG (épicas y sus
+    # estados), no la del contexto gobernado. Un hub que no versiona la deja en None y el
+    # cliente sigue funcionando exactamente igual que antes (compatibilidad hacia atrás).
     "context": {"manifest_hash": first(ctx.get("manifest_hash"), raw.get("manifest_hash")),
-                "version": first(ctx.get("version"), raw.get("context_version"))},
+                "version": first(ctx.get("version"), raw.get("context_version")),
+                "graph_version": first(ctx.get("graph_version"), raw.get("graph_version"))},
     "lease": {"expires_at": first(lease.get("expires_at"), raw.get("lease_expires_at")),
               "ttl_s": first(lease.get("ttl_s"), raw.get("lease_ttl_s"))},
 }
@@ -120,20 +124,25 @@ PY
 }
 
 # agent_context_fetch_and_cache — GET /agent/context, normaliza y escribe la caché.
-# rc 0 = caché actualizada · 1 = no se pudo (red, status != 200, respuesta ilegible):
-# en ese caso la caché anterior NO se toca, y los guards siguen operando con ella.
+# rc 0 = caché actualizada · 1 = no se pudo TRAER (red caída, status != 200) · 2 = el hub
+# respondió 200 pero la respuesta no se pudo normalizar o la proyección no se pudo escribir.
+# En ambos fallos la caché anterior NO se toca y los guards siguen operando con ella.
+# [#61 · ronda final] El 2 no es cosmético: con un solo rc de fallo, quien diagnostica después
+# leía `runtime_http_status` == 200 y anunciaba «no se pudo refrescar (último intento: 200)»,
+# que manda a mirar la red cuando el problema está en el disco o en el cuerpo de la respuesta.
+# Todos los llamadores ramifican sobre «rc != 0», así que el código nuevo no cambia su flujo.
 agent_context_fetch_and_cache() {
   local body status tmp norm rc
   body="$(runtime_get "$AGENT_CONTEXT_PATH")"
   status="$(runtime_http_status)"
   [ "$status" = "200" ] || return 1
-  tmp="$(mktemp)" || return 1
+  tmp="$(mktemp)" || return 2
   printf '%s' "$body" > "$tmp"
   norm="$(agent_context_normalize "$tmp")"
   rc=$?
   rm -f "$tmp"
-  [ $rc -eq 0 ] || return 1
-  [ -n "$norm" ] && [ "$norm" != "{}" ] || return 1
-  runtime_projection_write "$norm" || return 1
+  [ $rc -eq 0 ] || return 2
+  [ -n "$norm" ] && [ "$norm" != "{}" ] || return 2
+  runtime_projection_write "$norm" || return 2
   return 0
 }

package/hooks/build/lib/config.sh

@@ -5,8 +5,32 @@
 # config_get. Diseño: fail-open, igual que state-io.sh — nunca lanza.
 
 # config_root — raíz del proyecto consumidor (misma señal que state_path en state-io.sh).
+#
+# Worktrees: el estado del arnés (runtime.credentials, runtime-projection.json,
+# outbox/, build-state.json) está en .gitignore — es secreto y working state, no
+# se versiona — así que NO viaja a un `git worktree add`. Resolviendo la raíz solo
+# por el toplevel, todo agente que arranque en un worktree se queda sin
+# credenciales y opera HUÉRFANO: sin identidad de proyecto, sin lease, sin
+# reportar al hub, y con los guards inhibidos porque su fail-open de auto-arme no
+# distingue "este proyecto no usa el arnés" de "no veo el estado desde aquí".
+# Por eso, cuando el árbol actual no tiene estado, se cae al clon principal
+# (--git-common-dir), que es donde vive de verdad. Idempotente para un clon
+# normal: si el candidato ya tiene estado, se devuelve tal cual.
 config_root() {
-  echo "${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+  local candidate
+  candidate="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+  [ -f "$candidate/.claude/state/runtime.credentials" ] && { echo "$candidate"; return; }
+
+  local common main
+  common="$(git -C "$candidate" rev-parse --git-common-dir 2>/dev/null)" || common=""
+  if [ -n "$common" ]; then
+    case "$common" in /*) ;; *) common="$candidate/$common" ;; esac
+    main="$(cd "$common/.." 2>/dev/null && pwd)" || main=""
+    if [ -n "$main" ] && [ -f "$main/.claude/state/runtime.credentials" ]; then
+      echo "$main"; return
+    fi
+  fi
+  echo "$candidate"
 }
 
 # config_get <clave.punteada> <default>