(1) **VEREDICTO: BLOQUEADO** (2) **Hallazgos** 1. **BLOQUEANTE — Un fallo del INSERT de telemetría puede destruir el claim soberano.** `abrirIntento()` ejecuta el `INSERT` usando la misma transacción del claim y captura el error en TypeScript ([material/telemetria-lateral.ts:161](), [material/telemetria-lateral.ts:188]()). El despachador incluso tiene otro `catch` ([material/despachador-fragmentos.ts:36]()). Eso no revive una transacción PostgreSQL que ya entró en estado aborted. El `UPDATE work_items ... SET status='leased'` puede terminar rollbackeado; dependiendo de cómo el driver trate el `COMMIT` de una tx abortada, incluso existe el riesgo de devolver al worker un lease que no quedó persistido. **Corrección mínima:** envolver únicamente `abrirIntento` en un `SAVEPOINT`; ante error hacer rollback al savepoint y continuar el claim. Alternativamente mover la apertura post-commit y aceptar el hueco reconciliable. Un `try/catch` JS no basta. 2. **BLOQUEANTE — Con el flag OFF el camino SQL no es byte-a-byte idéntico.** El claim cambió incondicionalmente su `RETURNING`: agrega `attempts`, `created_at` y `now() AS telemetria_leased_at` ([material/diff-completo.patch:327]()). El cierre también cambia incondicionalmente de `RETURNING workspace_id` a `RETURNING workspace_id, closed_at` ([material/diff-completo.patch:365](), [material/diff-completo.patch:374]()). El `if (telemetriaEncendida())` ocurre después de ejecutar el SQL. El test OFF solo demuestra que no aparecen filas laterales ([material/diff-completo.patch:289]()), no que el camino soberano sea idéntico. **Corrección mínima:** con flag OFF ejecutar literalmente los SQL anteriores. La variante con columnas adicionales solo debe existir en la rama ON, o recuperar metadata lateral después sin alterar las sentencias soberanas. 3. **BLOQUEANTE — El observador no reproduce exactamente las ramas del resolver real.** El observador considera `path_missing` siempre que exista `path` y el valor actual no sea objeto ([material/resolver-observado.ts:31]()). El resolver real solo recorre la ruta cuando `path && val && typeof val === 'object'`; si el upstream es un primitivo/null/undefined, omite el recorrido y devuelve ese valor ([material/resolver-observado.ts:89]()). Ejemplo comprobable: con `r3 = 'texto'`, `{{steps.r3.outputs.x}}` termina siendo `"texto"` en el resolver, pero el observador afirma `path_missing`. Hay además una segunda mentira: `resolver()` convierte valores exitosos `undefined` a `null` ([material/resolver-observado.ts:40]()), y el worker hashea ese `null` ([material/worker-fragmento.ts:30]()). Para un inline cuyo valor real es `undefined`, el resolver produce `"undefined"` ([material/resolver-observado.ts:103]()), mientras la telemetría almacena la huella de JSON `null`. Y `source_missing`/`path_missing` también reciben `valor:null`, por lo que actualmente pueden terminar con hash de `null` aunque no exista valor resuelto. **Corrección mínima:** extraer una única primitiva de resolución compartida por resolver y observador, o replicar literalmente las condiciones actuales. No normalizar `undefined` a `null` para observación inline; y generar hash únicamente para `resolved`/`inline_resolved`, nunca para `path_missing`/`source_missing`. 4. **SERIO — `telemetria_inconsistente` todavía no protege contra pérdida parcial de filas.** La evidencia dice que la herramienta declara inconsistencia cuando el receipt declara N y “no hay ninguna fila” ([material/evidencia.md:159]()). Eso solo detecta pérdida total. Si un intento tiene `edge_count=8` y quedan 7 filas, el receipt continúa `complete`; precisamente la arista eliminada puede volver a parecer `sin_consumo`. Además `substrate_app` recibe `DELETE` sobre estas tablas ([material/migracion-0116.sql:112]()), así que la mutabilidad no es puramente teórica. **Corrección mínima:** para todo receipt `complete`, exigir `COUNT(edge_transfers WHERE lease_token)=edge_count`. Cualquier `<`, `>` o contradicción convierte el intento completo en `telemetria_inconsistente` y prohíbe `sin_consumo`. 5. **SERIO — La mordida documentada del receipt ya no prueba lo que afirma.** [material/evidencia.md:110]() afirma que `registrarConsumos` devuelve `0` cuando falla y que por eso `escritos < 0` nunca era verdadero. La implementación suministrada devuelve `-1` al fallar ([material/telemetria-lateral.ts:312]()). Por tanto, romper la tabla y obtener `failed` no demuestra que el cambio a `escritos < consumos.length` sea el que salvó el receipt: con el código actual, incluso `escritos < 0` detectaría ese fallo. **Corrección mínima:** morder un **short write**, no un error total: preinsertar una PK conflictiva y distinta, provocar que `RETURNING` entregue N-1, y comprobar que el receipt queda `failed`/inconsistente. 6. **MENOR — `error_code` no garantiza por código que sea realmente un código.** Se persiste cualquier string encontrado en `cierre.error.code` ([material/despachador-fragmentos.ts:78](), [material/despachador-fragmentos.ts:85]()) y la columna acepta texto arbitrario ([material/migracion-0116.sql:28]()). No veo mensajes/payloads escritos deliberadamente, pero la garantía “código, nunca texto de negocio” depende de convención. **Corrección mínima:** allowlist/normalización de códigos internos; cualquier valor desconocido → `null`/`UNCLASSIFIED`. Los `console.warn` sí imprimen `error.message` ([material/telemetria-lateral.ts:150](), [material/worker-fragmento.ts:47]()), aunque eso queda fuera de las tablas laterales. (3) **R1..R8** **R1. ¿Flag OFF realmente idéntico?** No. No hay escrituras laterales, pero sí cambian los dos `RETURNING` soberanos y los tipos intermedios que reciben esos resultados. El test actual verifica “cero filas de telemetría”, no identidad del camino SQL. **R2. ¿Telemetría puede abortar claim/cierre/recuperación?** Sí, el **claim está roto** frente a un error PostgreSQL real en `abrirIntento`: el `catch` no desaborta la transacción. Cierre y watchdog están mucho mejor: sus escrituras laterales ocurren post-commit ([material/despachador-fragmentos.ts:73](), [material/despachador-fragmentos.ts:119]()) y no pueden revertir el estado soberano. **R3. ¿Identidad por `lease_token` correcta?** Sí en lo esencial. Cada claim genera un UUID nuevo ([material/despachador-fragmentos.ts:26]()), la PK es `lease_token` ([material/migracion-0116.sql:16]()) y el nuevo intento no pisa al viejo. El watchdog usa exactamente el token recuperado y solo lo marca si la recuperación soberana efectivamente ocurrió ([material/despachador-fragmentos.ts:121]()). Puede faltar fila si telemetría estaba apagada/falló; eso debe significar desconocido, no “no hubo intento”. No encontré dos intentos legítimos compartiendo token. **R4. ¿Observador exactamente equivalente?** No. Objetos con rutas inexistentes, step inexistente, arrays anidados, inline múltiples y el valor literalmente igual a otro template están razonablemente cubiertos. La divergencia está en **ruta aplicada a primitivo/null/undefined**, y en el tratamiento de `undefined` inline. Además se hashea `null` para estados missing. Esto bloquea. **R5. ¿Procedencia correcta?** En el material suministrado, sí. El diseño establece que la fusión de propias/heredadas es disjunta ([material/diseno-v02.md:31]()), por lo que comprobar pertenencia a `heredadas` ([material/worker-fragmento.ts:23]()) es válido. Si falta `source_run_id` o `source_work_item_id`, la fila se omite y `omitidos > 0` fuerza receipt `failed` ([material/worker-fragmento.ts:26](), [material/worker-fragmento.ts:41]()). No encontré un camino que convierta esa omisión en `complete`. **R6. ¿Puede haber `complete` faltando filas?** Durante el batch inicial no veo un camino normal: el INSERT es una única sentencia y `escritos < consumos.length` es conservador. **Después**, sí: una pérdida parcial de `edge_transfers` deja el receipt `complete`. La defensa documentada solo contempla cero filas, no `actual_count != edge_count`. Así Graph Health todavía puede fabricar un `sin_consumo` falso. **R7. ¿Se filtra contenido?** No encontré payload, valor resuelto, brief ni keyword guardados directamente: quedan metadata, tamaños y hashes. El agujero es `error_code`, que actualmente acepta cualquier string. Los mensajes completos también aparecen en logs, pero no en las tablas de telemetría. **R8. ¿Qué mordidas faltan?** Las críticas son: - provocar **un error SQL real dentro de `abrirIntento`**, no un mock, y demostrar que el claim soberano sigue committed; hoy esa prueba debería fallar; - matriz resolver/observador con `primitive.path`, `null.path`, `undefined.path`, `undefined` inline y missing inline; - borrar **una sola** `edge_transfer` de un intento con N>1 y exigir `telemetria_inconsistente`; - morder un `RETURNING` parcial/conflicto para validar realmente `< consumos.length`; - completar la prueba que la propia evidencia reconoce pendiente: mantener vivo el `source_work_item_id` heredado y recomputar el hash cross-run end-to-end ([material/evidencia.md:141]()). (4) **Lo revisado que quedó bien** - La identidad física por `lease_token` corrige correctamente el problema de `attempt`. - Cierre normal y watchdog escriben telemetría después del commit soberano. - Las referencias inline múltiples tienen identidad por `input_path + ref_ordinal`. - La procedencia heredada queda obligatoria por CHECK y las omisiones degradan el receipt a `failed`. - Las filas antiguas de `work_items` quedan `created_at=NULL`; no se inventa historia. - El canonicalizador evita almacenar payload y los hashes TS↔Python tienen evidencia sólida para el corpus probado. - La clasificación por rama evita el viejo error de inferir resolución comparando strings; el caso “el valor es literalmente otro template” está bien resuelto. - `run_events` sigue sin ser modificado por esta telemetría. El bloqueo principal no está en Graph Health: está antes. **Mientras `abrirIntento` pueda envenenar la transacción del claim y el observador pueda describir una rama distinta de la que ejecutó `resolveStepRefs`, la telemetría todavía tiene autoridad accidental sobre la ejecución y puede producir evidencia falsa.**