<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Alexis Román</title>
    <description>The latest articles on DEV Community by Alexis Román (@alexisromtz7).</description>
    <link>https://dev.to/alexisromtz7</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4087143%2F1473ce2a-9b3c-4fa1-a30d-135640b37e45.JPG</url>
      <title>DEV Community: Alexis Román</title>
      <link>https://dev.to/alexisromtz7</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/alexisromtz7"/>
    <language>en</language>
    <item>
      <title>Encontré 2 bugs reales en Django y decidí no reportarlos. La razón es más interesante que el bug.</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Tue, 17 Nov 2026 19:24:53 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/encontre-2-bugs-reales-en-django-y-decidi-no-reportarlos-la-razon-es-mas-interesante-que-el-bug-3b7n</link>
      <guid>https://dev.to/alexisromtz7/encontre-2-bugs-reales-en-django-y-decidi-no-reportarlos-la-razon-es-mas-interesante-que-el-bug-3b7n</guid>
      <description>&lt;h1&gt;
  
  
  Encontré 2 bugs reales en Django y decidí no reportarlos. La razón es más interesante que el bug.
&lt;/h1&gt;

&lt;p&gt;&lt;em&gt;Un embudo de tres etapas para auditar fronteras de acoplamiento, con tres de mis propios instrumentos refutados por la ejecución real.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;Pasé una noche midiendo si los ciclos de importación predicen fallos en producción. Al final tenía &lt;strong&gt;1 449 módulos auditados en 5 paquetes, 2 rupturas reales en el backend de base de datos de Django, 0 reportes enviados&lt;/strong&gt;. Este artículo es sobre por qué la tercera cifra es la correcta, y sobre los tres instrumentos que tuvieron que romperse para llegar a ella. El código, los datos y los falsadores están en &lt;a href="https://github.com/alexisromtz-lab/auditor-toolkit" rel="noopener noreferrer"&gt;auditor-toolkit&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  La premisa
&lt;/h2&gt;

&lt;p&gt;Los proyectos maduros acumulan invariantes implícitos: órdenes de carga, estado global, dependencias no declaradas. Sus propias suites de pruebas nunca los violan, porque las pruebas se escribieron obedeciendo esas reglas. Un consumidor externo —un adaptador, un plugin, un backend de base de datos de terceros— sí puede violarlas, y entonces el sistema falla de una forma que ningún linter detecta.&lt;/p&gt;

&lt;p&gt;Los linters responden a «¿existe un ciclo?». La pregunta útil es otra: &lt;strong&gt;¿existe una ruptura alcanzable?&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Etapa 1 — el candidato: mi primer instrumento, refutado tres veces
&lt;/h2&gt;

&lt;p&gt;Escribí un modelo posicional: una sentencia &lt;code&gt;from M import n&lt;/code&gt; solo rompe si &lt;code&gt;n&lt;/code&gt; no existe todavía en &lt;code&gt;M&lt;/code&gt; en el instante en que la sentencia corre. Suena correcto. Sobre 17 componentes fuertemente conexos (SCC) en django, pydantic, sqlalchemy, celery y django-filter, emitió veredicto en 14 de ellos y predijo &lt;strong&gt;11 rupturas&lt;/strong&gt; (los otros 3 los dio por &lt;code&gt;PASA&lt;/code&gt;, y 3 quedaron &lt;code&gt;NO_MEDIDO&lt;/code&gt;). La ejecución real, ya con todos los drivers instalados, encontró &lt;strong&gt;2&lt;/strong&gt; — y ninguna de las 11 estaba entre ellas.&lt;/p&gt;

&lt;p&gt;Lo corregí tres veces, cada vez con evidencia:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;versión&lt;/th&gt;
&lt;th&gt;defecto corregido&lt;/th&gt;
&lt;th&gt;predice ROMPE&lt;/th&gt;
&lt;th&gt;lecturas inseguras&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;v1&lt;/td&gt;
&lt;td&gt;un submódulo se medía contra el SCC en vez de contra el paquete completo&lt;/td&gt;
&lt;td&gt;14 / 17&lt;/td&gt;
&lt;td&gt;1 107&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;v2&lt;/td&gt;
&lt;td&gt;el corte de líneas se leía del módulo &lt;strong&gt;que lee&lt;/strong&gt;, no del &lt;strong&gt;leído&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;14 / 17&lt;/td&gt;
&lt;td&gt;1 050&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;v3&lt;/td&gt;
&lt;td&gt;regla padre-primero: un submódulo nunca está a medio ejecutar cuando su padre lo importa&lt;/td&gt;
&lt;td&gt;11 / 17&lt;/td&gt;
&lt;td&gt;625&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Y la razón por la que ninguna versión funciona no es un bug. Es estructural:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Dentro de un SCC, todo par de módulos se alcanza mutuamente. Por tanto «¿está &lt;code&gt;t&lt;/code&gt; a medio ejecutar?» &lt;strong&gt;no es decidible desde el AST&lt;/strong&gt;: depende de la pila de importación, es decir, del punto de entrada.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Comparado SCC a SCC contra la ejecución real: &lt;strong&gt;los 11 SCC que el modelo marcó &lt;code&gt;ROMPE&lt;/code&gt; ejecutaron &lt;code&gt;PASA&lt;/code&gt;. Las 2 rupturas reales están en los 2 SCC que declaró &lt;code&gt;NO_MEDIDO&lt;/code&gt;&lt;/strong&gt;. No acertó por exceso: falló por abstención justo donde hacía falta. Lo dejé en el código con un &lt;code&gt;REFUTADO COMO PREDICTOR&lt;/code&gt; en el docstring, porque un instrumento refutado es evidencia de que fue refutado.&lt;/p&gt;

&lt;h2&gt;
  
  
  Etapa 2 — la ruptura: aquí sí hay hechos
&lt;/h2&gt;

&lt;p&gt;Un ejecutor independiente importa cada módulo en un intérprete limpio, uno por proceso, y clasifica la causa del fallo (&lt;code&gt;ORDEN&lt;/code&gt; / &lt;code&gt;DEPENDENCIA&lt;/code&gt; / &lt;code&gt;OTRO&lt;/code&gt;). Reduce los 909 módulos de Django a 71 imports con veredicto.&lt;/p&gt;

&lt;p&gt;En la primera corrida reportó &lt;strong&gt;0 rupturas por orden&lt;/strong&gt;. Ese cero era un artefacto: tres SCC estaban marcados &lt;code&gt;NO_MEDIDO&lt;/code&gt; porque faltaban drivers opcionales. &lt;code&gt;NO_MEDIDO&lt;/code&gt; no es cero. Instalé &lt;code&gt;oracledb 26.1.0&lt;/code&gt; y &lt;code&gt;psycopg2 2.9.13&lt;/code&gt;, y el resultado cambió de signo:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="c1"&gt;# intérprete limpio, driver presente&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;django&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;backends&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;postgresql&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;introspection&lt;/span&gt;
&lt;span class="c1"&gt;# ImportError: cannot import name 'DatabaseIntrospection'&lt;/span&gt;
&lt;span class="c1"&gt;#   from partially initialized module 'django.db.backends.postgresql.introspection'&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;django&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;backends&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;oracle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;utils&lt;/span&gt;
&lt;span class="c1"&gt;# ImportError: cannot import name 'BoundVar'&lt;/span&gt;
&lt;span class="c1"&gt;#   from partially initialized module 'django.db.backends.oracle.utils'&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;django&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;backends&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;oracle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;operations&lt;/span&gt;
&lt;span class="c1"&gt;# ImportError: cannot import name 'DatabaseOperations'&lt;/span&gt;
&lt;span class="c1"&gt;#   from partially initialized module 'django.db.backends.oracle.operations'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El mecanismo, en tres líneas de código ajeno:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;oracle/operations.py:16   from .utils import BoundVar, ...                  → entra a utils
oracle/utils.py:4         from .base import Database                        → entra a base
oracle/base.py:65         from .operations import DatabaseOperations  ← operations a medio construir
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Entrando por &lt;code&gt;base&lt;/code&gt; o por el paquete, &lt;code&gt;Database&lt;/code&gt; ya está ligado antes de la línea 65 y todo pasa. Entrando por &lt;code&gt;utils&lt;/code&gt; u &lt;code&gt;operations&lt;/code&gt;, no. &lt;strong&gt;La ruptura es real. Lo que falta es quién la alcance.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Etapa 3 — el consumidor: donde mi instrumento me mintió dos veces
&lt;/h2&gt;

&lt;p&gt;Busqué los tres imports en GitHub. &lt;code&gt;total_count: 0 · 0 · 0&lt;/code&gt;. Un cero limpio. No abrí el ticket.&lt;/p&gt;

&lt;p&gt;Antes de publicarlo corrí un control positivo sobre el buscador, con la misma forma de consulta:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh api search/code -f &lt;span class="nv"&gt;q&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"from+django.db.backends.postgresql.base+import"&lt;/span&gt;   &lt;span class="c"&gt;# → 0&lt;/span&gt;
gh api search/code -f &lt;span class="nv"&gt;q&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"from django.db.backends.postgresql.base import"&lt;/span&gt;   &lt;span class="c"&gt;# → 11 696&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;0 contra 11 696 para la misma cadena.&lt;/strong&gt; En un parámetro de query, &lt;code&gt;+&lt;/code&gt; es un signo más literal, no un espacio. Mi instrumento devolvía cero para lo que existe.&lt;/p&gt;

&lt;p&gt;Lo rehice con espacios: 19 520 / 9 872 / 14 080. Igual de inservible, ahora en la dirección contraria: la API de búsqueda empareja &lt;strong&gt;tokens, no sentencias&lt;/strong&gt;, y los resultados caían en el propio &lt;code&gt;postgresql/base.py&lt;/code&gt; de Django.&lt;/p&gt;

&lt;p&gt;Tercer intento, instrumento distinto y exacto: censo sobre el árbol fuente de Django 6.1.3, población declarada —los &lt;strong&gt;5 módulos&lt;/strong&gt; que forman los dos SCC—, separando las aristas internas del ciclo (esas son el ciclo, no quien lo alcanza).&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;clase&lt;/th&gt;
&lt;th&gt;cuenta&lt;/th&gt;
&lt;th&gt;detalle&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;aristas internas del ciclo&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;7&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;oracle/base.py:65&lt;/code&gt;, &lt;code&gt;postgresql/introspection.py:6&lt;/code&gt;…&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;consumidores a nivel módulo&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;5&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;los 5 en &lt;code&gt;contrib.gis&lt;/code&gt;; &lt;strong&gt;2 rompen&lt;/strong&gt; al desenmascararlos, 3 están precedidos por su &lt;code&gt;base&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;consumidores dentro de función&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;13&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;11 en &lt;code&gt;tests/&lt;/code&gt;, 1 en &lt;code&gt;oracle/client.py:12&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;documentados en &lt;code&gt;docs/ref/&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Ejecuté los 5 como punto de entrada. &lt;strong&gt;Cuatro fallan por GDAL ausente&lt;/strong&gt;, no por el ciclo:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;django&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;contrib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;gis&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;backends&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;oracle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;operations&lt;/span&gt;
&lt;span class="c1"&gt;# ImproperlyConfigured: Could not find the GDAL library&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El quinto no llega al import roto porque su línea 4 ya cargó &lt;code&gt;postgresql.base&lt;/code&gt;. Es decir: &lt;strong&gt;GDAL no enmascara un caso, enmascara cuatro de cinco&lt;/strong&gt;. Y ésa no es una casilla vacía que se pueda dejar abierta: es la variable que decide si esta etapa tiene algún consumidor vivo.&lt;/p&gt;

&lt;h3&gt;
  
  
  Así que la desenmascaré
&lt;/h3&gt;

&lt;p&gt;Instalar GDAL por Homebrew son 44 fórmulas. Usé una más barata y sin trampa: el wheel de &lt;code&gt;rasterio&lt;/code&gt; embarca un &lt;code&gt;libgdal.38.3.12.2.dylib&lt;/code&gt; &lt;strong&gt;real&lt;/strong&gt;, y basta apuntarlo con &lt;code&gt;GDAL_LIBRARY_PATH&lt;/code&gt;. No es un stub: es la misma biblioteca C que Django enlaza.&lt;/p&gt;

&lt;p&gt;Al hacerlo apareció una capa que no había previsto: &lt;strong&gt;no era una máscara, eran dos.&lt;/strong&gt; &lt;code&gt;geos/__init__.py:16&lt;/code&gt; importa &lt;code&gt;.libgeos&lt;/code&gt;, así que sin GEOS el módulo muere igual, un piso más abajo. Dos bibliotecas C hay que satisfacer antes de que un solo &lt;code&gt;import&lt;/code&gt; de &lt;code&gt;contrib.gis&lt;/code&gt; llegue a ejecutar Python propio.&lt;/p&gt;

&lt;p&gt;Con las dos presentes, y tras &lt;code&gt;django.setup()&lt;/code&gt;:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;consumidor&lt;/th&gt;
&lt;th&gt;antes&lt;/th&gt;
&lt;th&gt;después&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;gis/oracle/operations.py:20&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;GDAL ausente&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;&lt;code&gt;ImportError&lt;/code&gt;: &lt;code&gt;oracle.operations&lt;/code&gt; parcialmente inicializado&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;gis/postgis/introspection.py:2&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;GDAL ausente&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;&lt;code&gt;ImportError&lt;/code&gt;: &lt;code&gt;postgresql.introspection&lt;/code&gt; parcialmente inicializado&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;gis/oracle/base.py:1&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;GDAL ausente&lt;/td&gt;
&lt;td&gt;pasa (es la entrada segura)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;gis/postgis/base.py:4&lt;/code&gt; y &lt;code&gt;:8&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;cubierto&lt;/td&gt;
&lt;td&gt;pasa (la línea 4 precede a la 8)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Dos de los cinco consumidores llegan al ciclo y rompen.&lt;/strong&gt; El hallazgo cambia de signo: ya no es «cero accionables», es «dos accionables que ninguna biblioteca nativa alcanzaba a mostrar».&lt;/p&gt;

&lt;h3&gt;
  
  
  Y aquí está la prueba que hacía falta
&lt;/h3&gt;

&lt;p&gt;Mismo intérprete, misma configuración, mismo módulo. Lo único que cambia es el orden:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;django&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;contrib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;gis&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;backends&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;oracle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;operations&lt;/span&gt;
&lt;span class="c1"&gt;# ImportError: cannot import name 'DatabaseOperations' from partially initialized module&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;django&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;contrib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;gis&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;backends&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;oracle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;base&lt;/span&gt;      &lt;span class="c1"&gt;# primero esto&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;django&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;contrib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;gis&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;db&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;backends&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;oracle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;operations&lt;/span&gt;  &lt;span class="c1"&gt;# y ahora esto&lt;/span&gt;
&lt;span class="c1"&gt;# OK&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Lo mismo con &lt;code&gt;postgis.introspection&lt;/code&gt; y &lt;code&gt;postgis.base&lt;/code&gt;. &lt;strong&gt;El control negativo está dentro de la misma medición&lt;/strong&gt;: las dos secuencias «base primero» existen justamente para refutar que la causa sea el entorno. No lo refutan. La causa es el orden.&lt;/p&gt;

&lt;p&gt;Esto no es un bug de instalación ni una rareza de mi máquina: es un módulo que se rompe según quién lo importe antes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;No abrí el ticket&lt;/strong&gt; — pero no por lo que creía. El criterio que me dejó el &lt;code&gt;wontfix&lt;/code&gt; («sin un consumidor nombrado &lt;em&gt;y alcanzable&lt;/em&gt;, no hay bug: hay texto») se pone a prueba tres párrafos más abajo, y no sale como esperaba: al desenmascarar GDAL, el consumidor aparece. Que aun así no haya ticket tiene otra razón, y es la que vale.&lt;/p&gt;

&lt;h2&gt;
  
  
  Las tres reglas que me costaron la noche
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1. &lt;code&gt;NO_MEDIDO&lt;/code&gt; no es cero.&lt;/strong&gt; Dos veces. Los drivers ausentes fabricaron un nulo; el &lt;code&gt;+&lt;/code&gt; en la consulta fabricó el otro. Un cero con dependencias no declaradas es una mentira estadística.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Un cero que también da cero para lo que existe es un instrumento roto.&lt;/strong&gt; El control positivo no es burocracia: es lo único que distingue «no hay» de «no miré». Y un control positivo &lt;strong&gt;no basta&lt;/strong&gt;: mi modelo posicional lo pasaba —sabía emitir &lt;code&gt;ROMPE&lt;/code&gt;— y aun así sus 11 candidatos salieron limpios. Hace falta también el control que debe salir limpio.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. La etapa que convierte ruptura en hallazgo no es el análisis: es el consumidor.&lt;/strong&gt; Sin ella habría publicado un hallazgo falso por segunda vez.&lt;/p&gt;

&lt;h2&gt;
  
  
  El embudo, y lo que queda abierto
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;etapa&lt;/th&gt;
&lt;th&gt;instrumento&lt;/th&gt;
&lt;th&gt;resultado&lt;/th&gt;
&lt;th&gt;control positivo&lt;/th&gt;
&lt;th&gt;control negativo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;candidato&lt;/td&gt;
&lt;td&gt;AST estático&lt;/td&gt;
&lt;td&gt;17 SCC · 11 predichos &lt;code&gt;ROMPE&lt;/code&gt; · 625 lecturas&lt;/td&gt;
&lt;td&gt;sí&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;no: 11/11 falsos&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ruptura&lt;/td&gt;
&lt;td&gt;ejecución en intérprete limpio&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;2 SCC · 3 puntos de entrada&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;sí, uno por proceso&lt;/td&gt;
&lt;td&gt;sí&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;consumidor&lt;/td&gt;
&lt;td&gt;censo del sdist&lt;/td&gt;
&lt;td&gt;5 a nivel módulo · &lt;strong&gt;2 rompen al desenmascararlos&lt;/strong&gt; · 13 en función · 0 documentados&lt;/td&gt;
&lt;td&gt;sí&lt;/td&gt;
&lt;td&gt;sí&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Y el veredicto de la predicción que quedaba abierta. La corrí. &lt;strong&gt;3 de 4 acertadas&lt;/strong&gt;, y la que falló es un defecto de mi pre-registro, no del modelo: predije &lt;code&gt;PASA&lt;/code&gt; para &lt;code&gt;postgis/base&lt;/code&gt; y sin &lt;code&gt;django.setup()&lt;/code&gt; da &lt;code&gt;AppRegistryNotReady&lt;/code&gt;, una tercera clase de fallo que no declaré como precondición. Con &lt;code&gt;setup()&lt;/code&gt;, pasa, como estaba escrito. La lección no es «acerté»: es que &lt;strong&gt;un pre-registro sin sus precondiciones no es falsable, es una frase&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Las dos que importan acertaron, y acertaron en la dirección incómoda: el ciclo es alcanzable y rompe de verdad.&lt;/p&gt;

&lt;h2&gt;
  
  
  Nivel 7: la pregunta que sí tiene respuesta
&lt;/h2&gt;

&lt;p&gt;Hasta aquí la pregunta era «¿el ciclo predice la ruptura?», y la respuesta es que no: mis once candidatos salieron limpios. Pero hay una pregunta mejor, y esta sí se contesta con números: &lt;strong&gt;¿qué le permite a un paquete tener ciclos y no romperse?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Cambié la unidad de medida. En vez de contar ciclos, conté &lt;strong&gt;lectores&lt;/strong&gt;: módulos fuera del ciclo cuyo &lt;code&gt;import&lt;/code&gt; a nivel módulo resuelve a un miembro del ciclo. Un lector es la persona que entra por la puerta de atrás. Para cada uno, dos sondas en intérprete limpio: &lt;code&gt;import R&lt;/code&gt;, y &lt;code&gt;import &amp;lt;predecesor&amp;gt;; import R&lt;/code&gt;. Si la primera rompe por ciclo y la segunda pasa, la causa es el orden y nada más.&lt;/p&gt;

&lt;p&gt;Sobre los mismos 17 ciclos:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;celda&lt;/th&gt;
&lt;th&gt;qué significa&lt;/th&gt;
&lt;th&gt;cuántos&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;INERTE&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;nadie de fuera entra por el ciclo&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;13&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;INMUNE_CONSTRUCCION&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;entra alguien y rompe, pero hay una entrada que lo salva&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;4&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;MINA_VIVA&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;entra alguien, rompe, y ninguna entrada lo salva&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Cinco pares (ciclo, lector) rompen, sobre &lt;strong&gt;cuatro módulos distintos&lt;/strong&gt;, todos en Django: &lt;code&gt;db.backends.oracle.operations&lt;/code&gt;, &lt;code&gt;db.backends.postgresql.introspection&lt;/code&gt;, &lt;code&gt;contrib.gis.db.backends.oracle.operations&lt;/code&gt; y &lt;code&gt;contrib.gis.db.backends.postgis.introspection&lt;/code&gt;. (Son 4 módulos y no «2 rupturas» como dice la tabla de arriba porque cuento poblaciones distintas: allí, ciclos que rompen; aquí, módulos que rompen al importarse primero.)&lt;/p&gt;

&lt;p&gt;Y aquí está el dato que no esperaba. Esos cuatro módulos se reparan con &lt;strong&gt;dos&lt;/strong&gt;: &lt;code&gt;db.backends.oracle.base&lt;/code&gt; y &lt;code&gt;db.backends.postgresql.base&lt;/code&gt;. El invariante que protege a Django &lt;strong&gt;no vive en el ciclo, vive en el paquete&lt;/strong&gt;: entra por &lt;code&gt;.base&lt;/code&gt;. Es una convención de una línea, y su API pública la impone en &lt;code&gt;django/db/utils.py:116&lt;/code&gt;. En pydantic, sqlalchemy y django-filter, sus &lt;strong&gt;7&lt;/strong&gt; ciclos no tienen ni un lector que rompa: cero convención necesaria.&lt;/p&gt;

&lt;p&gt;También me equivoqué aquí, y conviene decirlo. Mi pre-registro afirmaba que sólo dos de los diecisiete ciclos rompían; rompen cuatro. Y el reparador ni siquiera estaba donde lo busqué: para dos de ellos &lt;strong&gt;ningún&lt;/strong&gt; miembro del propio ciclo repara — el que repara pertenece a otro ciclo. Por eso la tabla final publica dos columnas, «repara en su vecindario» y «repara en todo el paquete». Quince de diecisiete predicciones correctas: fallé en los dos ciclos del bloque &lt;code&gt;db.models&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Lo que cambia para el ticket: no es que Django sea inmune por no tener ciclos —tiene diecisiete—. Es inmune porque tiene &lt;strong&gt;una entrada declarada&lt;/strong&gt; y la hace cumplir. Eso no lo arregla un &lt;code&gt;if&lt;/code&gt;, y no lo descubre un linter. Es exactamente el tipo de invariante implícito que este embudo existe para encontrar.&lt;/p&gt;

&lt;p&gt;Entonces, ¿por qué sigo sin abrir el ticket?&lt;/p&gt;

&lt;p&gt;Porque medí también el consumidor real, y ese número es pequeño y preciso: &lt;code&gt;django/db/utils.py:116&lt;/code&gt; hace &lt;code&gt;import_module("%s.base" % backend_name)&lt;/code&gt; — Django &lt;strong&gt;siempre&lt;/strong&gt; carga &lt;code&gt;base&lt;/code&gt; antes de &lt;code&gt;operations&lt;/code&gt;. En el uso normal el fallo no puede ocurrir. Vive en el único hueco donde alguien importe &lt;code&gt;operations&lt;/code&gt; primero: un paquete de terceros que herede &lt;code&gt;DatabaseOperations&lt;/code&gt; a nivel de módulo. Que ese paquete exista o no lo sigo teniendo en &lt;code&gt;NO_MEDIDO&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Es una mina, no un incendio. Y una mina sin denominador medido no se reporta: se documenta.&lt;/p&gt;

&lt;p&gt;Y queda una casilla honesta: el consumidor &lt;strong&gt;externo&lt;/strong&gt; de terceros es &lt;code&gt;NO_MEDIDO&lt;/code&gt;. No tengo hoy un instrumento que pruebe una sentencia literal sobre GitHub, y no voy a rellenar esa casilla con un número que no se distingue de un instrumento roto.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Medido el 16 y 17 de noviembre de 2026 sobre django 6.1.3, pydantic 2.14.3, sqlalchemy 2.1.9, celery 5.7.0, django-filter 26.2, Python 3.14.8 en macOS, con GDAL 3.12.2 y GEOS 3.15.0. Los tres instrumentos de esta medición —con su pre-registro, sus datos y sus falsadores ejecutables— están publicados en &lt;a href="https://github.com/alexisromtz-lab/auditor-toolkit" rel="noopener noreferrer"&gt;auditor-toolkit v0.2.0&lt;/a&gt;, DOI &lt;a href="https://doi.org/10.5281/zenodo.24323318" rel="noopener noreferrer"&gt;10.5281/zenodo.24323318&lt;/a&gt;, bajo &lt;a href="https://github.com/alexisromtz-lab/auditor-toolkit/tree/main/research/frontera-import" rel="noopener noreferrer"&gt;&lt;code&gt;research/frontera-import/&lt;/code&gt;&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — y la compuerta que los emite se mueve a mano, sin llamadas de red, en &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>spanish</category>
      <category>python</category>
      <category>django</category>
      <category>testing</category>
    </item>
    <item>
      <title>Dos parches, la misma política en verde: uno cierra 5 vías SSRF y el otro 1</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Sun, 15 Nov 2026 17:50:05 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/dos-parches-la-misma-politica-en-verde-uno-cierra-5-vias-ssrf-y-el-otro-1-1c7</link>
      <guid>https://dev.to/alexisromtz7/dos-parches-la-misma-politica-en-verde-uno-cierra-5-vias-ssrf-y-el-otro-1-1c7</guid>
      <description>&lt;p&gt;Un previsualizador de URLs recibe un enlace y devuelve una captura. Es una función tan común&lt;br&gt;
que casi nadie la revisa: alguien pega una URL, el servidor la busca, el servidor devuelve el&lt;br&gt;
render. Y el servidor, a diferencia de quien pegó el enlace, vive dentro de la red.&lt;/p&gt;

&lt;p&gt;El filtro que se escribe para eso es casi siempre el mismo: si la URL contiene &lt;code&gt;localhost&lt;/code&gt; o&lt;br&gt;
&lt;code&gt;127.&lt;/code&gt;, se rechaza. Lo escribí, y después escribí el parche que la literatura llama correcto.&lt;br&gt;
Medí las dos cosas con el mismo ataque.&lt;/p&gt;

&lt;p&gt;El resultado incómodo no es que el filtro falle. Es que &lt;strong&gt;el test que se escribe para&lt;br&gt;
demostrar que el filtro funciona pasa en los dos parches&lt;/strong&gt;, en el roto y en el sano, con la&lt;br&gt;
misma salida.&lt;/p&gt;
&lt;h2&gt;
  
  
  El servicio
&lt;/h2&gt;

&lt;p&gt;Dos servidores efímeros en loopback: uno &lt;strong&gt;interior&lt;/strong&gt;, que devuelve una marca que no debería&lt;br&gt;
salir nunca, y uno &lt;strong&gt;público&lt;/strong&gt;. El previsualizador recibe una URL, la busca y devuelve el&lt;br&gt;
cuerpo. Cinco vías intentan alcanzar el interior; la primera es la obvia y las otras cuatro&lt;br&gt;
son el mismo destino escrito de otra manera, o alcanzado de rebote.&lt;/p&gt;
&lt;h2&gt;
  
  
  El test que miente
&lt;/h2&gt;

&lt;p&gt;Los tres sujetos empiezan midiendo su propia política antes de que se dispare nada:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;POLITICA · destino_permitido, medido antes de atacar:
  127.0.0.1:80        -&amp;gt; False   (esperado: False en todo parche)
  93.184.216.34:443   -&amp;gt; True    (esperado: True en todo parche)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Esa salida es &lt;strong&gt;idéntica en el parche vulnerable, en el parche ingenuo y en el canónico&lt;/strong&gt;. Se&lt;br&gt;
bloquea loopback, se permite una IP pública. Si tu suite comprueba esto, tu suite está verde&lt;br&gt;
en los tres y no distingue nada. La política es una función; el ataque no pregunta por la&lt;br&gt;
función, pregunta por la representación.&lt;/p&gt;
&lt;h2&gt;
  
  
  Tres corridas, un comando
&lt;/h2&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;python3 exploit_poc.py                                  &lt;span class="c"&gt;# servicio vulnerable&lt;/span&gt;
python3 exploit_poc.py --app patch_secure.py --naive    &lt;span class="c"&gt;# el parche obvio&lt;/span&gt;
python3 exploit_poc.py --app patch_secure.py            &lt;span class="c"&gt;# el parche canónico&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;vía&lt;/th&gt;
&lt;th&gt;vulnerable&lt;/th&gt;
&lt;th&gt;parche obvio&lt;/th&gt;
&lt;th&gt;parche canónico&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;URL literal al interior&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;bloqueada&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;bloqueada&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;IP decimal &lt;code&gt;2130706433&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;bloqueada&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;IP hexadecimal &lt;code&gt;0x7f000001&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;bloqueada&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;IPv4 mapeada en IPv6 &lt;code&gt;[::ffff:127.0.0.1]&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;bloqueada&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;redirección 302 hacia el interior&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;entra&lt;/td&gt;
&lt;td&gt;bloqueada&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;total&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;5 de 5 · RC 0&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;4 de 5 · RC 0&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0 de 5 · RC 1&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;El parche obvio bloquea una. La única que bloquea es la que el atacante no usa.&lt;/p&gt;
&lt;h2&gt;
  
  
  Por qué la lista negra no puede ganar
&lt;/h2&gt;

&lt;p&gt;Es una asimetría de información, no un descuido. El filtro compara &lt;strong&gt;cadenas&lt;/strong&gt;; el atacante&lt;br&gt;
elige la cadena. &lt;code&gt;127.0.0.1&lt;/code&gt;, &lt;code&gt;2130706433&lt;/code&gt;, &lt;code&gt;0x7f000001&lt;/code&gt; y &lt;code&gt;[::ffff:127.0.0.1]&lt;/code&gt; son cuatro&lt;br&gt;
maneras de escribir la misma dirección, y la cuarta ni siquiera es IPv4: es IPv4 dentro de&lt;br&gt;
IPv6, y el sistema operativo la conecta igual. Para bloquearlas por texto hacen falta reglas&lt;br&gt;
para cada notación que exista hoy, más las que aparezcan.&lt;/p&gt;

&lt;p&gt;Y el &lt;code&gt;302&lt;/code&gt; no es una notación: es una decisión del servidor remoto. El filtro revisa la URL&lt;br&gt;
que le dieron y el cliente HTTP obedece la siguiente, que nadie revisó. Una lista negra sobre&lt;br&gt;
la primera URL no tiene nada que decir sobre la segunda.&lt;/p&gt;
&lt;h2&gt;
  
  
  El parche que sí
&lt;/h2&gt;

&lt;p&gt;El orden se invierte: primero se resuelve, después se decide.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;_resolver&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;host&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;infos&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getaddrinfo&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;host&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;socket&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;SOCK_STREAM&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nb"&gt;sorted&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;info&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;split&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"%"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;info&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;infos&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;direcciones&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;_resolver&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;nombre&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;puerto&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;direcciones&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;DestinoNoPermitido&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"{nombre} no resuelve a ninguna direccion"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;direccion&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;direcciones&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;ipaddress&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;ip_address&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;direccion&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;is_global&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;DestinoNoPermitido&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
            &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"{nombre} resuelve a {direccion}, que no es una direccion global"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;_pedir_fijado&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;direcciones&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;puerto&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;partes&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Tres cosas hacen que esto funcione donde la lista negra no:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Se juzga la dirección, no el texto.&lt;/strong&gt; &lt;code&gt;is_global&lt;/code&gt; es una propiedad del espacio de
direcciones, así que la notación deja de importar: las cuatro formas caen en la misma
comprobación, porque las cuatro resuelven al mismo &lt;code&gt;ip_address&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Se comprueban todas las respuestas, no la primera.&lt;/strong&gt; Un nombre puede resolver a varias
direcciones; validar una y conectar otra es el mismo agujero con más pasos. Por eso el
conjunto se reduce con &lt;code&gt;split("%")&lt;/code&gt; —fuera el identificador de zona— y se recorre entero.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Se conecta a la IP validada, no al nombre.&lt;/strong&gt; &lt;code&gt;_pedir_fijado&lt;/code&gt; abre la conexión contra
&lt;code&gt;direcciones[0]&lt;/code&gt; y manda el nombre sólo en la cabecera &lt;code&gt;Host&lt;/code&gt;. Si se volviera a resolver al
conectar, entre la comprobación y la conexión cabe un cambio de DNS.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Y la redirección se &lt;strong&gt;rechaza&lt;/strong&gt;: en modo estricto un &lt;code&gt;3xx&lt;/code&gt; lanza y no se sigue, porque la&lt;br&gt;
segunda URL es un destino nuevo y haber validado el primero no dice nada del segundo. Seguir&lt;br&gt;
el salto y re-validarlo también es correcto; tiene más caminos que revisar, y el camino que no&lt;br&gt;
se paga es el que se olvida.&lt;/p&gt;
&lt;h2&gt;
  
  
  El control que hace honesta la medición
&lt;/h2&gt;

&lt;p&gt;El parche canónico &lt;strong&gt;no bloquea todo&lt;/strong&gt;: &lt;code&gt;93.184.216.34:443 -&amp;gt; True&lt;/code&gt; sigue permitido, y esa&lt;br&gt;
línea se mide antes de atacar, en el mismo bloque que en el parche roto. Es la diferencia&lt;br&gt;
entre «cerré las cinco vías» y «rompí el previsualizador», que también daría cinco bloqueos y&lt;br&gt;
el mismo código de salida.&lt;/p&gt;

&lt;p&gt;Un parche que rechaza cualquier URL es trivial de escribir y no sirve para nada. El número que&lt;br&gt;
lo distingue no está en el total de bloqueos: está en la línea de política que se lee igual en&lt;br&gt;
el parche roto.&lt;/p&gt;
&lt;h2&gt;
  
  
  Reproducirlo
&lt;/h2&gt;

&lt;p&gt;Cinco segundos, biblioteca estándar, sin red externa, sin estado entre corridas:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone --depth 1 https://github.com/alexisromtz-lab/offensive-reproducers
&lt;span class="nb"&gt;cd&lt;/span&gt; offensive-reproducers/002-ssrf-pdf-renderer
python3 exploit_poc.py --app patch_secure.py --naive   &lt;span class="c"&gt;# RC 0 · 4 de 5 entran&lt;/span&gt;
python3 exploit_poc.py --app patch_secure.py           &lt;span class="c"&gt;# RC 1 · 0 de 5&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Si auditas esto mañana
&lt;/h2&gt;

&lt;p&gt;Cuando alguien diga «validamos la URL», las tres preguntas son: ¿se juzga el texto o la&lt;br&gt;
dirección resuelta?, ¿se comprueban todas las respuestas del DNS o sólo la primera?, ¿qué pasa&lt;br&gt;
con la segunda URL de una redirección? Con una respuesta negativa, el &lt;code&gt;localhost&lt;/code&gt; bloqueado no&lt;br&gt;
significa nada — y la suite seguirá en verde.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — y la compuerta que los emite se mueve a mano, sin llamadas de red, en &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>python</category>
      <category>webdev</category>
      <category>ssrf</category>
    </item>
    <item>
      <title>De 360 formas de escribir un archivo, sólo una escribe</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Sun, 15 Nov 2026 17:47:37 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/de-360-formas-de-escribir-un-archivo-solo-una-escribe-212i</link>
      <guid>https://dev.to/alexisromtz7/de-360-formas-de-escribir-un-archivo-solo-una-escribe-212i</guid>
      <description>&lt;p&gt;&lt;strong&gt;Fecha:&lt;/strong&gt; 2026-11-14 · &lt;strong&gt;Base medida:&lt;/strong&gt; el gate de pre-vuelo de este repositorio, con la precedencia leída de su propio código y una tabla de 360 estados precalculada.&lt;br&gt;
&lt;strong&gt;Origen de las cifras:&lt;/strong&gt; la tabla viaja dentro de la página publicada; cualquiera puede abrirla y contar.&lt;/p&gt;


&lt;h2&gt;
  
  
  El problema no es el código de salida: es el orden
&lt;/h2&gt;

&lt;p&gt;Un pre-vuelo que bloquea escrituras suele presentarse como una lista de comprobaciones. La nuestra tiene &lt;strong&gt;13 códigos de salida&lt;/strong&gt; y &lt;strong&gt;12 posiciones de guarda&lt;/strong&gt;, y esa diferencia de uno ya dice algo: dos códigos (&lt;code&gt;11&lt;/code&gt; y &lt;code&gt;19&lt;/code&gt;) comparten posición porque describen el mismo hecho visto desde dos lados —la huella ya habita el destino— y sólo se distinguen por si el blob es el contratado.&lt;/p&gt;

&lt;p&gt;Lo que casi nunca se documenta es la &lt;strong&gt;precedencia&lt;/strong&gt;. Sobre un archivo que git ignora, ¿qué se informa: que está sucio o que está fuera de perímetro? Depende del orden, y el orden casi siempre vive en la cabeza de quien lo escribió.&lt;/p&gt;

&lt;p&gt;En este repositorio el orden se publica en el propio gate, en una línea:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;20 -&amp;gt; 29 -&amp;gt; 10 -&amp;gt; 31 -&amp;gt; 14 -&amp;gt; 23 -&amp;gt; 11/19 -&amp;gt; 12 -&amp;gt; 13 -&amp;gt; 24 -&amp;gt; 15 -&amp;gt; 0
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Traducido: primero la aridad de la tupla, después la divergencia de rama, después si el destino existe, después si el universo está vacío, después si hay árbol git, &lt;strong&gt;después&lt;/strong&gt; si el archivo está ignorado, y sólo entonces el desfase del blob.&lt;/p&gt;

&lt;h2&gt;
  
  
  Seis preguntas, 360 estados
&lt;/h2&gt;

&lt;p&gt;El formulario interactivo pregunta seis cosas:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;#&lt;/th&gt;
&lt;th&gt;pregunta&lt;/th&gt;
&lt;th&gt;opciones&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;la tupla de pre-vuelo&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;el estado del destino&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;el estado del árbol git&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;el blob del disco frente al contrato&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;la huella en el destino&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;las líneas frente al contrato&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;code&gt;2 · 3 · 5 · 2 · 3 · 2 = 360&lt;/code&gt;. El simulador no ejecuta el gate: tiene la tabla precalculada y responde &lt;strong&gt;qué guarda dispara primero&lt;/strong&gt; para cada una de las 360 combinaciones.&lt;/p&gt;

&lt;p&gt;De las 360, &lt;strong&gt;exactamente una&lt;/strong&gt; llega al permiso terminal. El reparto medido:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;código&lt;/th&gt;
&lt;th&gt;qué informa&lt;/th&gt;
&lt;th&gt;estados&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;20&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;uso incorrecto: aridad, argumento inválido o &lt;code&gt;TARGET&lt;/code&gt; no absoluto&lt;/td&gt;
&lt;td&gt;180&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;31&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;universo vacío — destino sin bytes con &lt;code&gt;LINEAS_PRE &amp;gt; 0&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;48&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;10&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;el destino no existe: es un alta&lt;/td&gt;
&lt;td&gt;48&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;29&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;divergencia de rama: la base es caduca&lt;/td&gt;
&lt;td&gt;36&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;23&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;el &lt;code&gt;TARGET&lt;/code&gt; está ignorado por git y fuera del perímetro&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;14&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;el destino no vive en un árbol git&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;11&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;la huella ya habita el destino &lt;strong&gt;y&lt;/strong&gt; el blob es el contratado&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;19&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;la huella habita el destino pero el blob &lt;strong&gt;no&lt;/strong&gt; es el contratado&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;12&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;blob distinto al contrato&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;13&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;estado sucio por cambios ajenos al &lt;code&gt;TARGET&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;15&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;líneas distintas al contrato&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;0&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;pre-vuelo correcto&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La mitad de los estados son un error de llamada. Eso no es un detalle: si la mitad de los usos falla en la aridad, el problema no es el gate, es su interfaz.&lt;/p&gt;

&lt;h2&gt;
  
  
  Por qué el &lt;code&gt;23&lt;/code&gt; va antes del &lt;code&gt;12&lt;/code&gt;
&lt;/h2&gt;

&lt;p&gt;Hay una decisión en ese orden que vale la pena aislar. Un archivo ignorado por git y sin perímetro declarado está &lt;strong&gt;prohibido&lt;/strong&gt;, con independencia de que su blob coincida o no con el contrato.&lt;/p&gt;

&lt;p&gt;Si el gate midiera primero el desfase, el mensaje sería «tu blob cambió» y alguien lo leería como «actualiza la tupla». Sería un gate que mide &lt;strong&gt;para autorizar&lt;/strong&gt; sobre un objeto que no puede autorizar. El orden es entonces parte del contrato, no un detalle de implementación: por eso se publica y por eso el simulador lo lee del código en vez de tenerlo escrito a mano.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lo que no se puede simular, se declara
&lt;/h2&gt;

&lt;p&gt;El código &lt;code&gt;24&lt;/code&gt; —el índice declara un bit de frescura (&lt;code&gt;assume-unchanged&lt;/code&gt;, &lt;code&gt;skip-worktree&lt;/code&gt;), así que &lt;code&gt;git status --porcelain&lt;/code&gt; devuelve &lt;strong&gt;vacío&lt;/strong&gt; aunque el disco haya cambiado— está en la lista, tiene su posición (la 10) y &lt;strong&gt;no aparece nunca&lt;/strong&gt; en la tabla de 360.&lt;/p&gt;

&lt;p&gt;La razón es que &lt;code&gt;assume-unchanged&lt;/code&gt; no es una pregunta de este formulario. Hay dos salidas posibles: inventar un estado donde ese código dispare, o declararlo. El artefacto lo declara, en un campo aparte:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;"codigo"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;24&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nl"&gt;"motivo"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"el bit de frescura del indice no se pregunta en este formulario"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Un cero en una tabla se lee como «no ocurre». Y &lt;code&gt;24&lt;/code&gt; sí ocurre: ocurre en el mundo real, todos los días, cuando alguien marca un archivo como &lt;code&gt;assume-unchanged&lt;/code&gt; para que &lt;code&gt;git status&lt;/code&gt; deje de molestarle. Un simulador que lo omitiera en silencio mentiría por omisión.&lt;/p&gt;

&lt;h2&gt;
  
  
  La página se deriva, no se teclea
&lt;/h2&gt;

&lt;p&gt;El detalle que hace todo esto mantenible: el HTML &lt;strong&gt;no es texto escrito a mano&lt;/strong&gt;. Se genera a partir de dos fuentes —la línea de orden y la tabla de la taxonomía— y cada bloque viaja con el identificador del objeto git de su fuente en el momento de generar.&lt;/p&gt;

&lt;p&gt;Eso da una propiedad concreta: si el gate cambia y la página no se regenera, un comparador lo dice con los dos identificadores a la vista, y el despliegue se detiene. La página publicada es el sujeto de la medición, no una copia de la idea.&lt;/p&gt;

&lt;p&gt;Y no hay ninguna llamada de red: la tabla de 360 estados va embebida en el documento. Se puede abrir sin conexión.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pruébalo
&lt;/h2&gt;

&lt;p&gt;El simulador está en línea y es de una sola página:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Mueve los seis controles y mira qué guarda dispara primero. Si encuentras una combinación donde el resultado te parece injusto, ese es exactamente el punto: el orden se puede discutir, pero ahora está a la vista.&lt;/p&gt;

</description>
      <category>devops</category>
      <category>tooling</category>
      <category>testing</category>
      <category>opensource</category>
    </item>
    <item>
      <title>My falsifier was measuring my laptop</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Sun, 15 Nov 2026 17:38:41 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/my-falsifier-was-measuring-my-laptop-499p</link>
      <guid>https://dev.to/alexisromtz7/my-falsifier-was-measuring-my-laptop-499p</guid>
      <description>&lt;p&gt;I ship small engines twice: once in Python as an oracle, once in JavaScript so a&lt;br&gt;
stranger can play with one in a browser without installing anything. The rule is&lt;br&gt;
that the port must agree with the oracle &lt;em&gt;exactly&lt;/em&gt; — not approximately, not&lt;br&gt;
within tolerance. Zero tolerance.&lt;/p&gt;

&lt;p&gt;That rule needs a falsifier: a frozen fixture generated from the oracle and&lt;br&gt;
committed, plus a script that recomputes everything and diffs it against the&lt;br&gt;
frozen file. On the economic-threshold page that is &lt;strong&gt;250 states and 4,270&lt;br&gt;
compared values&lt;/strong&gt;, including a Monte Carlo bank (&lt;code&gt;n=8000&lt;/code&gt;, &lt;code&gt;seed=20261113&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;It was green on my laptop every time I ran it. The first CI run after deploying&lt;br&gt;
turned it red.&lt;/p&gt;

&lt;p&gt;This post is about three checks that lied to me, and the one habit that caught&lt;br&gt;
them: &lt;strong&gt;measure the difference before naming the cause.&lt;/strong&gt;&lt;/p&gt;


&lt;h2&gt;
  
  
  Defect 1 — the fixture recorded who measured
&lt;/h2&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;RC 5 · el oráculo se movió
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;CI runs Python 3.12.13; my laptop runs 3.9.6. The interesting conclusion is&lt;br&gt;
also the wrong one: &lt;em&gt;the oracle is not deterministic across interpreters.&lt;/em&gt; So I&lt;br&gt;
measured instead of concluding.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Oracle under 3.9.6 → fixture &lt;strong&gt;102,715 bytes&lt;/strong&gt;
&lt;/li&gt;
&lt;li&gt;Oracle under 3.12.13 → fixture &lt;strong&gt;102,717 bytes&lt;/strong&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two bytes. A recursion over the two JSON trees puts both failures in one leaf:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/procedencia/python    "3.9.6"  -&amp;gt;  "3.12.13"
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And the number that settles it: of the 4,270 values the fixture claims to&lt;br&gt;
compare, &lt;strong&gt;4,270 are identical, bit for bit.&lt;/strong&gt; Every boundary state, every&lt;br&gt;
preset, every value on the frontier band. Nothing numeric moved.&lt;/p&gt;

&lt;p&gt;The fixture recorded &lt;em&gt;who measured&lt;/em&gt; inside the bytes it compared:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"estados"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt; &lt;span class="s2"&gt;"... 250 states, 4270 values ..."&lt;/span&gt; &lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"procedencia"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"python"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"3.9.6"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;procedencia.python&lt;/code&gt; is a statement about the observer. The contract is about&lt;br&gt;
the subject — the numbers. By putting the observer inside the compared region, a&lt;br&gt;
&lt;em&gt;correct&lt;/em&gt; oracle failed on a different interpreter.&lt;/p&gt;

&lt;p&gt;This is worth naming precisely, because it is not "a flaky test". The oracle was&lt;br&gt;
right. The page was right. The falsifier was answering the wrong question: it&lt;br&gt;
asked &lt;em&gt;"did the environment change?"&lt;/em&gt; and reported the answer as &lt;em&gt;"did the math&lt;br&gt;
change?"&lt;/em&gt;&lt;/p&gt;
&lt;h3&gt;
  
  
  The fix, and the part that matters more
&lt;/h3&gt;

&lt;p&gt;Split the compared region from the metadata:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="no"&gt;CAMPOS_DEL_OBSERVADOR&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"procedencia/python"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;_sujeto&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;datos&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="s2"&gt;"""Lo que se compara: el sujeto, sin el estado del observador."""&lt;/span&gt;
    &lt;span class="n"&gt;sujeto&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;copy&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;deepcopy&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;datos&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;sujeto&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;pop&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"procedencia"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;None&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;sujeto&lt;/span&gt;

&lt;span class="c1"&gt;# --check compares the subject on both sides&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nf"&gt;serializa&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;_sujeto&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;congelado&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="nf"&gt;serializa&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;_sujeto&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;datos&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="no"&gt;RC_ORACULO_MOVIDO&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The obvious version stops there, and that version has a second defect waiting: a&lt;br&gt;
file that silently excludes a field is indistinguishable from a file that&lt;br&gt;
silently excludes &lt;em&gt;the wrong&lt;/em&gt; field. An unstated exemption is the same class of&lt;br&gt;
error as a lie.&lt;/p&gt;

&lt;p&gt;So &lt;code&gt;--check&lt;/code&gt; prints its exemption on every run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;RC 0 · fixture congelado == oráculo (102715 bytes) · fuera del sujeto: procedencia/python=3.9.6
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;There is no state in which the tool excludes something and does not say so.&lt;/p&gt;

&lt;h3&gt;
  
  
  Pin both halves
&lt;/h3&gt;

&lt;p&gt;A fix tested only in the direction it was written is not tested. The test pins&lt;br&gt;
the exemption &lt;strong&gt;and&lt;/strong&gt; its boundary:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_el_check_ignora_solo_al_observador&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="c1"&gt;# 1) change the interpreter -&amp;gt; still RC 0, and the field is named&lt;/span&gt;
    &lt;span class="c1"&gt;# 2) change the Monte Carlo seed -&amp;gt; RC 5, naming the contract that moved&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Change the observer and the check stays green. Change the subject and it goes&lt;br&gt;
red, with a reason. Without that second assertion, "ignore &lt;code&gt;procedencia&lt;/code&gt;" would&lt;br&gt;
be indistinguishable from "ignore anything inconvenient".&lt;/p&gt;


&lt;h2&gt;
  
  
  Defect 2 — a hang that had already printed its failure
&lt;/h2&gt;

&lt;p&gt;The suite also drives the real page through a headless runtime and mutates it,&lt;br&gt;
asserting that each mutation is caught. On macOS 26.5.2 / node 24.15.0, about 2%&lt;br&gt;
of those runs never returned:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;sample &amp;lt;pid&amp;gt;
  Builtins_JSEntryTrampoline
  node::Environment::Exit
  NodePlatform::Shutdown
  WorkerThreadsTaskRunner::Shutdown()      &amp;lt;- stuck here, after printing the failure
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The failure had already been printed. The process just would not die. Measured:&lt;br&gt;
&lt;strong&gt;3 hangs in 150&lt;/strong&gt; runs of a mutated page, &lt;strong&gt;0 in 200&lt;/strong&gt; of the pristine one, &lt;strong&gt;0&lt;br&gt;
in 200&lt;/strong&gt; of &lt;code&gt;node -e 'process.exit(1)'&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The mitigation is one retry with a &lt;code&gt;UserWarning&lt;/code&gt; — plus the check that keeps it&lt;br&gt;
honest: &lt;strong&gt;two consecutive timeouts still fail.&lt;/strong&gt; A retry that also swallows a&lt;br&gt;
real hang is not a mitigation, it is a mute button.&lt;/p&gt;

&lt;p&gt;The claim is not "it never hangs". The claim is "a hang costs one retry, not a&lt;br&gt;
red build" — and since it has already fired once on a real run, the docs say&lt;br&gt;
exactly that.&lt;/p&gt;


&lt;h2&gt;
  
  
  The rule I added afterwards — and the false green inside it
&lt;/h2&gt;

&lt;p&gt;Publishing four demos made the next gap obvious. Three of the four pages proved&lt;br&gt;
their thesis and &lt;strong&gt;never said what they do not prove&lt;/strong&gt;. For a project whose&lt;br&gt;
whole argument is "publish the negative result as a result", that is a&lt;br&gt;
credibility gap, not a rendering gap.&lt;/p&gt;

&lt;p&gt;So the house rule became: no page ships without a block declaring its limits, in&lt;br&gt;
both languages. Each page now carries two, and they are not decorative. This one&lt;br&gt;
is from the field classifier:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;code&gt;reader drift&lt;/code&gt; compares two readers of this same code. If both share the same&lt;br&gt;
wrong definition of the invariant, the drift is zero and the error stays&lt;br&gt;
invisible: zero drift proves the two paths agree, not that the class is right.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;And the rule is enforced, not requested:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;$ python3 tools/verificar_limites.py
demo/clasificador-de-campos            limites=2  OK
demo/nulo-con-dientes                  limites=2  OK
demo/piso-de-deteccion                 limites=2  OK
demo/umbral-economico                  limites=2  OK
README.md                              cita la regla
README.es.md                           cita la regla
RC 0 · 4 páginas declaran lo que no prueban, en todos sus idiomas
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Delete a limit while still declaring &lt;code&gt;data-limites="2"&lt;/code&gt; and it fails closed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;  ✗ demo/piso-de-deteccion: declara 2 límites y publica 1
  ✗ demo/piso-de-deteccion: publica 1 límite(s) y el mínimo es 2: un límite único no distingue el alcance de la excusa
RC 1 · 2 fallo(s): una página que no declara su límite no es un instrumento
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Then I tried to write this paragraph, and the paragraph was false
&lt;/h3&gt;

&lt;p&gt;I was about to publish "the limits contract fails closed", which is a claim, not&lt;br&gt;
an observation. So I ran the mutation that the sentence depends on:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight html"&gt;&lt;code&gt;&lt;span class="c"&gt;&amp;lt;!-- &amp;lt;li data-t="lim1"&amp;gt;The floats are not bit-exact and this page does not
     claim they are: x**2 in CPython routes to the system libm …&amp;lt;/li&amp;gt; --&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;$ python3 tools/verificar_limites.py
...
RC 0 · 4 páginas declaran lo que no prueban, en todos sus idiomas
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;RC 0.&lt;/strong&gt; A limit wrapped in an HTML comment — present in the file, invisible to&lt;br&gt;
every reader — counted as published. The verifier extracted &lt;code&gt;&amp;lt;li&amp;gt;&lt;/code&gt; elements from&lt;br&gt;
the raw body, and the comment markers sat &lt;em&gt;outside&lt;/em&gt; the &lt;code&gt;&amp;lt;li&amp;gt;&lt;/code&gt;, so the element&lt;br&gt;
was still there and its text was still substantive. Commenting the whole&lt;br&gt;
&lt;code&gt;&amp;lt;section id="limites"&amp;gt;&lt;/code&gt; did not register either.&lt;/p&gt;

&lt;p&gt;The cause is embarrassingly simple, and it is the same cause as defect 1: the&lt;br&gt;
check was reading the observer's view of the document (what a &lt;code&gt;findall&lt;/code&gt; sees)&lt;br&gt;
instead of the reader's view (what a person sees). Stripping &lt;code&gt;&amp;lt;!-- … --&amp;gt;&lt;/code&gt; from&lt;br&gt;
the whole document &lt;em&gt;before&lt;/em&gt; counting anything closed all three shapes.&lt;/p&gt;

&lt;p&gt;The other half of the defect is in the test bank: it covered commenting the text&lt;br&gt;
&lt;em&gt;inside&lt;/em&gt; a &lt;code&gt;&amp;lt;li&amp;gt;&lt;/code&gt; — the half of the problem that was easy to imagine. The half&lt;br&gt;
that mattered was the one outside the quote marks.&lt;/p&gt;

&lt;p&gt;Two new mutations, and I checked that each one is a real falsifier by reverting&lt;br&gt;
the fix in a throwaway copy:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;FAILED tests/test_limites.py::MutacionesTests::test_la_seccion_entera_comentada_no_cuenta
FAILED tests/test_limites.py::MutacionesTests::test_un_limite_entero_comentado_no_cuenta
2 failed, 15 passed
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Green with the fix, red without it. Without that second run, "the test passes"&lt;br&gt;
would have meant nothing more than "the test agrees with the code I just wrote".&lt;/p&gt;




&lt;h2&gt;
  
  
  What generalises
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;A fixture that fails on a correct implementation teaches people to ignore
fixtures.&lt;/strong&gt; The cost of a false red is not the red — it is the credibility you
spend next time.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Separate the observer from the subject, and print what you excluded.&lt;/strong&gt;
Compiler versions, OS, machine, timestamp, user: all of them describe who
measured, not what was measured. HTML comments, rendering, and scroll
position are observers too.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;If you cannot make a check fail on purpose, it is not a check.&lt;/strong&gt; Every
verifier here is paired with a mutation that must produce a non-zero exit —
and the mutation is re-run with the fix removed, because a mutation that
passes in both directions is measuring nothing.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A test bank covers exactly the failures its author imagined.&lt;/strong&gt; The gap is
never in the case you wrote; it is in the neighbouring one. Enumerate the
shapes the defect can take — text inside the tag, tag inside the comment,
comment around the section — not just the one in front of you.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Measure the difference before naming the cause.&lt;/strong&gt; "Not deterministic across
interpreters" was one command away from being refuted. If I had written it in
the commit message first, it would have become the story.&lt;/li&gt;
&lt;/ol&gt;




&lt;h2&gt;
  
  
  Go try to break them
&lt;/h2&gt;

&lt;p&gt;Four engines. Each page ships its frozen fixture — every state, every compared&lt;br&gt;
value — plus a script that recomputes the browser engine and diffs it against&lt;br&gt;
that file. The check runs in the public repo, against a fixture generated from&lt;br&gt;
the Python oracle. The oracle itself lives in a private repository for three of&lt;br&gt;
the four, and those fixtures say &lt;code&gt;fuente_publica: false&lt;/code&gt; with a reproducible&lt;br&gt;
local command rather than a link that would 404:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://alexisromtz-lab.github.io/auditor-toolkit/demo/clasificador-de-campos/" rel="noopener noreferrer"&gt;Classifier of electromagnetic fields&lt;/a&gt;&lt;/strong&gt; —
six components of an antisymmetric tensor, classified into the algebraic types
of Cl(1,3), with the invariants that do not move under a frame change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://alexisromtz-lab.github.io/auditor-toolkit/demo/nulo-con-dientes/" rel="noopener noreferrer"&gt;Does your null have teeth?&lt;/a&gt;&lt;/strong&gt; —
a permutation test is a null only for the invariant it destroys: which
invariant dies, and which one survives, under each of five resamplers.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://alexisromtz-lab.github.io/auditor-toolkit/demo/piso-de-deteccion/" rel="noopener noreferrer"&gt;The detection floor&lt;/a&gt;&lt;/strong&gt; —
a gate that judges a field with a constant ε is not choosing a precision, it
is choosing between two blindnesses; the operator's truncation floor depends
on the node and is measured without ground truth.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://alexisromtz-lab.github.io/auditor-toolkit/demo/umbral-economico/" rel="noopener noreferrer"&gt;The threshold&lt;/a&gt;&lt;/strong&gt; —
&lt;code&gt;p_min = C/V&lt;/code&gt; and expected value for repeated attempts, with the Monte Carlo
bank behind the closed form.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Hub: &lt;a href="https://alexisromtz-lab.github.io/auditor-toolkit/" rel="noopener noreferrer"&gt;alexisromtz-lab.github.io/auditor-toolkit&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Each page also tells you, in English and Spanish, what it does &lt;em&gt;not&lt;/em&gt; prove — and&lt;br&gt;
a script fails the build if that block ever disappears. If you find a state where&lt;br&gt;
the browser and the oracle disagree, that is the bug report I want.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;A note on method:&lt;/strong&gt; the return codes I use here are indexed with their declared cause and the fingerprint that seals them at &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — and the gate that emits them can be driven by hand, with no network calls, at &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>testing</category>
      <category>python</category>
      <category>javascript</category>
      <category>ci</category>
    </item>
    <item>
      <title>El parche obvio del JWT no cierra la forja: 2 forjas aceptadas, luego 1, nunca 0</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Sat, 14 Nov 2026 23:21:19 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/el-parche-obvio-del-jwt-no-cierra-la-forja-2-1-0-medido-2h8k</link>
      <guid>https://dev.to/alexisromtz7/el-parche-obvio-del-jwt-no-cierra-la-forja-2-1-0-medido-2h8k</guid>
      <description>&lt;p&gt;La confusión de algoritmo en JWT tiene fama de problema resuelto. Está en todas las&lt;br&gt;
listas: &lt;code&gt;alg: none&lt;/code&gt;, &lt;code&gt;RS256 → HS256&lt;/code&gt;, «valida el algoritmo». Y como está resuelto en la&lt;br&gt;
literatura, se resuelve mal en el código: se añade un &lt;code&gt;if&lt;/code&gt; que rechaza &lt;code&gt;none&lt;/code&gt;, se da el&lt;br&gt;
caso por cerrado y el tablero se pone verde.&lt;/p&gt;

&lt;p&gt;Escribí tres verificadores del mismo servicio y medí qué pasa con el mismo ataque contra&lt;br&gt;
cada uno. No con opinión: con código de salida.&lt;/p&gt;
&lt;h2&gt;
  
  
  El servicio
&lt;/h2&gt;

&lt;p&gt;Un validador de tokens que firma con RSA y publica su clave pública —como cualquier&lt;br&gt;
despliegue que expone un JWKS—. El token declara &lt;code&gt;sub&lt;/code&gt;, &lt;code&gt;role&lt;/code&gt; y &lt;code&gt;exp&lt;/code&gt;. El ataque forja&lt;br&gt;
&lt;code&gt;{"sub": "alice", "role": "admin"}&lt;/code&gt;: escalada sobre la cuenta de otra persona, sin&lt;br&gt;
credenciales y sin acceso a la red interna.&lt;/p&gt;
&lt;h2&gt;
  
  
  Tres corridas, un comando
&lt;/h2&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;python3 exploit_poc.py                                  &lt;span class="c"&gt;# servicio vulnerable&lt;/span&gt;
python3 exploit_poc.py --app patch_secure.py --naive    &lt;span class="c"&gt;# el parche obvio&lt;/span&gt;
python3 exploit_poc.py --app patch_secure.py            &lt;span class="c"&gt;# el parche canónico&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;sujeto&lt;/th&gt;
&lt;th&gt;forjas aceptadas&lt;/th&gt;
&lt;th&gt;código de salida&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;servicio vulnerable&lt;/td&gt;
&lt;td&gt;2 de 2&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;parche obvio (&lt;code&gt;alg=none&lt;/code&gt; cerrado)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;1 de 2&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;parche canónico&lt;/td&gt;
&lt;td&gt;0 de 2&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;El número del medio es el que importa. La condición obvia —rechazar los tokens sin&lt;br&gt;
firma— se cumple y el ataque sigue entrando, porque el ataque interesante no era ése.&lt;/p&gt;
&lt;h2&gt;
  
  
  Por qué el parche obvio no basta
&lt;/h2&gt;

&lt;p&gt;Son dos decisiones independientes, inocentes cada una por separado:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;El algoritmo lo elige el token.&lt;/strong&gt; La cabecera no está firmada antes de decidir con
qué verificarla; es el huevo y la gallina. Un verificador no puede preguntarle al
atacante cómo quiere que lo verifiquen.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Un solo material de clave para dos mundos.&lt;/strong&gt; RSA necesita una clave pública; HMAC
necesita un secreto compartido. Si el código carga «la clave» una vez y la pasa a las
dos ramas, la rama HMAC termina usando algo que todo el mundo conoce.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Cerrar &lt;code&gt;alg=none&lt;/code&gt; toca el primero, y solo para el caso trivial. El material compartido&lt;br&gt;
sigue ahí, la rama HMAC sigue ahí, y el atacante solo tiene que declarar &lt;code&gt;HS256&lt;/code&gt; y firmar&lt;br&gt;
con la clave pública que el servicio publica.&lt;/p&gt;
&lt;h2&gt;
  
  
  El parche que sí
&lt;/h2&gt;

&lt;p&gt;El algoritmo deja de venir del token:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="no"&gt;ALGORITMOS_PERMITIDOS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;frozenset&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"RS256"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;alg&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;cabecera&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"alg"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;alg&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="no"&gt;ALGORITMOS_PERMITIDOS&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;InvalidToken&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"algoritmo fuera de la lista blanca: {alg!r}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;No es una lista negra más larga: es la &lt;strong&gt;desaparición de la rama&lt;/strong&gt;. Sin rama HMAC, la&lt;br&gt;
clave pública no puede convertirse en secreto de nadie. La lista blanca no añade una&lt;br&gt;
comprobación; elimina un camino.&lt;/p&gt;
&lt;h2&gt;
  
  
  El control que hace honesta la medición
&lt;/h2&gt;

&lt;p&gt;Las tres corridas empiezan verificando que el token legítimo entra en el servicio. Y en&lt;br&gt;
las tres entra. Eso es lo que separa «bloqueé el ataque» de «rompí todo»: un parche que&lt;br&gt;
deja el servicio inservible también rechaza el PoC, y devuelve el mismo código de salida.&lt;br&gt;
Un test que solo comprueba que el login funciona no distingue una cosa de la otra.&lt;/p&gt;
&lt;h2&gt;
  
  
  Reproducirlo
&lt;/h2&gt;

&lt;p&gt;Cinco segundos, sin dependencias, sin red, sin estado entre corridas:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone --depth 1 https://github.com/alexisromtz-lab/offensive-reproducers
&lt;span class="nb"&gt;cd&lt;/span&gt; offensive-reproducers/001-jwt-algorithm-confusion
python3 exploit_poc.py --app patch_secure.py --naive   &lt;span class="c"&gt;# RC 0 · sigue entrando&lt;/span&gt;
python3 exploit_poc.py --app patch_secure.py           &lt;span class="c"&gt;# RC 1 · bloqueado&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Cada cápsula del repositorio sigue el mismo molde de tres veredictos —vulnerable, parche&lt;br&gt;
obvio, parche canónico— con el código de salida como veredicto, para que la diferencia se&lt;br&gt;
pueda medir en vez de creer.&lt;/p&gt;

&lt;h2&gt;
  
  
  Si auditas esto mañana
&lt;/h2&gt;

&lt;p&gt;Cuando alguien diga «validamos el algoritmo», las tres preguntas son: ¿la lista es&lt;br&gt;
blanca o negra?, ¿existe todavía la rama del otro algoritmo?, ¿el material de clave es&lt;br&gt;
distinto en cada rama? Con una respuesta negativa, el &lt;code&gt;alg=none&lt;/code&gt; cerrado no significa&lt;br&gt;
nada.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — y la compuerta que los emite se mueve a mano, sin llamadas de red, en &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>python</category>
      <category>jwt</category>
      <category>webdev</category>
    </item>
    <item>
      <title>El job que audita tus dependencias tenía permiso de escritura</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Fri, 13 Nov 2026 18:10:21 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/el-job-que-audita-tus-dependencias-tenia-permiso-de-escritura-15p8</link>
      <guid>https://dev.to/alexisromtz7/el-job-que-audita-tus-dependencias-tenia-permiso-de-escritura-15p8</guid>
      <description>&lt;h2&gt;
  
  
  El número
&lt;/h2&gt;

&lt;p&gt;49 hallazgos sobre 36 workflows leídos, en una sola pasada estática. De esos 36 workflows, 26&lt;br&gt;
tienen al menos un hallazgo: 1 crítico, 23 de severidad alta y 25 de severidad baja.&lt;/p&gt;

&lt;p&gt;La cifra no viene de una corazonada ni de una captura de pantalla. Esa misma medición se corrió&lt;br&gt;
antes sobre el commit &lt;code&gt;eaa56e88&lt;/code&gt; y volvió a correrse el 13 de noviembre sobre &lt;code&gt;7f1785ea&lt;/code&gt;: los dos&lt;br&gt;
sujetos dieron 49 hallazgos, 24 fallos y 25 revisiones. Cuando un instrumento repite el número&lt;br&gt;
sobre dos árboles distintos, el número deja de ser una opinión sobre ese commit y pasa a ser una&lt;br&gt;
propiedad de esa configuración.&lt;/p&gt;

&lt;h2&gt;
  
  
  El caso que no es higiene
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;.github/workflows/npm-audit-claude-remediation.yml&lt;/code&gt;, job &lt;code&gt;remediate&lt;/code&gt;. El job declara escritura en&lt;br&gt;
&lt;code&gt;contents&lt;/code&gt; y en &lt;code&gt;pull-requests&lt;/code&gt;, y su cuerpo ejecuta &lt;code&gt;curl&lt;/code&gt; contra un extremo remoto. Su entrada es&lt;br&gt;
el texto de los avisos del registro de npm.&lt;/p&gt;

&lt;p&gt;Ese es el punto. Un aviso de npm es un documento que cualquier tercero puede publicar en el&lt;br&gt;
registro; no es código del repositorio ni texto que el mantenedor controle. Ese texto entra a un job&lt;br&gt;
que puede escribir sobre el árbol y abrir pull requests. La política del repositorio dice que el job&lt;br&gt;
audita dependencias; lo que el workflow permite es que un documento ajeno produzca una escritura con&lt;br&gt;
la identidad del repositorio.&lt;/p&gt;

&lt;p&gt;El mismo workflow aparece en el código &lt;code&gt;GATE_RC_2_SUMIDERO_IMPUDO&lt;/code&gt; por usar &lt;code&gt;actions/checkout&lt;/code&gt; como&lt;br&gt;
sumidero, y en &lt;code&gt;GATE_RC_1_AUTORIDAD_CONTAMINADA&lt;/code&gt; por la ejecución remota. Son dos invariantes&lt;br&gt;
distintos midiendo la misma línea de código desde dos ángulos: el sumidero que recibe contenido ajeno&lt;br&gt;
y la autoridad que ese sumidero hereda.&lt;/p&gt;

&lt;p&gt;El remedio no es un &lt;code&gt;if&lt;/code&gt;. Es partir el job en dos: uno lee el aviso y no tiene autoridad, otro recibe&lt;br&gt;
un dato ya validado y escribe.&lt;/p&gt;

&lt;h2&gt;
  
  
  El secreto en la línea de comando
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;.github/workflows/publish-php-sdk.yml&lt;/code&gt;, job &lt;code&gt;publish&lt;/code&gt;. Un &lt;code&gt;secrets&lt;/code&gt; se interpola directamente en un&lt;br&gt;
&lt;code&gt;run:&lt;/code&gt; que hace &lt;code&gt;curl&lt;/code&gt; a packagist. La interpolación ocurre antes de que el shell corra, así que el&lt;br&gt;
valor queda dentro del comando: en el &lt;code&gt;argv&lt;/code&gt; del proceso, en el log si el shell ecoa la línea, y en&lt;br&gt;
cualquier mensaje de error que la imprima.&lt;/p&gt;

&lt;p&gt;Es el único hallazgo crítico de los 49, y el único que no admite discusión sobre severidad: la&lt;br&gt;
credencial no se está pasando, se está escribiendo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Once jobs con autoridad sobre código que no controlan
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;GATE_RC_1_AUTORIDAD_CONTAMINADA&lt;/code&gt; aparece once veces. Los sujetos son &lt;code&gt;deploy-image.yml&lt;/code&gt;,&lt;br&gt;
&lt;code&gt;deploy-image-staging.yml&lt;/code&gt;, &lt;code&gt;deploy-nuq-postgres.yml&lt;/code&gt;, &lt;code&gt;deploy-playwright.yml&lt;/code&gt;, &lt;code&gt;deploy-redis.yml&lt;/code&gt; y&lt;br&gt;
&lt;code&gt;publish-go-sdk.yml&lt;/code&gt;, entre otros, ejecutando &lt;code&gt;docker pull&lt;/code&gt;, &lt;code&gt;docker manifest create&lt;/code&gt;,&lt;br&gt;
&lt;code&gt;git fetch --force --tags&lt;/code&gt; o &lt;code&gt;go build&lt;/code&gt; en jobs con &lt;code&gt;scopes=packages&lt;/code&gt; o &lt;code&gt;scopes=contents&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Ninguno de esos comandos es exótico. Lo que está fuera de lugar es la combinación: un job que puede&lt;br&gt;
publicar paquetes ejecutando binarios que descarga en el momento. La autoridad no se justifica por lo&lt;br&gt;
que el job hace, sino por lo que puede llegar a ejecutar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Siete workflows donde la autoridad no se lee del archivo
&lt;/h2&gt;

&lt;p&gt;Siete workflows no declaran &lt;code&gt;permissions&lt;/code&gt; en la raíz: &lt;code&gt;eval-prod.yml&lt;/code&gt;, &lt;code&gt;npm-audit.yml&lt;/code&gt;,&lt;br&gt;
&lt;code&gt;test-dotnet-sdk.yml&lt;/code&gt;, &lt;code&gt;test-go-html-to-md-service.yml&lt;/code&gt;, &lt;code&gt;test-php-sdk.yml&lt;/code&gt;, &lt;code&gt;test-ruby-sdk.yml&lt;/code&gt; y&lt;br&gt;
&lt;code&gt;test-server.yml&lt;/code&gt;. Heredan el default del repositorio o de la organización, que no vive en el archivo.&lt;/p&gt;

&lt;p&gt;Esto es lo que hace el hallazgo distinto de un lint. Un revisor que lee el workflow ve una cosa; el&lt;br&gt;
runtime puede estar aplicando otra. La configuración no es incompleta: es ilegible desde donde se&lt;br&gt;
revisa.&lt;/p&gt;

&lt;h2&gt;
  
  
  Punto ciego — lo que esta pieza no afirma
&lt;/h2&gt;

&lt;p&gt;No afirma que algo de esto se haya explotado. Lo que se midió es la configuración estática de 36&lt;br&gt;
workflows en un commit concreto; no se ejecutó ningún workflow ni se leyeron los permisos por&lt;br&gt;
defecto de la organización, que no son legibles sin privilegios de administración.&lt;/p&gt;

&lt;p&gt;No afirma que los 25 hallazgos de severidad baja sean fallos. Se llaman revisiones porque el&lt;br&gt;
instrumento no puede decidir por sí solo si el alcance de escritura está justificado; eso lo decide&lt;br&gt;
quien conoce la intención del job.&lt;/p&gt;

&lt;p&gt;No afirma que los secretos interpolados aparezcan realmente en los logs. No se consultó ningún log&lt;br&gt;
de ejecución de ese workflow.&lt;/p&gt;

&lt;p&gt;No afirma nada sobre exploits, sobre terceros ni sobre intención. Una configuración que permite un&lt;br&gt;
efecto no es la prueba de que el efecto haya ocurrido.&lt;/p&gt;

&lt;h2&gt;
  
  
  CTA único
&lt;/h2&gt;

&lt;p&gt;Si mantienes un repositorio con workflows de GitHub Actions, corre &lt;code&gt;.venv/bin/python&lt;br&gt;
tools/auditar_supply_chain.py --repo &amp;lt;owner&amp;gt;/&amp;lt;name&amp;gt;&lt;/code&gt; sobre el tuyo y mira cuántos jobs tienen&lt;br&gt;
escritura y ejecutan código que no controlas. El instrumento es de solo lectura y no necesita clonar.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — y la compuerta que los emite se mueve a mano, sin llamadas de red, en &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>githubactions</category>
      <category>ai</category>
      <category>devops</category>
    </item>
    <item>
      <title>El instrumento que se acusó a sí mismo: 28 hallazgos, 1 CRÍTICO y un mecanismo que no lo sostiene</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Fri, 13 Nov 2026 05:51:07 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/el-instrumento-que-se-acuso-a-si-mismo-28-hallazgos-1-critico-y-un-mecanismo-que-no-lo-sostiene-5fcf</link>
      <guid>https://dev.to/alexisromtz7/el-instrumento-que-se-acuso-a-si-mismo-28-hallazgos-1-critico-y-un-mecanismo-que-no-lo-sostiene-5fcf</guid>
      <description>&lt;p&gt;Un clasificador automático marcó un hallazgo &lt;strong&gt;CRÍTICO&lt;/strong&gt; en &lt;code&gt;google/gvisor&lt;/code&gt;. Después de leer el mecanismo que lo sostiene, el hallazgo se degradó a sí mismo.&lt;/p&gt;

&lt;p&gt;Esta es la auditoría donde el instrumento tuvo que acusarse a sí mismo, y el resultado es más útil que el hallazgo original.&lt;/p&gt;

&lt;h2&gt;
  
  
  El sujeto y su referencia
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;google/gvisor&lt;/code&gt; @ &lt;code&gt;2f5253abfaa87b6d62d79a0da60942e773389934&lt;/code&gt; — 15 archivos &lt;code&gt;.github/workflows/*.yml&lt;/code&gt;, leídos &lt;strong&gt;como texto&lt;/strong&gt;, sin clonar y sin parser YAML.&lt;/p&gt;

&lt;p&gt;Un conteo sin su &lt;code&gt;ref&lt;/code&gt; es otro objeto. El registro de la corrida anterior, contra &lt;code&gt;6ff6a1f498df&lt;/code&gt;, devolvió &lt;strong&gt;31&lt;/strong&gt; hallazgos. Esos dos &lt;code&gt;ref&lt;/code&gt; están a 8 commits de distancia (&lt;code&gt;ahead=0, behind=8&lt;/code&gt;), y en el camino los hallazgos pasaron de 31 a 28. Se publica el del informe y se declara el del registro; no se elige el número que suena mejor.&lt;/p&gt;

&lt;h2&gt;
  
  
  El hallazgo, y por qué no se sostiene
&lt;/h2&gt;

&lt;p&gt;En &lt;code&gt;.github/workflows/go.yml&lt;/code&gt; (job &lt;code&gt;generate&lt;/code&gt;), &lt;strong&gt;4 de las 5&lt;/strong&gt; apariciones de &lt;code&gt;${{ secrets.* }}&lt;/code&gt; caen dentro de bloques &lt;code&gt;run:&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;GitHub expande esas expresiones en el &lt;strong&gt;texto del script&lt;/strong&gt; antes de que el shell lo lea. Así que el valor del secreto se parsea como sintaxis. Medido, con un valor sintético:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;un valor con una comilla doble rompe el &lt;code&gt;[[ ]]&lt;/code&gt; → &lt;code&gt;bash&lt;/code&gt; rc 2, el paso muere;&lt;/li&gt;
&lt;li&gt;un valor con &lt;code&gt;$(...)&lt;/code&gt; se ejecuta → rc 0.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Lo que hace que esto &lt;strong&gt;no&lt;/strong&gt; sea una exposición crítica no es una opinión, es una propiedad del disparador: &lt;strong&gt;el que dispara es el valor del secreto, no una entrada del atacante.&lt;/strong&gt; Ninguna entrada controlable por quien abre un pull request llega a esa expansión, y GitHub enmascara el valor en el log. El fallo se convierte en caída o en ejecución local — no en fuga hacia un tercero.&lt;/p&gt;

&lt;p&gt;Por eso la severidad efectiva es &lt;strong&gt;higiene latente&lt;/strong&gt;, no exposición crítica. El remedio es de una línea y también está medido: pasar el secreto por &lt;code&gt;env:&lt;/code&gt;, donde el mismo valor con comilla queda inerte.&lt;/p&gt;

&lt;p&gt;El clasificador no se equivocó al mirar. Se equivocó al concluir sin mirar el disparador. Y el instrumento que publica el veredicto tiene que ser capaz de decir eso de sí mismo.&lt;/p&gt;

&lt;h2&gt;
  
  
  El conteo independiente
&lt;/h2&gt;

&lt;p&gt;Reproducido con &lt;code&gt;curl&lt;/code&gt;, sin clonar, sin token y sin dependencias:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;15&lt;/strong&gt; workflows leídos.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;12&lt;/strong&gt; sin &lt;code&gt;permissions:&lt;/code&gt; raíz.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;1&lt;/strong&gt; workflow con secreto dentro de &lt;code&gt;run:&lt;/code&gt; — &lt;strong&gt;4&lt;/strong&gt; ocurrencias; &lt;strong&gt;7&lt;/strong&gt; quedan fuera de &lt;code&gt;run:&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;23/23&lt;/strong&gt; &lt;code&gt;uses:&lt;/code&gt; fijados (ninguno flotante).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;0&lt;/strong&gt; &lt;code&gt;continue-on-error&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Los 12 sin &lt;code&gt;permissions:&lt;/code&gt; raíz se publican como &lt;strong&gt;indeterminados, no como expuestos&lt;/strong&gt;: quien decide si heredan &lt;code&gt;read&lt;/code&gt; o &lt;code&gt;write&lt;/code&gt; es el permiso por defecto de la organización, y este instrumento no lo lee.&lt;/p&gt;

&lt;h2&gt;
  
  
  El límite, dentro del artefacto
&lt;/h2&gt;

&lt;p&gt;El instrumento juzga el YAML como texto y &lt;strong&gt;no publica número de línea&lt;/strong&gt;. No observó runtime ni leyó el historial de Actions, así que no afirma que ningún flujo concreto se haya disparado. Fuera de alcance declarado: workflows reutilizables (&lt;code&gt;workflow_call&lt;/code&gt;), acciones compuestas alojadas en repositorios ajenos, y el interior de los scripts del árbol.&lt;/p&gt;

&lt;p&gt;El conteo se reproduce con un script; &lt;strong&gt;la severidad no&lt;/strong&gt;, porque es un juicio. Por eso se publica con su mecanismo al lado en vez de sola.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reproducirlo
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;python3 reproduce.py            &lt;span class="c"&gt;# RC 0 — 6 de 6 afirmaciones reproducen, sin red&lt;/span&gt;
python3 reproduce.py --control  &lt;span class="c"&gt;# control negativo: las dos cifras tienen que moverse&lt;/span&gt;
python3 reproduce.py --remoto   &lt;span class="c"&gt;# testigo: compara objeto/ con el commit fijado&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;La copia fijada en &lt;code&gt;objeto/&lt;/code&gt; (15 archivos, byte a byte, Apache-2.0) es el sujeto del veredicto. &lt;code&gt;--remoto&lt;/code&gt; sólo la testifica y &lt;strong&gt;no&lt;/strong&gt; la sustituye: un testigo divergente no cambia el resultado.&lt;/p&gt;

&lt;p&gt;El caso completo, con la ficha, el contador y el control negativo: &lt;a href="https://alexisromtz-lab.github.io/la-auditora/portafolio/auditoria-003-gvisor/" rel="noopener noreferrer"&gt;https://alexisromtz-lab.github.io/la-auditora/portafolio/auditoria-003-gvisor/&lt;/a&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Regla de esta serie: un hallazgo que no demuele nada suyo no se publica. Este publica su propia degradación.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — y la compuerta que los emite se mueve a mano, sin llamadas de red, en &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>githubactions</category>
      <category>security</category>
      <category>devops</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Barrí 50 repositorios: dos defectos reales y una tasa del 2 %</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Fri, 13 Nov 2026 02:40:25 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/barri-50-repositorios-dos-defectos-reales-y-una-tasa-del-2--30fk</link>
      <guid>https://dev.to/alexisromtz7/barri-50-repositorios-dos-defectos-reales-y-una-tasa-del-2--30fk</guid>
      <description>&lt;h2&gt;
  
  
  0 · Veredicto en una línea
&lt;/h2&gt;

&lt;p&gt;De &lt;strong&gt;50&lt;/strong&gt; repositorios de empresa con CI (≥ 5 000 ★, IA/DevTools/Fintech), &lt;strong&gt;1&lt;/strong&gt; tiene hoy un defecto de&lt;br&gt;
señal de CI que yo firmaría con mi nombre en su repo; los otros dos blancos tienen defecto real pero&lt;br&gt;
condición distinta, y aquí se dice cuál es cuál en vez de vender los tres igual.&lt;/p&gt;
&lt;h2&gt;
  
  
  1 · La medición — el denominador, antes de la conclusión
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;qué se midió&lt;/th&gt;
&lt;th&gt;magnitud&lt;/th&gt;
&lt;th&gt;cómo se obtuvo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;cohorte&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;50&lt;/strong&gt; repos&lt;/td&gt;
&lt;td&gt;273 candidatos de 12 búsquedas &lt;code&gt;gh search repos&lt;/code&gt; → filtro de listas &lt;code&gt;awesome&lt;/code&gt;/cursos/clones y &amp;gt; 900 MB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;archivos de workflow leídos&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;765&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;descarga de &lt;code&gt;.github/workflows/*&lt;/code&gt; por API, parseo con PyYAML&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;pasos que invocan un runner de tests&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;262&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;regex de runners (&lt;code&gt;pytest&lt;/code&gt;, &lt;code&gt;ctest&lt;/code&gt;, &lt;code&gt;go test&lt;/code&gt;, &lt;code&gt;npm test&lt;/code&gt;, &lt;code&gt;tox&lt;/code&gt;, &lt;code&gt;make test&lt;/code&gt;, &lt;code&gt;dotnet test&lt;/code&gt;, &lt;code&gt;bazel test&lt;/code&gt;, …)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;pasos cuya caída &lt;strong&gt;no puede propagarse&lt;/strong&gt; al resultado del workflow&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;11 · 4,2 %&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;continue-on-error&lt;/code&gt; (paso o job) o || true / || exit 0, &lt;strong&gt;sin&lt;/strong&gt; postcondición local &lt;strong&gt;y&lt;/strong&gt; sin consumidor &lt;code&gt;needs:&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;repos distintos con al menos uno&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;5 · 10 %&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;livekit/agents&lt;/code&gt;, &lt;code&gt;ggml-org/llama.cpp&lt;/code&gt;, &lt;code&gt;PrefectHQ/prefect&lt;/code&gt;, &lt;code&gt;raga-ai-hub/RagaAI-Catalyst&lt;/code&gt;, &lt;code&gt;Arize-ai/phoenix&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;de esos 5, con declaración explícita de intención&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;3&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Prefect se llama &lt;code&gt;(advisory)&lt;/code&gt; y lo comenta (&lt;code&gt;api-compatibility-tests.yaml:19-21&lt;/code&gt;); llama.cpp deja el gate real en &lt;code&gt;e2e-tests&lt;/code&gt;; Arize es un workflow de bot (&lt;code&gt;claude-daily-deps-upgrade.yml&lt;/code&gt;)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;de los 2 restantes, repo &lt;strong&gt;vivo&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;1&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;livekit/agents&lt;/code&gt; publica commits hoy (&lt;code&gt;2026-11-06&lt;/code&gt;); &lt;code&gt;RagaAI-Catalyst&lt;/code&gt; no tiene commit desde &lt;code&gt;2025-05-16&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;⇒ Tasa de blancos defendibles: 1/50 = 2 %.&lt;/strong&gt; Para tres blancos vivos haría falta barrer ~150 repos.&lt;/p&gt;
&lt;h3&gt;
  
  
  1.1 · Auto-auditoría del instrumento (tres correcciones medidas en este turno)
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;El primer clasificador era ciego a los gates por &lt;code&gt;needs:&lt;/code&gt;.&lt;/strong&gt; La v1 sólo miraba pasos posteriores
&lt;em&gt;dentro del mismo job&lt;/em&gt;. La v2 añadió consumidores &lt;code&gt;needs:&lt;/code&gt; y guardas &lt;code&gt;needs.X.result&lt;/code&gt; → mismo
resultado (10 vs 10). El número sobrevivió, pero el argumento no estaba probado hasta que se probó.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;La regex de runners era corta.&lt;/strong&gt; No veía &lt;code&gt;make test&lt;/code&gt;, &lt;code&gt;dotnet test&lt;/code&gt;, &lt;code&gt;bazel test&lt;/code&gt;, &lt;code&gt;phpunit&lt;/code&gt;, &lt;code&gt;rspec&lt;/code&gt;.
Ampliada: 262 pasos, &lt;strong&gt;+1 repo&lt;/strong&gt; (&lt;code&gt;Arize-ai/phoenix&lt;/code&gt;, workflow de bot). La tasa se movió de 4/50 a 5/50
y la de blancos defendibles &lt;strong&gt;no&lt;/strong&gt; se movió.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;El ranking de «dolor de CI» del rastreo estaba contaminado y se descarta.&lt;/strong&gt; Contaba corridas de ramas
de fork y &lt;code&gt;action_required&lt;/code&gt; (workflow que nunca llegó a ejecutarse) como fallos. Medido en
&lt;code&gt;openai/evals&lt;/code&gt;: &lt;strong&gt;11 de 15&lt;/strong&gt; corridas recientes son &lt;code&gt;action_required&lt;/code&gt; — de ahí el &lt;code&gt;0.99&lt;/code&gt; de la primera
pasada. Un repo con CI sana puede producir esa cifra. &lt;strong&gt;El ranking se retira&lt;/strong&gt;; no se usa en ninguna
decisión de este documento.&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;
  
  
  2 · Los tres blancos
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;#&lt;/th&gt;
&lt;th&gt;repo&lt;/th&gt;
&lt;th&gt;★&lt;/th&gt;
&lt;th&gt;pin medido&lt;/th&gt;
&lt;th&gt;defecto&lt;/th&gt;
&lt;th&gt;locus&lt;/th&gt;
&lt;th&gt;severidad&lt;/th&gt;
&lt;th&gt;repo vivo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;&lt;code&gt;livekit/agents&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;15 107&lt;/td&gt;
&lt;td&gt;&lt;code&gt;055744e1505b&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;la suite STT no puede fallar (doble capa)&lt;/td&gt;
&lt;td&gt;&lt;code&gt;test-stt.yml:201&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;MEDIA&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;sí&lt;/strong&gt; (commit hoy)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;&lt;code&gt;raga-ai-hub/RagaAI-Catalyst&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;16 185&lt;/td&gt;
&lt;td&gt;&lt;code&gt;ab6789331089&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;el pipeline entero es asesorativo + salida muerta&lt;/td&gt;
&lt;td&gt;&lt;code&gt;ci.yml:12,41,93&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;ALTA&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;no&lt;/strong&gt; (último commit 2025-05-16)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;&lt;code&gt;ggml-org/llama.cpp&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;133 519&lt;/td&gt;
&lt;td&gt;&lt;code&gt;4b77dee0524c&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;unit/client tests asesorativos mientras E2E sí gatea&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;ui.yml:55&lt;/code&gt; · &lt;code&gt;build-sanitize.yml:40&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;BAJA&lt;/td&gt;
&lt;td&gt;sí (commit hoy)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;El blanco de mayor severidad está en el repo más muerto.&lt;/strong&gt; n=2 no permite afirmar correlación: se&lt;br&gt;
publica como observación, no como ley.&lt;/p&gt;
&lt;h2&gt;
  
  
  3 · Blanco 1 — &lt;code&gt;livekit/agents&lt;/code&gt; (el único que firmo)
&lt;/h2&gt;
&lt;h3&gt;
  
  
  El defecto, verbatim en &lt;code&gt;test-stt.yml@055744e1505b:201&lt;/code&gt;
&lt;/h3&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Run STT tests&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt;
    &lt;span class="s"&gt;uv run pytest -n 3 -v --stt --tb=long --junitxml=test-results.xml 2&amp;gt;&amp;amp;1 | tee test-output.txt || true&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Dos capas independientes borran el resultado:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;code&gt;|| true&lt;/code&gt; convierte cualquier salida distinta de cero en 0.&lt;/li&gt;
&lt;li&gt;Aunque se quite &lt;code&gt;|| true&lt;/code&gt;, la tubería termina en &lt;code&gt;tee&lt;/code&gt;, y en el bash por defecto (sin &lt;code&gt;pipefail&lt;/code&gt;) el
estado del paso es el de &lt;code&gt;tee&lt;/code&gt;, que es 0 siempre que pueda escribir el archivo. &lt;strong&gt;Borrar &lt;code&gt;|| true&lt;/code&gt; a
secas no restaura la guarda&lt;/strong&gt; — esto es lo que separa una lectura superficial de una medición.&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;
  
  
  Por qué probablemente no es lo que se quiso
&lt;/h3&gt;

&lt;p&gt;Los pasos posteriores ya están escritos para correr pase lo que pase (&lt;code&gt;Generate test summary&lt;/code&gt; y&lt;br&gt;
&lt;code&gt;Post results to PR&lt;/code&gt; llevan &lt;code&gt;if: always()&lt;/code&gt;), y &lt;code&gt;pytest --junitxml&lt;/code&gt; escribe el XML también al fallar. El&lt;br&gt;
&lt;code&gt;|| true&lt;/code&gt; &lt;strong&gt;no es necesario para que exista el reporte&lt;/strong&gt;: &lt;code&gt;always()&lt;/code&gt; ya lo compraba. Lo único que compra&lt;br&gt;
es que una suite STT roja sea indistinguible de una verde en la lista de checks.&lt;/p&gt;
&lt;h3&gt;
  
  
  El contraste que hace creíble el reporte
&lt;/h3&gt;

&lt;p&gt;El mismo repositorio ya implementa el patrón correcto en &lt;code&gt;ci.yml:34-43&lt;/code&gt;: &lt;code&gt;continue-on-error: true&lt;/code&gt; sobre&lt;br&gt;
&lt;code&gt;ruff&lt;/code&gt; &lt;strong&gt;más&lt;/strong&gt; un paso &lt;code&gt;Report ruff errors&lt;/code&gt; con &lt;code&gt;if: steps.ruff-check.outcome == 'failure' || …&lt;/code&gt; que hace&lt;br&gt;
&lt;code&gt;exit 1&lt;/code&gt;. Es decir: la casa sabe cerrar una guarda. &lt;code&gt;test-stt.yml&lt;/code&gt; es una inconsistencia, no una filosofía.&lt;/p&gt;
&lt;h3&gt;
  
  
  Texto del Issue — listo para pegar
&lt;/h3&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Título:&lt;/strong&gt; &lt;code&gt;ci: Test STT reports green on a failing suite —&lt;/code&gt; || true&lt;code&gt;plus a&lt;/code&gt;tee&lt;code&gt;pipeline erase the exit code&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Body:&lt;/strong&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  What
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;.github/workflows/test-stt.yml:201&lt;/code&gt; cannot fail:&lt;/p&gt;


&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Run STT tests&lt;/span&gt;
  &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt;
    &lt;span class="s"&gt;uv run pytest -n 3 -v --stt --tb=long --junitxml=test-results.xml 2&amp;gt;&amp;amp;1 | tee test-output.txt || true&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;


&lt;p&gt;Two independent layers erase the result:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;code&gt;|| true&lt;/code&gt; turns any non-zero exit into 0.&lt;/li&gt;
&lt;li&gt;Even without &lt;code&gt;|| true&lt;/code&gt;, the pipeline ends in &lt;code&gt;tee&lt;/code&gt;; with the default bash (no &lt;code&gt;pipefail&lt;/code&gt;) the step's
status is &lt;code&gt;tee&lt;/code&gt;'s, which is 0 as long as it can write the file. So deleting &lt;code&gt;|| true&lt;/code&gt; alone does
&lt;strong&gt;not&lt;/strong&gt; restore the gate.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Measured at &lt;code&gt;livekit/agents@055744e1505b1489976d06ca029b3001bc91ea55&lt;/code&gt;.&lt;/p&gt;
&lt;h2&gt;
  
  
  Why it is probably not what you meant
&lt;/h2&gt;

&lt;p&gt;The steps after it already run regardless of the test outcome (&lt;code&gt;Generate test summary&lt;/code&gt; and&lt;br&gt;
&lt;code&gt;Post results to PR&lt;/code&gt; both carry &lt;code&gt;if: always()&lt;/code&gt;), and &lt;code&gt;pytest --junitxml&lt;/code&gt; writes the XML on failure too.&lt;br&gt;
The &lt;code&gt;|| true&lt;/code&gt; is not needed for the report to exist — &lt;code&gt;always()&lt;/code&gt; already buys that. What it buys is&lt;br&gt;
that a red STT suite looks exactly like a green one in the checks list.&lt;/p&gt;
&lt;h2&gt;
  
  
  Why it matters
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;Test STT&lt;/code&gt; triggers on &lt;code&gt;pull_request&lt;/code&gt; for changes to &lt;code&gt;tests/test_stt.py&lt;/code&gt; and to its own workflow — the&lt;br&gt;
PRs most likely to break STT. The PR comment lists per-provider results, but nothing in the merge UI&lt;br&gt;
does. If this workflow is advisory by design, its name and a comment should say so; if it is a gate,&lt;br&gt;
it does not gate.&lt;/p&gt;
&lt;h2&gt;
  
  
  Reproduction
&lt;/h2&gt;


&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone --depth 1 https://github.com/livekit/agents &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="nb"&gt;cd&lt;/span&gt; agents
git fetch --depth 1 origin 055744e1505b1489976d06ca029b3001bc91ea55
git checkout 055744e1505b1489976d06ca029b3001bc91ea55
sed -n &lt;span class="s1"&gt;'201p'&lt;/span&gt; .github/workflows/test-stt.yml

bash -c &lt;span class="s1"&gt;'false | tee out.txt || true'&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;            &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"exit=$?"&lt;/span&gt;   &lt;span class="c"&gt;# 0  &amp;lt;- || true&lt;/span&gt;
bash -c &lt;span class="s1"&gt;'false | tee out.txt'&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;                    &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"exit=$?"&lt;/span&gt;   &lt;span class="c"&gt;# 0  &amp;lt;- tee, no pipefail&lt;/span&gt;
bash -c &lt;span class="s1"&gt;'set -o pipefail; false | tee out.txt'&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;   &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;"exit=$?"&lt;/span&gt;   &lt;span class="c"&gt;# 1  &amp;lt;- lo que falta&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;h2&gt;
  
  
  Proposal, cheapest first
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Keep the report, restore the signal:&lt;/strong&gt; drop &lt;code&gt;|| true&lt;/code&gt; and run the step with &lt;code&gt;set -o pipefail&lt;/code&gt;
(job-level &lt;code&gt;defaults.run.shell: bash -eo pipefail {0}&lt;/code&gt;, or &lt;code&gt;set -o pipefail&lt;/code&gt; inside the &lt;code&gt;run&lt;/code&gt;).
&lt;code&gt;tee&lt;/code&gt; still writes the log; the step now exits with pytest's status.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;If providers legitimately cannot run on forks without secrets,&lt;/strong&gt; skip them explicitly
(&lt;code&gt;pytest.mark.skipif(not os.getenv("DEEPGRAM_API_KEY"), …)&lt;/code&gt;) instead of letting the whole suite exit
non-zero. A skip is honest; &lt;code&gt;|| true&lt;/code&gt; is not.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;If the workflow is advisory by contract,&lt;/strong&gt; rename it (&lt;code&gt;Test STT (advisory)&lt;/code&gt;) and leave a one-line
comment at line 201 saying so, so the next reader does not "fix" it in the wrong direction.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Happy to send (1) as a PR if that is the direction — I did not want to change CI semantics in a repo&lt;br&gt;
where the reporting steps clearly have intent.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2&gt;
  
  
  4 · Blanco 2 — &lt;code&gt;RagaAI-Catalyst&lt;/code&gt; (defecto grave, repo dormido)
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;ci.yml@ab6789331089&lt;/code&gt;, un solo workflow para todo el repo:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;:12&lt;/code&gt; &lt;code&gt;code-quality&lt;/code&gt; con &lt;code&gt;continue-on-error: true&lt;/code&gt;, y sus pasos son &lt;code&gt;ruff format .&lt;/code&gt; + &lt;code&gt;ruff check --fix .&lt;/code&gt;:
&lt;strong&gt;arregla y no commitea&lt;/strong&gt;, sobre un checkout desechable. El job no puede fallar ni dejar rastro.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;:41&lt;/code&gt; el job &lt;code&gt;test&lt;/code&gt; también con &lt;code&gt;continue-on-error: true&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;:40&lt;/code&gt; el único &lt;code&gt;needs:&lt;/code&gt; es &lt;code&gt;test → code-quality&lt;/code&gt;. &lt;strong&gt;Nadie necesita &lt;code&gt;test&lt;/code&gt;&lt;/strong&gt; ⇒ el estado terminal del
workflow es asesorativo.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;:49&lt;/code&gt; declara &lt;code&gt;outputs.test_summary&lt;/code&gt; desde &lt;code&gt;steps.pytest.outputs.test_summary&lt;/code&gt;, que se produce en &lt;code&gt;:94&lt;/code&gt;.
&lt;code&gt;grep -rn test_summary .github/&lt;/code&gt; devuelve &lt;strong&gt;sólo esas dos líneas&lt;/strong&gt;: la salida se declara y no la lee nadie.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;:93&lt;/code&gt; &lt;code&gt;pytest tests/ -v --junitxml=test-results/junit.xml | tee test-output.txt&lt;/code&gt; — sin &lt;code&gt;pipefail&lt;/code&gt; en
ningún workflow del repo (&lt;code&gt;grep -rn pipefail&lt;/code&gt; = 0). Aunque se quite el &lt;code&gt;coe&lt;/code&gt;, el paso sigue verde.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Diagnóstico honesto del porqué:&lt;/strong&gt; &lt;code&gt;tests/&lt;/code&gt; incluye pruebas de integración que exigen ~20 secretos; en&lt;br&gt;
forks no pueden pasar. La respuesta correcta es separar marcadores (&lt;code&gt;-m "not integration"&lt;/code&gt; para la guarda,&lt;br&gt;
integración asesorativa), no volver asesorativo el pipeline entero.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Y la condición del repo:&lt;/strong&gt; último commit &lt;code&gt;2025-05-16&lt;/code&gt;. Un issue aquí &lt;strong&gt;no produce conversación&lt;/strong&gt;; produce&lt;br&gt;
un artefacto de auditoría. Se entrega como tal, sin contarlo como pitch.&lt;/p&gt;
&lt;h2&gt;
  
  
  5 · Blanco 3 — &lt;code&gt;llama.cpp&lt;/code&gt; (defecto leve en repo vivo)
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;ui.yml:55&lt;/code&gt; marca asesorativo el job &lt;code&gt;ui-checks&lt;/code&gt; completo, que incluye &lt;code&gt;Run Client tests&lt;/code&gt; y &lt;code&gt;Run Unit tests&lt;/code&gt;&lt;br&gt;
(&lt;code&gt;ui.yml:100&lt;/code&gt;, &lt;code&gt;:105&lt;/code&gt;); &lt;code&gt;build-sanitize.yml:40&lt;/code&gt; hace lo mismo con &lt;code&gt;ctest&lt;/code&gt;. Pero &lt;code&gt;e2e-tests&lt;/code&gt; en el mismo&lt;br&gt;
archivo &lt;strong&gt;no&lt;/strong&gt; lleva &lt;code&gt;continue-on-error&lt;/code&gt;: hay un gate real para E2E, no para unit/cliente ni para sanitizers.&lt;/p&gt;

&lt;p&gt;Se publica como &lt;strong&gt;pregunta de diseño&lt;/strong&gt; («¿es intencional que unit/cliente sean asesorativos mientras E2E&lt;br&gt;
gatea?»), no como acusación. En un repo de 133 519 ★ y 2 584 issues abiertos, un issue de severidad baja&lt;br&gt;
compite contra ruido.&lt;/p&gt;
&lt;h2&gt;
  
  
  6 · Controles negativos — lo que NO es defecto
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;repo&lt;/th&gt;
&lt;th&gt;locus&lt;/th&gt;
&lt;th&gt;por qué no es defecto&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;PrefectHQ/prefect&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;api-compatibility-tests.yaml:19-21&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;el job se llama &lt;code&gt;Cloud API compatibility (advisory)&lt;/code&gt; y lleva el comentario «Keep compatibility and harness failures advisory for contributors»&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;LMCache/LMCache&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;cpu_device.yml:366&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;el archivo &lt;strong&gt;declara&lt;/strong&gt; que no hay &lt;code&gt;continue-on-error&lt;/code&gt;; todos los || true son limpieza de docker/&lt;code&gt;df&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Arize-ai/phoenix&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;claude-daily-deps-upgrade.yml&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;workflow de bot sobre PRs propias&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vibrantlabsai/ragas&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;ci.yaml:126,129&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;sólo corre &lt;code&gt;tests/unit&lt;/code&gt;; &lt;code&gt;tests/e2e&lt;/code&gt; son &lt;strong&gt;32 rutas&lt;/strong&gt; en &lt;code&gt;HEAD&lt;/code&gt; y ningún workflow las invoca (&lt;code&gt;grep -rn e2e&lt;/code&gt; sobre sus 8 workflows = 0) — &lt;strong&gt;hueco de cobertura, no fail-open&lt;/strong&gt;, y el repo no tiene commit desde &lt;code&gt;2026-02-24&lt;/code&gt;, así que no se propone&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;h2&gt;
  
  
  7 · El hallazgo caro: el canal no está vacío, está ocupado
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;livekit/agents#8231&lt;/code&gt; (2026-10-29, «unit tests pin Python 3.12 while the package advertises 3.14 support»)&lt;br&gt;
es un issue de fuera, con loci y propuesta — exactamente el formato de este documento. Cronología medida:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;cuándo&lt;/th&gt;
&lt;th&gt;qué&lt;/th&gt;
&lt;th&gt;firma&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;2026-10-29&lt;/td&gt;
&lt;td&gt;se abre &lt;code&gt;#8231&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;kcncb&lt;/code&gt;, &lt;code&gt;author_association: NONE&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2026-10-29 13:17&lt;/td&gt;
&lt;td&gt;alguien lo toma y declara «Slai Agent Runtime assisted»&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;huong8373tt-beep&lt;/code&gt;, &lt;code&gt;NONE&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2026-10-30 02:19&lt;/td&gt;
&lt;td&gt;el autor original contesta (13 h) — &lt;strong&gt;de fuera a fuera&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;&lt;code&gt;kcncb&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2026-10-30 03:10&lt;/td&gt;
&lt;td&gt;se abre &lt;code&gt;#8252&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;&lt;code&gt;huong8373tt-beep&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2026-11-05 22:45&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;#8252&lt;/code&gt; &lt;strong&gt;cerrado sin merge, por su propio autor&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;&lt;code&gt;huong8373tt-beep&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Revisión registrada en &lt;code&gt;#8252&lt;/code&gt;: &lt;code&gt;devin-ai-integration[bot]&lt;/code&gt; y &lt;code&gt;kcncb&lt;/code&gt;. &lt;strong&gt;Cero revisión de mantenedor.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;⇒ El canal de «audito tu CI y te lo cuento» &lt;strong&gt;tiene conversación y no tiene conversión&lt;/strong&gt;, y el que&lt;br&gt;
contesta suele ser otro agente de fuera. n=1: se publica como observación con su falsador — si en 5&lt;br&gt;
issues propios en repos vivos no aparece &lt;strong&gt;una&lt;/strong&gt; respuesta de mantenedor, la observación se sostiene.&lt;/p&gt;
&lt;h2&gt;
  
  
  8 · La estrategia corregida
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;«El Francotirador»&lt;/strong&gt; (buscar el defecto oculto en 50 repos y disparar) midió &lt;strong&gt;2 %&lt;/strong&gt; de blancos vivos.&lt;br&gt;
Su costo real no es el escaneo: es que 49 de cada 50 intentos no producen nada y el disparo se gasta en un&lt;br&gt;
repo muerto o en un defecto que el dueño declaró a propósito.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;«El Interlocutor»&lt;/strong&gt; invierte la carga: no se busca el defecto, se entra donde &lt;strong&gt;el dolor ya está escrito&lt;/strong&gt;&lt;br&gt;
y se lleva la medición que el autor no tiene. El dolor lo declara el cliente; el instrumento es lo único&lt;br&gt;
que se aporta. Aplica al mismo canal, con la misma firma pública y un costo por intento mucho menor.&lt;/p&gt;

&lt;p&gt;Regla de entrada, una: &lt;strong&gt;no se comenta sin una medición que el autor del issue no tenga ya&lt;/strong&gt;. Si el&lt;br&gt;
comentario se puede escribir sin correr nada, no se escribe.&lt;/p&gt;

&lt;p&gt;Cola concreta medida (issues abiertos, sin respuesta, sobre CI/tests):&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;repo&lt;/th&gt;
&lt;th&gt;issue&lt;/th&gt;
&lt;th&gt;estado&lt;/th&gt;
&lt;th&gt;qué se aportaría&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vibrantlabsai/ragas&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;#2989 «CI: check-docs fails on every fork PR — pull_request_target»: &lt;code&gt;claude-docs-check.yml&lt;/code&gt; cae a los ~6 s &lt;strong&gt;en el paso de checkout&lt;/strong&gt;, antes de analizar nada&lt;/td&gt;
&lt;td&gt;abierto, &lt;strong&gt;0 comentarios&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;confirmar el bloqueo contra &lt;code&gt;actions/checkout&lt;/code&gt; y entregar el diff mínimo con permisos recortados&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;ggml-org/llama.cpp&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;#30281 &lt;code&gt;test-backend-ops&lt;/code&gt; debería salir 1 cuando falta backend&lt;/td&gt;
&lt;td&gt;abierto, 0 comentarios&lt;/td&gt;
&lt;td&gt;confirmar con una corrida y proponer el &lt;code&gt;exit&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;PrefectHQ/prefect&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;#16404 / #16310 / #15558 flaky tests&lt;/td&gt;
&lt;td&gt;abiertos desde 2024&lt;/td&gt;
&lt;td&gt;medir la tasa de flake por test antes de opinar&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Nota:&lt;/strong&gt; &lt;code&gt;ragas#2989&lt;/code&gt; describe corridas de septiembre de 2026 sobre un repo cuyo último commit es&lt;br&gt;
&lt;code&gt;2026-02-24&lt;/code&gt;. Antes de comentar hay que comprobar que el workflow sigue existiendo en ese pin; si no,&lt;br&gt;
el issue es de otro objeto y comentarlo quema la firma.&lt;/p&gt;
&lt;h2&gt;
  
  
  9 · DMs
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;LiveKit — David Zhao.&lt;/strong&gt; Verificado: &lt;code&gt;davidzhao&lt;/code&gt; · name «David Zhao» · company &lt;code&gt;@livekit&lt;/code&gt; · X &lt;code&gt;davidzh&lt;/code&gt;.&lt;br&gt;
No se usa ningún otro handle: &lt;code&gt;russdsa&lt;/code&gt; devuelve &lt;strong&gt;404&lt;/strong&gt; y no se inventa.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Hi David — I spent a day auditing CI signal across 50 company repos in the voice-AI / infra space, and&lt;br&gt;
one finding landed in &lt;code&gt;livekit/agents&lt;/code&gt;. &lt;code&gt;.github/workflows/test-stt.yml:201&lt;/code&gt; can't fail: &lt;code&gt;|| true&lt;/code&gt; plus a&lt;br&gt;
&lt;code&gt;tee&lt;/code&gt; pipeline (no &lt;code&gt;pipefail&lt;/code&gt;) erase pytest's exit code, so a red STT suite and a green one look&lt;br&gt;
identical in the checks list. Your ruff steps at &lt;code&gt;ci.yml:34-43&lt;/code&gt; already do the opposite — they gate via a&lt;br&gt;
&lt;code&gt;steps.*.outcome&lt;/code&gt; postcondition — which is why it reads as an inconsistency rather than a philosophy.&lt;br&gt;
Three-line fix, happy to send it as an issue or a PR, whichever you prefer. I run Platino Labs: we&lt;br&gt;
audit CI for fail-open guards like this one. No pitch attached — the finding is yours either way.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;strong&gt;RagaAI — &lt;code&gt;NO_MEDIDO&lt;/code&gt;.&lt;/strong&gt; No hay handle de fundador verificado; no se fabrica un nombre. El hallazgo del&lt;br&gt;
§4 se entrega como artefacto, no como DM.&lt;/p&gt;
&lt;h2&gt;
  
  
  10 · Punteros
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;pieza&lt;/th&gt;
&lt;th&gt;qué es&lt;/th&gt;
&lt;th&gt;ruta&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;instrumento de censo&lt;/td&gt;
&lt;td&gt;censo de guardas fail-open sobre cohorte pinneada&lt;/td&gt;
&lt;td&gt;&lt;code&gt;tools/correr_censo.py&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;sonda de nivel 6&lt;/td&gt;
&lt;td&gt;el motor de auditoría del corpus&lt;/td&gt;
&lt;td&gt;&lt;code&gt;tools/sonda_nivel_6.py&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;gate de pre-escritura&lt;/td&gt;
&lt;td&gt;A2.1&lt;/td&gt;
&lt;td&gt;&lt;code&gt;tools/gate_pre_escritura.sh&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;receta de artículo&lt;/td&gt;
&lt;td&gt;cómo un hallazgo pasa a nota pública&lt;/td&gt;
&lt;td&gt;&lt;code&gt;ARTICULO_DEVTO_AUDITORIA_LITELLM_46923_PUBLICO.md&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;red de publicación&lt;/td&gt;
&lt;td&gt;cómo una nota pasa a encolada&lt;/td&gt;
&lt;td&gt;&lt;code&gt;PUBLICAR_EN_RED.md&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;canal medido&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;Canal público&lt;/code&gt; sin alcance · &lt;code&gt;Canal empresa&lt;/code&gt; con &lt;code&gt;Sent&lt;/code&gt; = 0&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;_PLAN.md&lt;/code&gt; §2 · &lt;code&gt;_REGISTRO.md&lt;/code&gt; fila 25&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Nota de duplicación:&lt;/strong&gt; otro carril del árbol tiene en vuelo &lt;code&gt;tools/auditar_fail_open_universal.py&lt;/code&gt;&lt;br&gt;
(34 896 B, 2026-11-06T00:49) y &lt;code&gt;tools/auditar_soft_fail_buildkite.py&lt;/code&gt;. El clasificador usado aquí fue&lt;br&gt;
ad-hoc en &lt;code&gt;/tmp/caza/&lt;/code&gt; &lt;strong&gt;antes&lt;/strong&gt; de encontrar &lt;code&gt;tools/correr_censo.py&lt;/code&gt; en&lt;br&gt;
&lt;code&gt;INVENTARIO_INSTRUMENTOS.md&lt;/code&gt;. Los números de este documento se&lt;br&gt;
reconcilian contra &lt;code&gt;correr_censo.py --planificar&lt;/code&gt; (pines de 29/50 repos, estado &lt;code&gt;PARCIAL&lt;/code&gt; por HTTP 403);&lt;br&gt;
los demás pines se tomaron con &lt;code&gt;gh api repos/{n}/commits?per_page=1&lt;/code&gt;.&lt;/p&gt;
&lt;h2&gt;
  
  
  11 · Los disparos, ejecutados (2026-11-06)
&lt;/h2&gt;

&lt;p&gt;Los dos actos públicos de este documento salieron. No hay un tercero: &lt;code&gt;llama.cpp&lt;/code&gt; y &lt;code&gt;RagaAI-Catalyst&lt;/code&gt;&lt;br&gt;
quedaron como artefacto interno y no se publican (§6 y §9 dicen por qué).&lt;/p&gt;
&lt;h3&gt;
  
  
  11.1 · &lt;code&gt;vibrantlabsai/ragas#2989&lt;/code&gt; — comentario técnico publicado
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/vibrantlabsai/ragas/issues/2989#issuecomment-6679331106" rel="noopener noreferrer"&gt;https://github.com/vibrantlabsai/ragas/issues/2989#issuecomment-6679331106&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;El issue seguía &lt;strong&gt;abierto, 0 comentarios, sin editar desde &lt;code&gt;2026-09-02T15:16:45Z&lt;/code&gt;&lt;/strong&gt;: el comentario es el&lt;br&gt;
primero. Se verificó que el workflow existe en el pin citado antes de escribir (§8 lo exigía).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Lo que el autor no tenía —medido en &lt;code&gt;298b68274234c060deacab3cf5fb52aa3a20e885&lt;/code&gt;— y se le entregó:&lt;/strong&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;medición&lt;/th&gt;
&lt;th&gt;valor&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;workflows que declaran &lt;code&gt;pull_request_target&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;3 de 8&lt;/strong&gt;, y &lt;strong&gt;2&lt;/strong&gt; hacen checkout del código del fork: el issue nombra &lt;strong&gt;1&lt;/strong&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;el segundo, &lt;code&gt;claude-docs-apply.yml:21-22&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;el más expuesto: &lt;code&gt;permissions: contents: write&lt;/code&gt; (&lt;code&gt;:12&lt;/code&gt;), token CLAUDE_CODE_PAT || GITHUB_TOKEN (&lt;code&gt;:24&lt;/code&gt;)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;por qué ese segundo está inalcanzable hoy&lt;/td&gt;
&lt;td&gt;el rojo de &lt;code&gt;check-docs&lt;/code&gt; mata el checkout &lt;strong&gt;antes&lt;/strong&gt; del paso que pone &lt;code&gt;needs-doc-update&lt;/code&gt;, y esa etiqueta es el único disparador de &lt;code&gt;apply-docs&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;corridas de &lt;code&gt;Claude Docs Apply&lt;/code&gt; (&lt;code&gt;216244931&lt;/code&gt;) en toda su historia&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;allow-unsafe-pr-checkout&lt;/code&gt; en &lt;code&gt;actions/checkout&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;ausente en v4.1.7 · v4.2.0 · v4.2.1 · v4.2.2 · v4.3.0 · v4.3.1; &lt;strong&gt;primera aparición v4.4.0&lt;/strong&gt; (&lt;code&gt;action.yml:101&lt;/code&gt;)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;corridas de &lt;code&gt;Claude Docs Check&lt;/code&gt; (&lt;code&gt;216244933&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;391&lt;/strong&gt;, todas de forks: 142 éxito · 223 fallo · 26 canceladas&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;último éxito&lt;/td&gt;
&lt;td&gt;&lt;code&gt;2026-07-20T11:26:10Z&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;racha roja vigente&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;162 fallos consecutivos, 0 éxitos&lt;/strong&gt; desde &lt;code&gt;2026-07-20T16:54:58Z&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;publicación de &lt;code&gt;actions/checkout&lt;/code&gt; v4.4.0&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;2026-07-20T15:36:10Z&lt;/code&gt; — &lt;strong&gt;78 minutos antes&lt;/strong&gt; del primer fallo de la racha&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;límite de honestidad&lt;/td&gt;
&lt;td&gt;logs anteriores a ~&lt;code&gt;2026-08-08&lt;/code&gt; caducados (&lt;code&gt;HTTP 410&lt;/code&gt;) ⇒ la causa del &lt;strong&gt;primer&lt;/strong&gt; fallo es &lt;code&gt;NO_MEDIDO&lt;/code&gt;; la de todos los legibles, la guarda de checkout&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;El comentario no vende, no enlaza este repo y no menciona servicios: firma con &lt;code&gt;@alexisromtz-lab&lt;/code&gt; al pie y&lt;br&gt;
declara el pin. La lección que deja: &lt;strong&gt;el issue describía la mitad del patrón&lt;/strong&gt;, y esa mitad no se veía sin&lt;br&gt;
correr el censo sobre el pin — no sin leer el issue.&lt;/p&gt;
&lt;h3&gt;
  
  
  11.2 · &lt;code&gt;livekit/agents&lt;/code&gt; — Issue publicado
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/livekit/agents/issues/8417" rel="noopener noreferrer"&gt;https://github.com/livekit/agents/issues/8417&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Título: &lt;code&gt;ci: Test STT cannot fail — || true and a tee pipeline erase the exit code&lt;/code&gt;. Cuerpo íntegro de §3.&lt;br&gt;
Re-verificado antes de disparar: en &lt;code&gt;055744e1505b1489976d06ca029b3001bc91ea55&lt;/code&gt;, &lt;code&gt;test-stt.yml:201&lt;/code&gt; es&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;uv run pytest -n 3 -v --stt --tb=long --junitxml=test-results.xml 2&lt;span class="o"&gt;&amp;gt;&amp;amp;&lt;/span&gt;1 &lt;span class="o"&gt;|&lt;/span&gt; tee test-output.txt &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Sin duplicado: &lt;code&gt;gh issue list -R livekit/agents --author @me --state all&lt;/code&gt; devolvía &lt;strong&gt;0&lt;/strong&gt; issues antes del&lt;br&gt;
alta. El reporte sobrevive a los bots del canal (§7) porque no compite por atención: aporta tres líneas de&lt;br&gt;
&lt;code&gt;bash&lt;/code&gt; que el lector puede correr para ver el &lt;code&gt;exit=0&lt;/code&gt; con sus propios ojos.&lt;/p&gt;

&lt;h3&gt;
  
  
  11.3 · El censo que hizo posible el §11.1
&lt;/h3&gt;

&lt;p&gt;&lt;code&gt;tools/correr_censo.py&lt;/code&gt; moría en &lt;strong&gt;29 pines de 50&lt;/strong&gt; porque no tenía modo autenticado: &lt;code&gt;token()&lt;/code&gt; solo leía&lt;br&gt;
&lt;code&gt;GITHUB_TOKEN&lt;/code&gt;/&lt;code&gt;GH_TOKEN&lt;/code&gt;, ambas ausentes, mientras &lt;code&gt;gh auth status&lt;/code&gt; estaba verde — 60 peticiones por hora&lt;br&gt;
sin credencial, 2 por repo = &lt;strong&gt;30 repos por hora&lt;/strong&gt;, exactamente el techo donde se detuvo. Corregido en&lt;br&gt;
&lt;code&gt;6a56efa0&lt;/code&gt; con &lt;code&gt;gh auth token&lt;/code&gt; como tercera fuente, fuente publicada y ausencia tipada. Medido en el acto,&lt;br&gt;
misma cohorte: &lt;strong&gt;&lt;code&gt;PARCIAL&lt;/code&gt; 29/50 → &lt;code&gt;RESUELTA&lt;/code&gt; 50/50&lt;/strong&gt; con &lt;code&gt;autenticacion.fuente = gh:auth-token&lt;/code&gt;.&lt;br&gt;
Sin ese arreglo, la tabla de §11.1 se habría quedado en la mitad de sus filas.&lt;/p&gt;







&lt;h2&gt;
  
  
  12. Lo que el mundo contestó — censo de interacciones (2026-11-06)
&lt;/h2&gt;

&lt;p&gt;Medido con &lt;code&gt;gh api "search/issues?q=commenter:alexisromtz-lab"&lt;/code&gt; (39 hilos) leyendo los comentarios de cada hilo, no contando notificaciones. Ventana del censo: hasta &lt;code&gt;2026-11-06T18:15Z&lt;/code&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  12.1 La huella, medida
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;repos ajenos&lt;/th&gt;
&lt;th&gt;hilos donde comentamos&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;tenstorrent/tt-metal&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;14&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vllm-project/vllm-omni&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;7&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;BerriAI/litellm&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;vllm-project/vllm&lt;/code&gt; · &lt;code&gt;huggingface/transformers&lt;/code&gt; · &lt;code&gt;huggingface/smolagents&lt;/code&gt; · &lt;code&gt;astral-sh/uv&lt;/code&gt; · &lt;code&gt;duetosymmetry/qnm&lt;/code&gt; · &lt;code&gt;vibrantlabsai/ragas&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;1 cada uno&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Total&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;30 hilos ajenos&lt;/strong&gt; (39 con los 9 propios)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;De esos 30, &lt;strong&gt;13&lt;/strong&gt; recibieron actividad humana posterior y &lt;strong&gt;6&lt;/strong&gt; recibieron una respuesta &lt;strong&gt;dirigida a nuestro comentario&lt;/strong&gt;, no actividad vecina.&lt;/p&gt;

&lt;h3&gt;
  
  
  12.2 Los humanos que contestaron
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;hilo&lt;/th&gt;
&lt;th&gt;quién&lt;/th&gt;
&lt;th&gt;qué dijo&lt;/th&gt;
&lt;th&gt;veredicto&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;livekit/agents#8417&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;iamdgarcia&lt;/code&gt; (CONTRIBUTOR, 6 PRs en el repo)&lt;/td&gt;
&lt;td&gt;verificó el hallazgo, aportó 2 datos propios y ofreció el PR&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;conversión&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vllm-project/vllm-omni#9086&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;hsliuustc0106&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;APPROVED&lt;/code&gt;, 4 checks en verde&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;aprobado, sin mergear&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vllm-project/vllm-omni#9096&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;hsliuustc0106&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;APPROVED&lt;/code&gt;, 4 checks en verde&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;aprobado, sin mergear&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vllm-project/vllm-omni#9129&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;Big2Wheel&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;validación en hardware real: Ascend 910B3, imagen &lt;code&gt;96fa…&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;validación externa&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;duetosymmetry/qnm#22&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;duetosymmetry&lt;/code&gt; (maintainer)&lt;/td&gt;
&lt;td&gt;«Alexis — I'll happily review a PR that you submit fixing the bug you found»&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;invitación&lt;/strong&gt; → &lt;code&gt;qnm#45&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;BerriAI/litellm#47340&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;Mrun25&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;«Thanks for digging into this, alexisromtz-lab. The TTL-plumbing analysis is a real adjacent gap»&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;crédito técnico&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vllm-project/vllm#62322&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;mosafariuk&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;corrigió nuestra medición con el wheel publicado&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;corrección aceptada&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;BerriAI/litellm#46923&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;shaikn6&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;«&lt;code&gt;_has_pre_deployment_request_rewriters&lt;/code&gt; doesn't exist anywhere»&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;cita fantasma&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;tenstorrent/tt-metal#53639&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;kinginu&lt;/code&gt; (autor del PR)&lt;/td&gt;
&lt;td&gt;«ignore comments from @alexisromtz-lab… could you block @alexisromtz-lab from this repo»&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;daño público&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;11 personas distintas&lt;/strong&gt; interactuaron: 6 en comentarios y 5 en reviews o validación de hardware.&lt;/p&gt;

&lt;h3&gt;
  
  
  12.3 La tasa de interacción, contra su línea base
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;métrica&lt;/th&gt;
&lt;th&gt;valor&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;hilos ajenos con respuesta dirigida a nosotros&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;6 / 30 = 20 %&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;hilos ajenos con cualquier actividad humana posterior&lt;/td&gt;
&lt;td&gt;13 / 30 = 43 %&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;línea base de Caza Mayor (issue frío, genuino, vivo)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;1 / 50 = 2 %&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;factor&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;≈10×&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La estrategia del Interlocutor se sostiene con el dato: comentar donde ya hay un humano midiendo rinde diez veces más que abrir un issue frío. Lo que el dato &lt;strong&gt;no&lt;/strong&gt; sostiene es que todo comentario rinda: &lt;strong&gt;1 de cada 6 respuestas fue hostilidad&lt;/strong&gt;, y &lt;strong&gt;2 de 9 humanos acusaron a la cuenta de citar objetos que no existen&lt;/strong&gt;. Las dos acusaciones son del mismo defecto, y el defecto es nuestro.&lt;/p&gt;

&lt;h3&gt;
  
  
  12.4 El daño, medido y fechado
&lt;/h3&gt;

&lt;p&gt;&lt;code&gt;tenstorrent/tt-metal#53639&lt;/code&gt;, comentarios de &lt;code&gt;kinginu&lt;/code&gt; del &lt;code&gt;2026-10-20T03:15:49Z&lt;/code&gt; (1 325 car.) y del &lt;code&gt;2026-10-21T02:51:12Z&lt;/code&gt; (244 car.):&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;«Please ignore comments from @alexisromtz-lab. I dont have any connections with this bot.»&lt;/p&gt;

&lt;p&gt;«@jberkowitzTT could you block @alexisromtz-lab from this repo, or hide their comments as off topic? I have no connection with that bot, and it keeps stepping into the review conversation.»&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;strong&gt;Después de esa petición publicamos dos comentarios más&lt;/strong&gt; en el mismo hilo: &lt;code&gt;2026-10-27T22:23:48Z&lt;/code&gt; (6 077 car.) y &lt;code&gt;2026-10-27T22:51:14Z&lt;/code&gt; (1 790 car.). Un humano pidió que nos fuéramos del hilo y respondimos con 7 867 caracteres. Eso no es un fallo de contenido: es un fallo de &lt;strong&gt;escucha&lt;/strong&gt;, y es el único de esta lista que no se arregla con una medición.&lt;/p&gt;

&lt;h3&gt;
  
  
  12.5 Las dos citas fantasma
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;hilo&lt;/th&gt;
&lt;th&gt;cita que se hizo&lt;/th&gt;
&lt;th&gt;lo que el humano midió&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;BerriAI/litellm#46923&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;_has_pre_deployment_request_rewriters&lt;/code&gt;, &lt;code&gt;router.py:1062&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;0 ocurrencias repo-wide en &lt;code&gt;d7620c77a1&lt;/code&gt;; &lt;code&gt;router.py:1062&lt;/code&gt; es &lt;code&gt;_exact_base_model_max_input_tokens()&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;duetosymmetry/qnm#22&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;medicion_qnm_cf_tol.py&lt;/code&gt; en el registro Zenodo&lt;/td&gt;
&lt;td&gt;«I can not find &lt;code&gt;medicion_qnm_cf_tol.py&lt;/code&gt; at the Zenodo record you pointed to»&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Las dos se retiraron — &lt;code&gt;litellm#46923@2026-10-20T13:55:38Z&lt;/code&gt; retira el mecanismo, y &lt;code&gt;qnm#45@2026-10-21T14:59:54Z&lt;/code&gt; registra la errata del DOI — pero &lt;strong&gt;se retiraron después de que un humano las encontrara&lt;/strong&gt;, no antes de publicarlas. Es exactamente la clase que el corpus ya nombra (&lt;code&gt;MEDICIÓN CON BLOB&lt;/code&gt;, &lt;code&gt;SIN_OBJETO&lt;/code&gt; en &lt;code&gt;tools/verificar_cita_publicable.py&lt;/code&gt;, A2.2): un objeto citado que no existe en el destino.&lt;/p&gt;

&lt;h3&gt;
  
  
  12.6 Los dos bucles que se cerraron hoy
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;livekit/agents#8417@2026-11-06T18:14:59Z&lt;/code&gt;&lt;/strong&gt; (1 881 car.) — respuesta a &lt;code&gt;iamdgarcia&lt;/code&gt;. Confirma sus dos puntos contra &lt;code&gt;main@055744e1505b&lt;/code&gt; (&lt;code&gt;pipefail&lt;/code&gt; 0 apariciones en 271 líneas; &lt;code&gt;:201&lt;/code&gt; es la única invocación de &lt;code&gt;pytest&lt;/code&gt; por &lt;code&gt;tee&lt;/code&gt;; los tres pasos siguientes llevan &lt;code&gt;if: always()&lt;/code&gt;), corrige el arreglo mínimo — &lt;strong&gt;borrar &lt;code&gt;|| true&lt;/code&gt; solo no hace nada&lt;/strong&gt;, porque sin &lt;code&gt;pipefail&lt;/code&gt; el estado del pipe es el de &lt;code&gt;tee&lt;/code&gt;, que es &lt;code&gt;0&lt;/code&gt; — y le cede el PR. Verificado por lectura de vuelta: 2 comentarios en el hilo, el segundo es nuestro.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;vllm-project/vllm#62322@2026-11-06T18:15:00Z&lt;/code&gt;&lt;/strong&gt; (1 475 car.) — &lt;strong&gt;retirada&lt;/strong&gt; de la mitad 1 de nuestro comentario del &lt;code&gt;2026-10-19&lt;/code&gt;. Nuestro arnés instalaba un wheel sintético &lt;strong&gt;por ruta de archivo&lt;/strong&gt;; &lt;code&gt;mosafariuk&lt;/code&gt; resuelve por nombre con &lt;code&gt;--extra-index-url&lt;/code&gt;, que es la única rama donde &lt;code&gt;uv&lt;/code&gt; rechaza un &lt;code&gt;Requires-Dist&lt;/code&gt; con URL. Lo que medimos fue nuestra reconstrucción de METADATA, no el artefacto que la gente instala. El &lt;code&gt;triton @&lt;/code&gt; de &lt;code&gt;requirements/cpu.txt:25-26&lt;/code&gt; gated por &lt;code&gt;platform_machine == "x86_64"&lt;/code&gt; explica la asimetría x86_64/aarch64 sin nada más. Verificado por lectura de vuelta: 3 comentarios, el tercero es nuestro.&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  12.7 Política que sale de esta jornada
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;tenstorrent/tt-metal&lt;/code&gt;: cero escrituras.&lt;/strong&gt; Un autor de PR pidió que se bloqueara la cuenta en ese repo. La resolución no es un mensaje — cualquier mensaje nuevo es la conducta que motivó la petición. Se deja el hilo como está y no se vuelve.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ningún comentario ajeno se publica con un símbolo, una ruta o un archivo que no se haya leído en el repo destino y en el commit declarado.&lt;/strong&gt; Las dos citas fantasma se habrían detenido con la misma sonda que ya corre sobre nuestros commits (A2.2), que hoy no tiene autoridad sobre la boca.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Los bucles abiertos se cierran o se declaran.&lt;/strong&gt; Queda uno declarado: &lt;code&gt;BerriAI/litellm#47340&lt;/code&gt;, repro de &lt;code&gt;Mrun25&lt;/code&gt; del &lt;code&gt;2026-10-20T04:25:18Z&lt;/code&gt;, sin respuesta nuestra.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — y la compuerta que los emite se mueve a mano, sin llamadas de red, en &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>devops</category>
      <category>ci</category>
      <category>githubactions</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Economía de contexto — el 99.2 %</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Fri, 13 Nov 2026 02:39:32 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/economia-de-contexto-el-992--58lk</link>
      <guid>https://dev.to/alexisromtz7/economia-de-contexto-el-992--58lk</guid>
      <description>&lt;p&gt;&lt;strong&gt;Regla de este documento:&lt;/strong&gt; ninguna cifra se escribe a mano. Cada una lleva el comando o el &lt;code&gt;archivo:línea&lt;/code&gt; que la produce, y la que no tiene denominador declarado no se publica.&lt;/p&gt;




&lt;h2&gt;
  
  
  1 · La tesis en una frase
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;El coste de un agente no está en lo que el modelo escribe; está en lo que la llamada arrastra.&lt;/strong&gt; Medido sobre&lt;br&gt;
28 971 llamadas reales de 5 días: el &lt;code&gt;output&lt;/code&gt; es el &lt;strong&gt;0.89 %&lt;/strong&gt; del consumo. El &lt;strong&gt;99.11 %&lt;/strong&gt; es &lt;code&gt;input&lt;/code&gt;&lt;br&gt;
(&lt;code&gt;REPORTE_TOKENS.md:130&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;De ahí el corolario incómodo: optimizar el modelo, el prompt o la temperatura mueve menos del 1 % de la factura.&lt;br&gt;
&lt;strong&gt;El 99 % restante lo decide cuántas veces se reenvía la historia.&lt;/strong&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  2 · El número del negocio: coste por tarea verificada
&lt;/h2&gt;

&lt;p&gt;No coste por llamada — coste por &lt;strong&gt;tarea&lt;/strong&gt;, que es la unidad en la que se factura y en la que se decide.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;métrica (mediana por tarea)&lt;/th&gt;
&lt;th&gt;valor&lt;/th&gt;
&lt;th&gt;n&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;consumo total de la tarea (&lt;code&gt;input&lt;/code&gt; + &lt;code&gt;output&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;18 024 682.50&lt;/strong&gt; tok&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;de eso, &lt;code&gt;output&lt;/code&gt; del modelo&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;141 574.50&lt;/strong&gt; tok&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;llamadas al modelo que hizo falta encadenar&lt;/td&gt;
&lt;td&gt;217.50&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;tokens reenviados &lt;strong&gt;por cada&lt;/strong&gt; llamada (arrastre)&lt;/td&gt;
&lt;td&gt;80 032.00&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;locus: &lt;code&gt;REPORTE_TOKENS.md:185-188 @ blob 1c09a667 (213 l)&lt;/code&gt; — correcto para la generación que §2 congela; en la generación viva la tabla vive en &lt;code&gt;:188-197 @ blob bc67c4c5&lt;/code&gt; (ver §8.1).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Una tarea cuesta 18.02 M tokens. De ellos, 141.6 k —el 0.79 %— es lo que el modelo produjo.&lt;/strong&gt; El resto es la&lt;br&gt;
misma historia contada otra vez doscientas diecisiete veces.&lt;/p&gt;

&lt;p&gt;Arrastre = &lt;code&gt;1 − 141 574.50 / 18 024 682.50&lt;/code&gt; = &lt;strong&gt;99.215 %&lt;/strong&gt;.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;No es un 95 %. Es un 99.2 %. La diferencia importa: un 95 % todavía admite la fantasía de que el 5 % restante&lt;br&gt;
—«el trabajo real»— sea donde está la palanca. Un 99.2 % dice que no hay tal 5 %.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2&gt;
  
  
  3 · Cómo se reproduce (esto es la parte que se cobra)
&lt;/h2&gt;

&lt;p&gt;El reporte no es una opinión con tablas. Es un instrumento determinista sobre evidencia del propio disco:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git cat-file blob bb7190b0 &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; /tmp/ttr.json           &lt;span class="c"&gt;# el crudo de atribución, congelado por blob&lt;/span&gt;
.venv/bin/python tools/reporte_tokens.py --ttr /tmp/ttr.json --md-out /tmp/panel.md   &lt;span class="c"&gt;# RC 150 = nominal&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;La corrida de verificación del 30-Oct-2026 reproduce &lt;code&gt;18 024 682.50&lt;/code&gt; y &lt;code&gt;141 574.50&lt;/code&gt; &lt;strong&gt;exactamente&lt;/strong&gt;, desde el&lt;br&gt;
blob &lt;code&gt;bb7190b0&lt;/code&gt; y no desde un archivo temporal perdido. Un lector tercero puede hacer lo mismo sin pedirnos&lt;br&gt;
nada.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Por qué esto es la parte comercial y no la técnica:&lt;/strong&gt; cualquier proveedor puede decir «optimizamos tu&lt;br&gt;
contexto». Lo que casi nadie puede hacer es entregar el comando con el que el cliente comprueba la cifra en su&lt;br&gt;
propia máquina.&lt;/p&gt;

&lt;h2&gt;
  
  
  4 · La trampa del porcentaje: tres denominadores, tres verdades
&lt;/h2&gt;

&lt;p&gt;Aquí está el hallazgo que convierte el artículo en algo que no existe en la literatura de agentes: &lt;strong&gt;el mismo&lt;br&gt;
ahorro mide tres cifras distintas según contra qué se divida&lt;/strong&gt;, y casi todo el material publicado no declara el&lt;br&gt;
denominador.&lt;/p&gt;

&lt;p&gt;Caso medido: recortar el bloque de esquemas de herramientas del perfil de 73 a 22 herramientas.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;contra qué se divide&lt;/th&gt;
&lt;th&gt;cifra&lt;/th&gt;
&lt;th&gt;lectura honesta&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;el bloque de esquemas del perfil que lo protagoniza&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;57.9 %&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;«recorté el bloque un 58 %»&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;el &lt;code&gt;input&lt;/code&gt; de ese mismo perfil&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;15.4 %&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;«ahorré el 15 % del input»&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;el &lt;code&gt;input&lt;/code&gt; de &lt;strong&gt;todo&lt;/strong&gt; el corpus&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;8.73 %&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;«ahorré el 8.7 % del gasto»&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Las tres son ciertas. Solo la tercera es «del total», y es la más pequeña. Un proveedor que publica la primera&lt;br&gt;
como si fuera la tercera está vendiendo un número con el sujeto cambiado — y ese error es indistinguible de una&lt;br&gt;
mentira en el contrato, aunque no haya intención.&lt;/p&gt;

&lt;p&gt;El tax ponderado real del bloque de esquemas es &lt;strong&gt;730 356 952 / 2 472 640 471 = 29.54 %&lt;/strong&gt; del input&lt;br&gt;
(&lt;code&gt;REPORTE_TOKENS.md:142-160&lt;/code&gt;, suma sobre llamadas). Casi un tercio del dinero se va en declarar herramientas.&lt;/p&gt;

&lt;h2&gt;
  
  
  5 · Y la poda no es lineal: el tax depende del conjunto, no del número
&lt;/h2&gt;

&lt;p&gt;La intuición de mercado —«menos herramientas, menos coste»— es &lt;strong&gt;falsa&lt;/strong&gt;, y se refuta con el mismo panel:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;herramientas expuestas&lt;/th&gt;
&lt;th&gt;
&lt;code&gt;tool_tokens&lt;/code&gt; por llamada&lt;/th&gt;
&lt;th&gt;n&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;98&lt;/td&gt;
&lt;td&gt;26 109.00&lt;/td&gt;
&lt;td&gt;343&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;97&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;25 818.00&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;933&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;94&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;32 768.00&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;22&lt;/td&gt;
&lt;td&gt;9 464.00&lt;/td&gt;
&lt;td&gt;416&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;21&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;9 173.88&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;205&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;locus: &lt;code&gt;REPORTE_TOKENS.md:147-160&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Menos herramientas (94) cuestan &lt;strong&gt;26.9 % más&lt;/strong&gt; que más herramientas (97). Y una herramienta menos que 22 (o sea&lt;br&gt;
21) cuesta &lt;strong&gt;3.07 % menos&lt;/strong&gt;. El tax lo fija el &lt;strong&gt;contenido&lt;/strong&gt; del bloque —qué esquemas, con qué descripción y qué&lt;br&gt;
esquema JSON—, no su longitud en unidades.&lt;/p&gt;

&lt;p&gt;Consecuencia para quien vaya a comprar esto: la pregunta correcta no es «¿a cuántas herramientas podamos?» sino&lt;br&gt;
&lt;strong&gt;«¿qué conjunto, medido, para qué tarea?»&lt;/strong&gt;. Un contrato que prometa un porcentaje por umbral de cardinal está&lt;br&gt;
prometiendo algo que el corpus no sostiene.&lt;/p&gt;

&lt;h2&gt;
  
  
  6 · Lo que este artículo NO afirma (y por qué decirlo lo hace vendible)
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;No afirma coste por fila.&lt;/strong&gt; El 99.2 % es la &lt;strong&gt;mediana de un panel de 200 commits evaluados&lt;/strong&gt;, con 10 tareas
atribuidas. La atribución por enlace existe pero es residual: &lt;code&gt;por_enlace = 1&lt;/code&gt;, &lt;code&gt;por_ventana = 199&lt;/code&gt;
(&lt;code&gt;REPORTE_TOKENS.md:69&lt;/code&gt;). &lt;strong&gt;No podemos decirle a un cliente «tu tarea cuesta X»&lt;/strong&gt;. Podemos decirle «la tarea
mediana de este panel cuesta 18.02 M». Es un dashboard de flota, no un recibo por servicio, y el recibo es
el producto que falta.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No afirma ahorro monetario.&lt;/strong&gt; El campo &lt;code&gt;cost&lt;/code&gt; del runtime viaja con &lt;code&gt;isByok: true&lt;/code&gt;: un &lt;code&gt;0.0&lt;/code&gt; ahí significa
«no facturado a esta cuenta», no «gratis». Sin tarifas no hay euros (&lt;code&gt;REPORTE_TOKENS.md&lt;/code&gt; §8).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No afirma routing.&lt;/strong&gt; La comparación de modelos por coste está &lt;code&gt;NO_MEDIDO&lt;/code&gt; por la misma razón.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Publicar los límites no debilita el artículo: &lt;strong&gt;es la única forma de que las tres cifras que sí se afirman sean&lt;br&gt;
creíbles.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  7 · Cierre
&lt;/h2&gt;

&lt;p&gt;El sector mide tokens como quien mide gasolina: litros consumidos. La diferencia entre eso y economía es saber&lt;br&gt;
&lt;strong&gt;cuántos de esos litros movieron el coche y cuántos se quemaron en el semáforo&lt;/strong&gt;. En un agente, el semáforo es&lt;br&gt;
el contexto reenviado, y en esta medición son &lt;strong&gt;99.2 de cada 100 litros&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Quien no mide el arrastre no está optimizando un agente: está eligiendo un motor más pequeño para un coche que&lt;br&gt;
no avanza.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Evidencia completa y reproducible:&lt;/strong&gt; &lt;code&gt;REPORTE_TOKENS.md&lt;/code&gt; · &lt;strong&gt;Instrumento:&lt;/strong&gt; &lt;code&gt;tools/reporte_tokens.py&lt;/code&gt; (RC 150&lt;br&gt;
nominal) · &lt;strong&gt;Crudo congelado:&lt;/strong&gt; &lt;code&gt;crudos/reporte_ttr_20261030.json @ bb7190b0&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  8 · La cifra tiene fecha (y la razón no)
&lt;/h2&gt;

&lt;p&gt;Este artículo se escribió sobre una &lt;strong&gt;generación&lt;/strong&gt; del crudo, y hay que decirlo con número porque el defecto es&lt;br&gt;
la especialidad de la casa: el productor escanea el &lt;code&gt;session-state&lt;/code&gt; del host, que &lt;strong&gt;crece mientras se escribe&lt;/strong&gt;,&lt;br&gt;
así que dos corridas del mismo comando el mismo día &lt;strong&gt;no&lt;/strong&gt; dan las mismas medianas.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;generación&lt;/th&gt;
&lt;th&gt;blob del crudo&lt;/th&gt;
&lt;th&gt;
&lt;code&gt;T_total&lt;/code&gt; mediana&lt;/th&gt;
&lt;th&gt;
&lt;code&gt;T_completion&lt;/code&gt; mediana&lt;/th&gt;
&lt;th&gt;llamadas&lt;/th&gt;
&lt;th&gt;arrastre&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;§2 de este artículo&lt;/td&gt;
&lt;td&gt;&lt;code&gt;bb7190b0&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;18 024 682.50&lt;/td&gt;
&lt;td&gt;141 574.50&lt;/td&gt;
&lt;td&gt;217.50&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;99.215 %&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;vigente, en el repo&lt;/td&gt;
&lt;td&gt;&lt;code&gt;03e9072b&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;23 105 392.50&lt;/td&gt;
&lt;td&gt;167 397.00&lt;/td&gt;
&lt;td&gt;276.50&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;99.276 %&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;salto entre las dos&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;+28.19 %&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;+18.24 %&lt;/td&gt;
&lt;td&gt;+27.13 %&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;+0.061 pp&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Esa fila del salto es la tesis del artículo medida contra sí misma.&lt;/strong&gt; El absoluto se mueve un &lt;strong&gt;28.19 %&lt;/strong&gt; según&lt;br&gt;
cuándo se corra el comando; la &lt;strong&gt;razón se mueve 0.061 puntos porcentuales&lt;/strong&gt;. Es exactamente por esto que el&lt;br&gt;
número que se vende es una proporción y no un total: &lt;strong&gt;una proporción sobrevive a la regeneración, un total no.&lt;/strong&gt;&lt;br&gt;
Las dos generaciones dan &lt;strong&gt;99.2 %&lt;/strong&gt; y &lt;strong&gt;99.3 %&lt;/strong&gt; — y en ningún caso el &lt;strong&gt;95 %&lt;/strong&gt; que circulaba. Una de las cuatro&lt;br&gt;
columnas de §2, &lt;code&gt;tokens por llamada = 80 032.00&lt;/code&gt;, es idéntica en las dos generaciones: la mediana de una razón&lt;br&gt;
se queda quieta aunque sus dos operandos se muevan.&lt;/p&gt;

&lt;p&gt;Dos consecuencias que no se esconden:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;REPORTE_TOKENS.md:185-188&lt;/code&gt; quedó superado por su propio sidecar, y ya se corrigió allí.&lt;/strong&gt; El sidecar del
crudo (&lt;code&gt;crudos/reporte_ttr_20261030.meta.json&lt;/code&gt;) declaró, en el mismo
árbol, que «la primera generación publicó &lt;code&gt;18024682.5 / 141574.5&lt;/code&gt; y esta publica &lt;code&gt;23105392.5 / 167397.0&lt;/code&gt;» y
que «la cifra que vale es la del crudo con su blob». La tabla §7 del reporte publicaba la primera: se midió y
se corrigió en &lt;code&gt;REPORTE_TOKENS.md&lt;/code&gt; (&lt;strong&gt;commit &lt;code&gt;45917cec&lt;/code&gt;&lt;/strong&gt;), donde hoy vive en &lt;code&gt;:188-197 @ blob bc67c4c5&lt;/code&gt; y
publica &lt;code&gt;23 105 392.50 / 167 397.00&lt;/code&gt;. El locus de §2 no estaba mal escrito: era correcto para el blob que cita
—&lt;code&gt;1c09a667&lt;/code&gt;, 213 líneas— y lo desplazó el commit vecino &lt;code&gt;6d74da06&lt;/code&gt;, que movió la tabla a &lt;code&gt;189-192&lt;/code&gt; antes de
que la corrección la dejara en &lt;code&gt;190-193&lt;/code&gt;. &lt;strong&gt;Este apartado no reescribe §2&lt;/strong&gt;: §2 se deja tal como se escribió,
con su generación congelada y su blob, para que la diferencia entre las dos sea auditable en vez de invisible.
Es &lt;strong&gt;adenda, no reemplazo&lt;/strong&gt; — ahora con el cierre fechado, no con la deuda abierta.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Quien corra el comando hoy obtendrá una tercera cifra.&lt;/strong&gt; La cifra no es el producto; &lt;strong&gt;el comando lo es&lt;/strong&gt;.
Por eso §3 entrega el comando y el blob, no la tabla.&lt;/li&gt;
&lt;/ol&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — y la compuerta que los emite se mueve a mano, sin llamadas de red, en &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>productivity</category>
      <category>opensource</category>
    </item>
    <item>
      <title>El contador que sobrevive a su ventana</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Fri, 13 Nov 2026 02:39:27 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/el-contador-que-sobrevive-a-su-ventana-3p2</link>
      <guid>https://dev.to/alexisromtz7/el-contador-que-sobrevive-a-su-ventana-3p2</guid>
      <description>&lt;p&gt;&lt;strong&gt;Un PR en LiteLLM destapó un defecto de metrología —un sensor cuya marca de tiempo no&lt;br&gt;
declara su origen— y de paso algo peor: los dos únicos veredictos que recibió fueron de bots.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Medición: 2026-11-10 · sujeto &lt;code&gt;BerriAI/litellm&lt;/code&gt; · PR #50808 @ &lt;code&gt;18:09Z&lt;/code&gt;&lt;/em&gt;&lt;/p&gt;


&lt;h2&gt;
  
  
  1. El defecto
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;parallel_request_limiter_v3.py&lt;/code&gt; mantiene un espejo local de los contadores de rate limit,&lt;br&gt;
además de Redis. El espejo guarda la entrada con un &lt;strong&gt;TTL anclado en la escritura&lt;/strong&gt;, no en el&lt;br&gt;
inicio de la ventana. Consecuencia: la entrada sobrevive a su propia ventana hasta&lt;br&gt;
&lt;code&gt;window_size&lt;/code&gt; segundos.&lt;/p&gt;

&lt;p&gt;Leída tal cual, esa cifra sigue respondiendo &lt;code&gt;OVER_LIMIT&lt;/code&gt; después de que la ventana giró.&lt;br&gt;
El código original hacía exactamente eso, en tres sitios:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="c1"&gt;# antes&lt;/span&gt;
&lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nb"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;_local_counter_states&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;counters&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El parche introduce una lectura que &lt;strong&gt;declara ausente&lt;/strong&gt; al contador de una ventana ya expirada:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;expired&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;window_start&lt;/span&gt; &lt;span class="k"&gt;is&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="kc"&gt;None&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;now_int&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;window_start&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="nb"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;window_size&lt;/span&gt;
&lt;span class="n"&gt;states&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;window_start&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;None&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;expired&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;window_start&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;counter_value&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Y lo aplica en los tres caminos: la comprobación local previa dentro de&lt;br&gt;
&lt;code&gt;should_rate_limit&lt;/code&gt;, y los dos &lt;em&gt;fallbacks&lt;/em&gt; a espejo local de&lt;br&gt;
&lt;code&gt;_read_counter_values_without_incrementing&lt;/code&gt; (sin Redis, y cuando el script Lua falla).&lt;/p&gt;

&lt;p&gt;La clave del arreglo es qué &lt;strong&gt;no&lt;/strong&gt; hace: no resetea nada. El giro de ventana pertenece al script&lt;br&gt;
Lua y a &lt;code&gt;_in_memory_cache_sliding_window&lt;/code&gt;; el espejo local sólo &lt;em&gt;lee&lt;/em&gt;. Un espejo que además&lt;br&gt;
reseteara tendría dos dueños del mismo estado, y ese es otro bug esperando su turno.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Por qué esto es metrología, no lógica
&lt;/h2&gt;

&lt;p&gt;El contador no mentía. El número era correcto: habían entrado 2000 tokens. Lo que estaba mal era&lt;br&gt;
&lt;strong&gt;la ventana a la que el número se atribuía&lt;/strong&gt;. Dos orígenes de tiempo distintos —la escritura y el&lt;br&gt;
inicio de ventana— colapsados en una sola variable.&lt;/p&gt;

&lt;p&gt;Es la misma clase de defecto que un instrumento de laboratorio que marca la hora del muestreo en&lt;br&gt;
lugar de la hora del evento: la lectura es exacta, el eje está desplazado, y toda conclusión que se&lt;br&gt;
saque de ella está desplazada también.&lt;/p&gt;

&lt;p&gt;El sentido del fallo importa. Un contador rancio &lt;strong&gt;no&lt;/strong&gt; deja pasar tráfico que debería bloquear:&lt;br&gt;
bloquea tráfico que ya está dentro de cuota. Es un falso rojo que te auto-deniega el servicio, con&lt;br&gt;
la agravante de que el cliente recibe un &lt;code&gt;429&lt;/code&gt; con una ventana que ya expiró. Nadie va a poder&lt;br&gt;
reproducirlo mirando el &lt;code&gt;429&lt;/code&gt;: el estado que lo causó ya no existe cuando llega el reclamo.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. La prueba que lo falsa (y la que lo habría dejado pasar)
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;tests/unit/proxy/hooks/test_parallel_request_limiter_v3.py&lt;/code&gt; añade&lt;br&gt;
&lt;code&gt;test_stale_local_counter_does_not_block_after_window_roll&lt;/code&gt;. Tres momentos:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;momento&lt;/th&gt;
&lt;th&gt;aserción&lt;/th&gt;
&lt;th&gt;qué falsa&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;tras consumir 2000 de 1000 en ventana de 60 s&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;read_only&lt;/code&gt; → &lt;code&gt;OVER_LIMIT&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;que el arreglo sea «ignorar el espejo local»&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;advance(61)&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;overall_code == "OK"&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;que el contador rancio siga bloqueando&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;después del giro&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;limit_remaining == 999&lt;/code&gt; y contador local &lt;code&gt;== 1&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;que el giro efectivamente reseteó y admitió una unidad&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;La primera fila es la que casi nadie escribe. Un arreglo que devolviera &lt;code&gt;[]&lt;/code&gt; en el espejo local&lt;br&gt;
pasaría las filas 2 y 3 —y también habría roto el rate limiting por completo—. La aserción&lt;br&gt;
&lt;code&gt;OVER_LIMIT&lt;/code&gt; &lt;strong&gt;dentro&lt;/strong&gt; de la ventana es la que exige que la deuda se cobre antes de condonarla.&lt;/p&gt;

&lt;p&gt;Regla general: toda prueba de un arreglo de «esto ya no debería pasar» necesita además una&lt;br&gt;
aserción de que &lt;em&gt;lo que sí debía pasar sigue pasando&lt;/em&gt;. Sin ella, el test verde es compatible con&lt;br&gt;
haber borrado la funcionalidad.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. El estado del PR, medido con fecha
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;campo&lt;/th&gt;
&lt;th&gt;lectura @ &lt;code&gt;2026-11-10T18:09Z&lt;/code&gt;
&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;estado&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;OPEN&lt;/code&gt;, base &lt;code&gt;main&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;edad&lt;/td&gt;
&lt;td&gt;15 h 52 min (a las 11:38Z eran 9 h 21 min)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;diff&lt;/td&gt;
&lt;td&gt;+60 / −5, 2 archivos, 1 commit&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;labels&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;reviews&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;review requests&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;comentarios&lt;/td&gt;
&lt;td&gt;2 — &lt;code&gt;CLAassistant&lt;/code&gt; &lt;a class="mentioned-user" href="https://dev.to/02"&gt;@02&lt;/a&gt;:17:01Z y &lt;code&gt;veria-ai[bot]&lt;/code&gt; &lt;a class="mentioned-user" href="https://dev.to/02"&gt;@02&lt;/a&gt;:17:08Z&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;humanos que comentaron&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;mergeable&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;true&lt;/code&gt; &lt;a class="mentioned-user" href="https://dev.to/11"&gt;@11&lt;/a&gt;:38Z → &lt;code&gt;UNKNOWN&lt;/code&gt; &lt;a class="mentioned-user" href="https://dev.to/18"&gt;@18&lt;/a&gt;:09Z&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Dos detalles de esa tabla merecen nombrarse.&lt;/p&gt;

&lt;p&gt;El primero: &lt;strong&gt;la edad del PR es una medición que caduca&lt;/strong&gt;. Cualquier titular que escriba «el parche&lt;br&gt;
de 9 horas» es verdad durante unas horas y falso para siempre. Si un número no se puede volver a&lt;br&gt;
medir igual, va con su marca de tiempo o no va.&lt;/p&gt;

&lt;p&gt;El segundo: &lt;code&gt;mergeable&lt;/code&gt; pasó de &lt;code&gt;true&lt;/code&gt; a &lt;code&gt;UNKNOWN&lt;/code&gt; en siete horas sin que nadie tocara la rama.&lt;br&gt;
Ese campo es una caché de GitHub, no un veredicto. Es, otra vez, un sensor cuyo valor no es estado&lt;br&gt;
del objeto. Quien mergee leyendo ese campo está leyendo la caché.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Los dos veredictos
&lt;/h2&gt;

&lt;p&gt;A los 6 segundos del alta, &lt;code&gt;CLAassistant&lt;/code&gt; registró el estado de la firma. Es un gate, no una&lt;br&gt;
revisión: tiene nombre y juicio, pero no lee el código.&lt;/p&gt;

&lt;p&gt;A los 13 segundos, &lt;code&gt;veria-ai[bot]&lt;/code&gt; emitió un veredicto de seguridad sobre el diff. En un PR cuyo&lt;br&gt;
contenido es un cambio de aritmética temporal en un limitador de cuota, un bot certificó «sin&lt;br&gt;
problemas de seguridad» sin inspeccionar la propiedad que el cambio toca: ¿qué pasa si&lt;br&gt;
&lt;code&gt;window_start&lt;/code&gt; es &lt;code&gt;None&lt;/code&gt;? ¿si el reloj retrocede? ¿si &lt;code&gt;window_size&lt;/code&gt; es menor que la latencia entre&lt;br&gt;
las dos lecturas de &lt;code&gt;now_int&lt;/code&gt;?&lt;/p&gt;

&lt;p&gt;Ninguna de esas preguntas la hace un bot que mira el diff. Y ninguna la hizo ningún humano, porque&lt;br&gt;
no hubo ninguno.&lt;/p&gt;

&lt;p&gt;Esto no es un reproche a LiteLLM, que no tiene obligación de revisar el PR de un desconocido en 16&lt;br&gt;
horas. Es una observación sobre el estado de la señal: en un repositorio de ~30 000 estrellas, el&lt;br&gt;
único veredicto automatizado que existe sobre un cambio de lógica es un gate de firma y un&lt;br&gt;
«sin problemas de seguridad» emitido por un servicio cuyo criterio no es auditable desde el PR.&lt;br&gt;
Un verde así no distingue «revisado y limpio» de «no revisado». Vale lo mismo que un &lt;code&gt;0&lt;/code&gt; que&lt;br&gt;
significa «no se midió».&lt;/p&gt;

&lt;p&gt;La consecuencia práctica para quien mantiene esto: &lt;strong&gt;el número de revisiones humanas de un PR es&lt;br&gt;
una métrica que conviene medir explícitamente&lt;/strong&gt;, porque su valor por defecto ya no es 0 de forma&lt;br&gt;
obvia —está decorado con comentarios, labels y checks—. Un PR sin humanos se ve, en la interfaz,&lt;br&gt;
igual de «atendido» que uno revisado.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Nota al pie: por qué no auditamos Gitleaks
&lt;/h2&gt;

&lt;p&gt;El impulso natural, teniendo un censo de umbrales numéricos, es pasárselo a un escáner de secretos:&lt;br&gt;
es el dominio donde un umbral mal puesto cuesta caro. La medición dice que no.&lt;/p&gt;

&lt;p&gt;Gitleaks está escrito en Go. Su árbol tiene &lt;strong&gt;un solo archivo &lt;code&gt;.py&lt;/code&gt;, de 769 bytes&lt;/strong&gt;: un hook de&lt;br&gt;
pre-commit. El universo del censo —archivos Python— está vacío. Un censo que devuelve cero&lt;br&gt;
hallazgos ahí no midió nada; y publicar ese cero como «limpio» sería el falso verde de manual.&lt;/p&gt;

&lt;p&gt;El escaneo de secretos, que sí es agnóstico al lenguaje, tampoco transfiere. Su clase positiva&lt;br&gt;
—cadenas con forma de credencial— &lt;strong&gt;es el fixture del propio sujeto&lt;/strong&gt;: &lt;code&gt;config/gitleaks.toml&lt;/code&gt; es&lt;br&gt;
el recetario del detector y coincide con lo que el detector busca. Sobre los objetos de su&lt;br&gt;
historia, 777 de 6 057 blobs casan con el patrón (12,8 %), y el grueso de esos aciertos son las&lt;br&gt;
versiones sucesivas de su propio fichero de reglas. En el repositorio donde el patrón se escribió,&lt;br&gt;
el mismo patrón dispara 0–4 veces.&lt;/p&gt;

&lt;p&gt;La lección, transferible: &lt;strong&gt;un instrumento sólo es admisible en un sujeto si la clase que busca es&lt;br&gt;
rara en ese sujeto&lt;/strong&gt;. Cuando la clase positiva es el fixture, el instrumento mide el recetario.&lt;br&gt;
Y ahí la respuesta correcta es &lt;code&gt;NO_MEDIDO&lt;/code&gt;, no «sin hallazgos».&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Tres reglas
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Toda marca de tiempo declara su origen.&lt;/strong&gt; Un TTL anclado en la escritura y una ventana
anclada en el inicio de la ventana son dos relojes. Si el código los usa indistintamente,
el error no está en el cálculo: está en el eje.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Un sensor que sobrevive a su sujeto no es un sensor.&lt;/strong&gt; Si la entrada vive más que el objeto
que describe, la lectura correcta de «expirado» es &lt;em&gt;ausente&lt;/em&gt;, no &lt;em&gt;cero&lt;/em&gt; —y desde luego no &lt;em&gt;el
último valor conocido&lt;/em&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Un verde no dice quién lo emitió.&lt;/strong&gt; Antes de leer un check como señal, pregunta si su autor
podía fallar. Un gate de firma y un bot que nunca ha bloqueado nada son, para efectos de
confianza, el mismo objeto.&lt;/li&gt;
&lt;/ol&gt;




&lt;p&gt;&lt;em&gt;Sujeto: &lt;code&gt;BerriAI/litellm&lt;/code&gt; PR #50808 («fix(rate-limit): stop a stale counter blocking after its&lt;br&gt;
window rolled»), issue #47340. Todas las cifras de este texto se midieron el 2026-11-10 y se pueden&lt;br&gt;
volver a medir con &lt;code&gt;gh pr view 50808 --repo BerriAI/litellm&lt;/code&gt; y &lt;code&gt;gh pr diff 50808 --repo&lt;br&gt;
BerriAI/litellm&lt;/code&gt;. La edad del PR, mañana, será otra.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt;&lt;/p&gt;

</description>
      <category>litellm</category>
      <category>metrologia</category>
      <category>bots</category>
      <category>codereview</category>
    </item>
    <item>
      <title>Auditar un escáner de secretos con un escáner de secretos no mide nada</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Fri, 13 Nov 2026 02:38:04 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/auditar-un-escaner-de-secretos-con-un-escaner-de-secretos-no-mide-nada-3f5o</link>
      <guid>https://dev.to/alexisromtz7/auditar-un-escaner-de-secretos-con-un-escaner-de-secretos-no-mide-nada-3f5o</guid>
      <description>&lt;p&gt;Tenía dos instrumentos recién construidos, los dos con su banco de pruebas en&lt;br&gt;
verde, y un repositorio de código abierto que quería auditar. El primero censa&lt;br&gt;
umbrales numéricos absolutos en código Python. El segundo busca credenciales&lt;br&gt;
comprometidas en el historial de git. Los corrí contra el objetivo y los dos&lt;br&gt;
devolvieron &lt;strong&gt;cero hallazgos&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Cero hallazgos suena a que el repositorio está limpio. Los dos instrumentos no&lt;br&gt;
habían mirado nada, y esa es una diferencia que ningún código de salida te dice.&lt;/p&gt;

&lt;p&gt;Lo que sigue es el registro de cómo se detecta eso en segundos, sin red y sin&lt;br&gt;
ejecutar el objetivo. No es un artículo sobre dos herramientas concretas: es&lt;br&gt;
sobre el paso que casi todo el mundo se salta antes de creerse un número.&lt;/p&gt;

&lt;h2&gt;
  
  
  El error de encuadre
&lt;/h2&gt;

&lt;p&gt;Cuando un escáner devuelve cero, la reacción por defecto es auditar la&lt;br&gt;
herramienta: revisar reglas, subir la sensibilidad, añadir patrones. Es tiempo&lt;br&gt;
perdido si el problema es anterior.&lt;/p&gt;

&lt;p&gt;Hay dos preguntas distintas y se contestan en orden:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;¿El sujeto admite este instrumento?&lt;/strong&gt; Es una pregunta sobre el objeto.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;¿El instrumento mide bien?&lt;/strong&gt; Es una pregunta sobre la herramienta.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Si la primera sale mal, la segunda no tiene sentido. Un termómetro perfecto&lt;br&gt;
aplicado a una pared mide la pared.&lt;/p&gt;

&lt;h2&gt;
  
  
  Forma 1 · universo vacío
&lt;/h2&gt;

&lt;p&gt;El primer instrumento recorre árboles sintácticos de Python. El objetivo resultó&lt;br&gt;
ser un proyecto escrito en Go.&lt;/p&gt;

&lt;p&gt;La cuenta exacta: &lt;strong&gt;769 archivos versionados, de los cuales 1 es &lt;code&gt;.py&lt;/code&gt; y pesa&lt;br&gt;
769 bytes.&lt;/strong&gt; El instrumento corrió, recorrió su universo, no encontró nada que&lt;br&gt;
analizar y devolvió cero.&lt;/p&gt;

&lt;p&gt;Ese cero tiene un nombre técnico: es el tamaño del universo, no el recuento de&lt;br&gt;
defectos. Un censo sobre un universo vacío no es un censo con resultado cero;&lt;br&gt;
es la ausencia de censo. Y sin embargo el código de salida era indistinguible de&lt;br&gt;
un repositorio revisado y limpio.&lt;/p&gt;

&lt;p&gt;Esa indistinción es el defecto. No el cero: la &lt;strong&gt;forma&lt;/strong&gt; del cero.&lt;/p&gt;

&lt;h2&gt;
  
  
  Forma 2 · clase dominante
&lt;/h2&gt;

&lt;p&gt;El segundo instrumento busca formas de credencial. Es un escáner de secretos&lt;br&gt;
aplicado a un escáner de secretos. Suena a buena idea: ¿quién mejor para tener&lt;br&gt;
secretos filtrados que una herramienta que vive de detectarlos?&lt;/p&gt;

&lt;p&gt;Antes de correrlo medí la densidad de la clase positiva en el sujeto. Es una&lt;br&gt;
división de dos números: cuántos archivos del repositorio casan el patrón,&lt;br&gt;
partido por cuántos archivos hay.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;777 de 6 057 blobs. El 12,8 %.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Y el motivo es obvio en cuanto se mira: el archivo &lt;code&gt;config/gitleaks.toml&lt;/code&gt; de ese&lt;br&gt;
repositorio es el recetario de reglas del propio detector. Contiene, por&lt;br&gt;
construcción, todos los patrones que el instrumento busca, escritos en la&lt;br&gt;
sintaxis que el instrumento entiende. El fixture &lt;strong&gt;es&lt;/strong&gt; la clase positiva.&lt;/p&gt;

&lt;p&gt;La consecuencia operativa es la que importa: en el repositorio donde ese patrón&lt;br&gt;
se escribió, el patrón dispara entre 0 y 4 veces. En el repositorio que lo&lt;br&gt;
define, dispara 777 veces. La misma regla, el mismo instrumento, dos sujetos&lt;br&gt;
distintos, y un solo resultado interpretable.&lt;/p&gt;

&lt;p&gt;Un escáner de secretos auditando un escáner de secretos no produce falsos&lt;br&gt;
positivos. Produce una medición sin denominador.&lt;/p&gt;

&lt;h2&gt;
  
  
  Por qué el fixture envenena la medición
&lt;/h2&gt;

&lt;p&gt;Un fixture es un caso de prueba. Un caso de prueba de un detector de secretos&lt;br&gt;
tiene que contener secretos, o no prueba nada. Eso es correcto y necesario&lt;br&gt;
dentro del fixture.&lt;/p&gt;

&lt;p&gt;El problema aparece cuando el instrumento no distingue el fixture del código&lt;br&gt;
productivo. Ahí la clase positiva está sembrada por el propio diseño del sujeto,&lt;br&gt;
y la tasa de detección deja de medir la salud del repositorio para medir la&lt;br&gt;
coherencia del recetario consigo mismo.&lt;/p&gt;

&lt;p&gt;Dos formas de no medir, entonces, y las dos devuelven un número plausible:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;forma&lt;/th&gt;
&lt;th&gt;qué se mide en realidad&lt;/th&gt;
&lt;th&gt;resultado típico&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;universo vacío&lt;/td&gt;
&lt;td&gt;el tamaño del sujeto, no sus defectos&lt;/td&gt;
&lt;td&gt;cero hallazgos&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;clase dominante&lt;/td&gt;
&lt;td&gt;la coherencia del recetario consigo mismo&lt;/td&gt;
&lt;td&gt;tasa altísima&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Ninguna de las dos se arregla ajustando el instrumento.&lt;/p&gt;

&lt;h2&gt;
  
  
  La compuerta: dos predicados, cero ejecución
&lt;/h2&gt;

&lt;p&gt;La solución no es un umbral más fino. Es una compuerta que corre &lt;strong&gt;antes&lt;/strong&gt; del&lt;br&gt;
instrumento y contesta la pregunta 1.&lt;/p&gt;

&lt;p&gt;Dos predicados, medibles en segundos y sin red:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Universo vacío.&lt;/strong&gt; ¿Cuántos archivos del lenguaje que el instrumento entiende
hay en el sujeto? Si el universo es vacío o despreciable, el veredicto no es
«limpio»: es &lt;code&gt;UNIVERSO_VACIO&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Clase dominante.&lt;/strong&gt; ¿Qué fracción del sujeto casa la clase positiva? Si pasa
del techo declarado, el veredicto es &lt;code&gt;CLASE_DOMINANTE&lt;/code&gt;. El techo no se adivina:
se declara antes de medir y se escribe junto al resultado.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Un techo razonable para código productivo es el 5 %. El propio banco de pruebas&lt;br&gt;
de la compuerta sobre un corpus real de herramientas internas casa en el 18,3 %,&lt;br&gt;
lo cual sirve para lo único que debe servir un banco de pruebas: demostrar que el&lt;br&gt;
techo muerde de verdad y que no está ahí de adorno.&lt;/p&gt;

&lt;p&gt;Y un tercer estado que muchos instrumentos omiten y que es el más importante:&lt;br&gt;
&lt;strong&gt;&lt;code&gt;SUJETO_ILEGIBLE&lt;/code&gt;&lt;/strong&gt;. Si el sujeto no se puede leer —clon incompleto, ruta&lt;br&gt;
inexistente, permisos—, el veredicto no puede ser «admisible» por defecto. Falla&lt;br&gt;
cerrado.&lt;/p&gt;

&lt;p&gt;Los tres veredictos son &lt;code&gt;ADMISIBLE&lt;/code&gt;, &lt;code&gt;UNIVERSO_VACIO&lt;/code&gt;, &lt;code&gt;CLASE_DOMINANTE&lt;/code&gt;, más el&lt;br&gt;
&lt;code&gt;SUJETO_ILEGIBLE&lt;/code&gt; que corta antes. Sólo el primero autoriza a correr el&lt;br&gt;
instrumento y a creerse el número que devuelva.&lt;/p&gt;

&lt;h2&gt;
  
  
  Por qué esto te sirve aunque no audites nada
&lt;/h2&gt;

&lt;p&gt;La trampa no es de seguridad. Es de cualquier medición automática.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Un linter de estilo configurado sobre un directorio que el glob no alcanza
devuelve cero violaciones. El glob es el universo.&lt;/li&gt;
&lt;li&gt;Un informe de cobertura sobre un paquete que los tests nunca importaron
devuelve 0 % de líneas sin cubrir. La importación es el universo.&lt;/li&gt;
&lt;li&gt;Un benchmark que corre su propio dataset de calibración mide su calibración.
El dataset es la clase dominante.&lt;/li&gt;
&lt;li&gt;Una búsqueda de malas prácticas en un repositorio que contiene el documento
que las prescribe encuentra el documento, no las prácticas.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;En los cuatro casos el instrumento está bien y el número es verdadero. Lo que&lt;br&gt;
está mal es la inferencia que se hace con él.&lt;/p&gt;

&lt;h2&gt;
  
  
  Tres reglas que se llevan a cualquier parte
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1 · El cero de un universo vacío no es un cero.&lt;/strong&gt;&lt;br&gt;
Un recuento sobre conjuntos vacíos no cuenta defectos. Si tu instrumento puede&lt;br&gt;
devolver cero sin haber recorrido nada, tu cero no distingue «limpio» de «no&lt;br&gt;
miré», y esa indistinción se propaga a cada decisión que tomes con él.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2 · La densidad de la clase positiva se declara antes de medir.&lt;/strong&gt;&lt;br&gt;
No después, cuando el resultado ya te incomoda. Un techo escrito en el momento en&lt;br&gt;
que ves el número es una racionalización con formato de parámetro.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3 · Falla cerrado cuando el sujeto no se puede leer.&lt;/strong&gt;&lt;br&gt;
&lt;code&gt;SUJETO_ILEGIBLE&lt;/code&gt; no es &lt;code&gt;ADMISIBLE&lt;/code&gt;. Un instrumento que, ante la duda, deja&lt;br&gt;
pasar, no es un instrumento: es un sello.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cierre
&lt;/h2&gt;

&lt;p&gt;El repositorio no estaba limpio ni sucio: no era un sujeto. Los dos instrumentos&lt;br&gt;
eran correctos y los dos devolvieron cero, y ninguna de esas dos cosas tenía&lt;br&gt;
relación con la pregunta que yo quería contestar.&lt;/p&gt;

&lt;p&gt;La compuerta que lo detecta cuesta segundos y no toca la red. Lo caro no era&lt;br&gt;
medir: era creerse el número antes de haber preguntado si el sujeto admitía la&lt;br&gt;
medición.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Nota del método:&lt;/strong&gt; los códigos de retorno que uso aquí están indexados con su causa declarada y la huella que los sella en &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt;&lt;/p&gt;

</description>
      <category>metrologia</category>
      <category>seguridad</category>
      <category>staticanalysis</category>
      <category>tooling</category>
    </item>
    <item>
      <title>The $6.3B hack was not a code bug</title>
      <dc:creator>Alexis Román</dc:creator>
      <pubDate>Mon, 09 Nov 2026 17:44:14 +0000</pubDate>
      <link>https://dev.to/alexisromtz7/the-63b-hack-was-not-a-code-bug-on9</link>
      <guid>https://dev.to/alexisromtz7/the-63b-hack-was-not-a-code-bug-on9</guid>
      <description>&lt;p&gt;&lt;strong&gt;Where the figures come from:&lt;/strong&gt; my own measurement, reproducible. Every figure in this article has its commit; the&lt;br&gt;
breakdown by code is further down, not in an appendix.&lt;/p&gt;




&lt;h2&gt;
  
  
  What is confirmed, and what the press is still arguing about
&lt;/h2&gt;

&lt;p&gt;Between October 29 and 30, eight outlets published the same fact: the largest theft in the history of&lt;br&gt;
cryptocurrency, between &lt;strong&gt;$6.3 and $6.4 billion&lt;/strong&gt;, with TRM Labs attributing it to North Korea. An Ethereum upgrade,&lt;br&gt;
&lt;strong&gt;EIP-7702&lt;/strong&gt;, appears in every piece: it lets an account delegate its signing capability to another contract. With&lt;br&gt;
that delegation signed, hot wallets were drained.&lt;/p&gt;

&lt;p&gt;So far, the headline. Now the part almost nobody is publishing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Cryptonews, October 30:&lt;/strong&gt; «EIP-7702 didn't cause Binance hack, but may have amplified losses».&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CCN, October 30:&lt;/strong&gt; «$3.66B Was Stolen Without It».&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CryptoTicker, October 29:&lt;/strong&gt; «$2.8B Drained From Hot Wallet via EIP-7702».&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Added up, those three pieces say something uncomfortable: &lt;strong&gt;most of the money was lost without the upgrade&lt;br&gt;
being involved&lt;/strong&gt;. If that holds, then EIP-7702 is not the cause. It is the amplifier.&lt;/p&gt;

&lt;p&gt;And a fourth piece, from the same day, closes the circle from the other side: &lt;strong&gt;The News International&lt;/strong&gt; headlines that&lt;br&gt;
Binance «confirms advanced EIP-7702 exploits and compromised DevOps laptop». That is: that the vector came through a&lt;br&gt;
&lt;strong&gt;compromised engineer machine&lt;/strong&gt; is not this article's hypothesis — the exchange itself confirmed it. The fact is not&lt;br&gt;
mine; the angle is.&lt;/p&gt;

&lt;p&gt;All four headlines were verified on October 30, 2026 with publication date and outlet; none is quoted from&lt;br&gt;
memory.&lt;/p&gt;

&lt;p&gt;And if it is not the cause, the right question is not «what primitive failed?». It is: &lt;strong&gt;who could sign?&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  The hole is the chain of authority, not the line of code
&lt;/h2&gt;

&lt;p&gt;A code audit looks for the error in the program. The incident points elsewhere: an engineer's machine with&lt;br&gt;
signing and deployment capability, and a delegation that turns one signature into permanent authority. None of that&lt;br&gt;
lives in a badly written line. It lives in the &lt;strong&gt;chain of authority&lt;/strong&gt;: which identity can publish, with which token,&lt;br&gt;
from which artifact, and with how many factors.&lt;/p&gt;

&lt;p&gt;That is not a hypothesis about cryptocurrency. It is the structure of any modern deployment. And it can be measured.&lt;/p&gt;




&lt;h2&gt;
  
  
  We measured it in our own house first
&lt;/h2&gt;

&lt;p&gt;We have an instrument that audits the authority surface of GitHub Actions: who has write permission and at the same&lt;br&gt;
time executes code, who can publish through OIDC and at the same time builds the artifact, which actions come in by&lt;br&gt;
movable tag, where secrets travel inline.&lt;/p&gt;

&lt;p&gt;We ran it against our own repository, before running it against anyone else's.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Result: 8 findings, &lt;code&gt;RC 1&lt;/code&gt; (&lt;code&gt;FINDINGS&lt;/code&gt;).&lt;/strong&gt; Six were from the same workflow. The three that matter:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;That workflow declares &lt;code&gt;pages: write&lt;/code&gt; + &lt;code&gt;id-token: write&lt;/code&gt; &lt;strong&gt;at the root&lt;/strong&gt;, not on the deployment job. Every job
inherits it, including the one that compiles.&lt;/li&gt;
&lt;li&gt;It comes in through &lt;strong&gt;four floating tags&lt;/strong&gt; (&lt;code&gt;@v4&lt;/code&gt;, &lt;code&gt;@v5&lt;/code&gt;, &lt;code&gt;@v3&lt;/code&gt;, &lt;code&gt;@v4&lt;/code&gt;). A tag is a movable reference: whoever can
move it executes code inside the perimeter that can publish.&lt;/li&gt;
&lt;li&gt;The deploy job consumes the OIDC token without consuming an artifact built separately: &lt;strong&gt;it builds and signs in the
same context&lt;/strong&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;None of the three pieces is dramatic on its own. &lt;strong&gt;The conjunction is the finding&lt;/strong&gt;: a publishing token inherited&lt;br&gt;
by every job, plus four entry doors that somebody else can move.&lt;/p&gt;

&lt;p&gt;Run time: &lt;strong&gt;1.2 seconds&lt;/strong&gt;. Zero tokens. Without installing anything in the audited repository.&lt;/p&gt;




&lt;h2&gt;
  
  
  And then we fixed it, because a report with no fix is an invoice
&lt;/h2&gt;

&lt;p&gt;This is where most audits end and where this article should start to differentiate itself.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;First move — fix.&lt;/strong&gt; Root permissions cut to &lt;code&gt;contents: read&lt;/code&gt;. &lt;code&gt;pages: write&lt;/code&gt; and &lt;code&gt;id-token: write&lt;/code&gt; drop&lt;br&gt;
to the &lt;code&gt;deploy&lt;/code&gt; job, where they are exercised. The workflow splits into two jobs with &lt;code&gt;needs:&lt;/code&gt;: one builds and uploads&lt;br&gt;
the artifact, the other publishes, and &lt;strong&gt;the one that publishes no longer has the repository code on its disk&lt;/strong&gt;. The&lt;br&gt;
four floating refs become full SHAs. And a &lt;code&gt;download-artifact&lt;/code&gt; appears that did not exist before: the gate had demanded&lt;br&gt;
it from the start and we were right not to believe the first green — without that step, the whole artifact is a sink&lt;br&gt;
for the instrument, because no step in the job declares it as an input.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Second move — measure again.&lt;/strong&gt; 8 findings → &lt;strong&gt;3&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Third move — the one almost nobody makes: do not delete the residue, declare it.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The 3 that remain are not bugs. Two are the corpus &lt;code&gt;keepalive&lt;/code&gt;: a job that needs &lt;code&gt;contents: write&lt;/code&gt; because its&lt;br&gt;
work &lt;strong&gt;is&lt;/strong&gt; to run &lt;code&gt;git push --dry-run&lt;/code&gt;. Taking the write away does not close a hole: it turns off the keepalive. The&lt;br&gt;
third is the write grant for the &lt;code&gt;deploy&lt;/code&gt; job, which now really is where it is used.&lt;/p&gt;

&lt;p&gt;The obvious temptation is to silence the instrument. Add an exclusion list, a &lt;code&gt;# noqa&lt;/code&gt;, a filter. That turns the audit&lt;br&gt;
into theater: the next real finding comes in through the same door we just opened.&lt;/p&gt;

&lt;p&gt;What we did instead was an &lt;strong&gt;adjudication registry&lt;/strong&gt;: a file where each exception is written with its code, its&lt;br&gt;
workflow, its job and &lt;strong&gt;the record that authorizes it&lt;/strong&gt;. The instrument reads that registry and demands two things a&lt;br&gt;
filter cannot give:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Zero orphans.&lt;/strong&gt; A row that no longer matches any finding is reported as an error. A registry that only
grows is a graveyard of exceptions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Adjudication does not delete the finding.&lt;/strong&gt; The finding stays in the JSON, with its severity, its &lt;code&gt;job&lt;/code&gt; and its
&lt;code&gt;motivo&lt;/code&gt;. What changes is the verdict of the repository: from &lt;code&gt;FINDINGS&lt;/code&gt; to &lt;code&gt;ADJUDICADO&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Result: &lt;code&gt;RC 0&lt;/code&gt;, &lt;code&gt;ADJUDICADO&lt;/code&gt;, zero orphans.&lt;/strong&gt; And when the instrument finds something again that is not in the&lt;br&gt;
registry, it goes red again. &lt;em&gt;That&lt;/em&gt; is what a &lt;code&gt;# noqa&lt;/code&gt; cannot do.&lt;/p&gt;

&lt;p&gt;This is the commercial point, and it is worth saying without decoration: &lt;strong&gt;the deliverable is not a number of&lt;br&gt;
findings. It is a number of findings that moves, and a residue with a name and a record.&lt;/strong&gt; Anyone can run a scanner&lt;br&gt;
and hand you 29 violations. What almost nobody delivers is the proof that the 29 dropped to 3, why those 3 are still&lt;br&gt;
there, and who signed each one.&lt;/p&gt;




&lt;h2&gt;
  
  
  And in somebody else's project, 21 findings
&lt;/h2&gt;

&lt;p&gt;On an active open source project (≈11 workflows), the same instrument returned &lt;strong&gt;21 findings&lt;/strong&gt;: a release job&lt;br&gt;
with &lt;code&gt;contents: write&lt;/code&gt;, &lt;code&gt;pull-requests: write&lt;/code&gt; and &lt;code&gt;id-token: write&lt;/code&gt; that also runs the build in the same context, and&lt;br&gt;
a bot token passed inline to a third-party action.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;And here comes the part almost no security vendor writes:&lt;/strong&gt; that job only fires on &lt;code&gt;push&lt;/code&gt; to &lt;code&gt;main&lt;/code&gt;,&lt;br&gt;
inside an &lt;code&gt;if&lt;/code&gt; that requires being the repository owner. &lt;strong&gt;There is no untrusted input.&lt;/strong&gt; The finding is &lt;em&gt;structural,&lt;br&gt;
not exploitable&lt;/em&gt;. Publishing «secret exposed in a public repo» would have been technically true on the surface and&lt;br&gt;
false in the risk.&lt;/p&gt;

&lt;p&gt;That distinction —&lt;strong&gt;structural ≠ exploitable&lt;/strong&gt;— is the difference between a report a CISO can use and one they have&lt;br&gt;
to shut off.&lt;/p&gt;

&lt;p&gt;And that foreign repo was not cloned. &lt;code&gt;--repo owner/name&lt;/code&gt; resolves the name before the first call, reads the workflows&lt;br&gt;
through a read-only API and publishes the exact commit it measured (&lt;code&gt;6c9ca431&lt;/code&gt;). &lt;strong&gt;Not one write to somebody else's&lt;br&gt;
disk, not one extra token.&lt;/strong&gt; If measuring someone's house requires copying their code, it is not a measurement: it is&lt;br&gt;
a move.&lt;/p&gt;




&lt;h2&gt;
  
  
  Ten repositories, ten measurements, none silent
&lt;/h2&gt;

&lt;p&gt;One case is not a sample. Ten public repositories, all with at least one workflow whose name publishes or deploys&lt;br&gt;
something. The inclusion criterion is declared before measuring, not after: &lt;strong&gt;a repository enters the batch if it has a&lt;br&gt;
deployment or publishing workflow&lt;/strong&gt;.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Repository&lt;/th&gt;
&lt;th&gt;Measured commit&lt;/th&gt;
&lt;th&gt;Findings&lt;/th&gt;
&lt;th&gt;Conjunction of authority&lt;/th&gt;
&lt;th&gt;Verdict&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;withastro/starlight&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;6c9ca431&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;21&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;withastro/astro&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;10dae2f3&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;51&lt;/td&gt;
&lt;td&gt;19&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vercel/next.js&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;4fed142e&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;181&lt;/td&gt;
&lt;td&gt;36&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;nuxt/nuxt&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;363f3b87&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;59&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;sveltejs/svelte&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;fe21fce0&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;remix-run/remix&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;2eb9249c&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;170&lt;/td&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;angular/angular&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;458303fe&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;26&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vuejs/core&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;24c9d0bf&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;11&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;facebook/react&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;16453bcd&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;234&lt;/td&gt;
&lt;td&gt;11&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;vitejs/vite&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;90bc034a&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;42&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;td&gt;&lt;code&gt;RC 1&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Total&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;10 commits&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;807&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;115&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;10 of 10&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two repositories from the original list were left out, and saying so is part of the method: &lt;code&gt;gatsbyjs/gatsby&lt;/code&gt; has no&lt;br&gt;
deployment or publishing workflow at all (one only, and it is not a deploy one) — it is declared &lt;code&gt;NO_APLICA&lt;/code&gt; and&lt;br&gt;
replaced by &lt;code&gt;vitejs/vite&lt;/code&gt;. &lt;code&gt;astro-build/astro&lt;/code&gt; does not exist: the correct organization is &lt;code&gt;withastro&lt;/code&gt;, and&lt;br&gt;
&lt;code&gt;withastro/astro&lt;/code&gt; was measured.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;And here is the part a scanner vendor does not write: 807 are not 807 vulnerabilities.&lt;/strong&gt; They are 807&lt;br&gt;
observations of the YAML surface. Of those, &lt;strong&gt;115 are the conjunction this article defends&lt;/strong&gt; — write authority that&lt;br&gt;
executes, authority inherited from the root, or missing root permissions. The other &lt;strong&gt;692&lt;/strong&gt; split without decoration:&lt;br&gt;
&lt;strong&gt;308&lt;/strong&gt; movable refs (real hygiene), &lt;strong&gt;153&lt;/strong&gt; scope reviews that contract SC-1 marks as &lt;code&gt;REVIEW&lt;/code&gt;,&lt;br&gt;
&lt;strong&gt;3&lt;/strong&gt; root reads under review, and &lt;strong&gt;228&lt;/strong&gt; from &lt;strong&gt;two codes of the instrument itself that detect the mechanism, not the&lt;br&gt;
defect&lt;/strong&gt;. &lt;code&gt;SECRETO_EXPUESTO&lt;/code&gt; flags any &lt;code&gt;${{ secrets.* }}&lt;/code&gt; in an &lt;code&gt;env:&lt;/code&gt;, which is &lt;em&gt;the correct way&lt;/em&gt; to pass a&lt;br&gt;
secret to a step; and &lt;code&gt;SUMIDERO_IMPUDO&lt;/code&gt; flags a job with &lt;code&gt;id-token: write&lt;/code&gt; that runs &lt;code&gt;actions/checkout&lt;/code&gt;, which is what&lt;br&gt;
&lt;strong&gt;every&lt;/strong&gt; publishing job has to do to have something to publish. Publishing the raw number would have been the&lt;br&gt;
same sin we criticize three paragraphs above, with the sign flipped.&lt;/p&gt;

&lt;p&gt;The full table, with the breakdown by code and the exact commit of each measurement, is the one above: ten rows, ten commits, none silent. The batch record keeps the ten SHAs and the criterion they were chosen with.&lt;/p&gt;




&lt;h2&gt;
  
  
  What this instrument does NOT measure
&lt;/h2&gt;

&lt;p&gt;Saying it is part of the contract, not a clause at the foot of the page:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Default permissions&lt;/strong&gt; of &lt;code&gt;GITHUB_TOKEN&lt;/code&gt; at repository or organization level: invisible from the YAML.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;OIDC policies of the destination&lt;/strong&gt; (npm, PyPI, AWS): the instrument sees that there is a door, not which lock it has.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dependency modification at runtime&lt;/strong&gt; when non-isolated native code runs.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Reusable workflows (&lt;code&gt;workflow_call&lt;/code&gt;) and composite actions hosted in foreign repositories.&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Runtime.&lt;/strong&gt; It measures the declared surface of the YAML; it does not certify what happens when it runs.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;An instrument that does not declare its blindness is not an instrument: it is an opinion with a JSON format.&lt;/p&gt;




&lt;h2&gt;
  
  
  The falsifier
&lt;/h2&gt;

&lt;p&gt;This thesis dies in two ways, and both are measurable:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;If in &lt;strong&gt;10 repositories with deployment workflows&lt;/strong&gt; the instrument does not find &lt;strong&gt;a single&lt;/strong&gt; conjunction of inherited
authority with movable doors, then there is no market: the problem does not exist outside our house.&lt;/li&gt;
&lt;li&gt;If it finds &lt;strong&gt;10 of 10&lt;/strong&gt;, then the finding stops being a finding and becomes the norm — and the product is no
longer the scan (which anyone runs in a second), but the &lt;strong&gt;remediation&lt;/strong&gt; and the evidence that it was done.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Neither of the two is a defeat. Both force you to stop selling «audit» and start selling «this got&lt;br&gt;
closed, and here is the proof».&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The falsifier has already been exercised, and the comfortable branch did not come out.&lt;/strong&gt; Ten repositories, ten&lt;br&gt;
measurements: &lt;strong&gt;10 of 10 have at least one conjunction of authority&lt;/strong&gt; (minimum 2, in &lt;code&gt;sveltejs/svelte&lt;/code&gt;; maximum 36, in&lt;br&gt;
&lt;code&gt;vercel/next.js&lt;/code&gt;). There is not a single repository in the batch where the problem does not exist.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;And the measurement found a hole in the falsifier, not in the thesis.&lt;/strong&gt; The text said «conjunction of inherited&lt;br&gt;
authority &lt;strong&gt;with&lt;/strong&gt; movable doors», and that conjunction admits three readings. All three are published:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Reading of the falsifier&lt;/th&gt;
&lt;th&gt;Repositories that satisfy it&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;A&lt;/strong&gt; — at least one conjunction of authority (criterion declared in the evidence)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;10 of 10&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;B&lt;/strong&gt; — conjunction of authority &lt;strong&gt;and&lt;/strong&gt; at least one &lt;code&gt;uses:&lt;/code&gt; with a movable tag&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;6 of 10&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;C&lt;/strong&gt; — write authority inherited &lt;strong&gt;from the root&lt;/strong&gt; and movable tag&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;4 of 10&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;No reading gives zero.&lt;/strong&gt; The first branch of the falsifier —«if it does not find a single one, there is no market»—&lt;br&gt;
is refuted under all three. But the second is not reached clean either: only reading &lt;strong&gt;A&lt;/strong&gt; gets to 10 of 10. The&lt;br&gt;
falsifier was written with two branches and a hole in the middle, and that hole was filled by the measurement, not by&lt;br&gt;
rhetoric. The honest version of the falsifier is not binary: it is &lt;strong&gt;a threshold&lt;/strong&gt; — «if fewer than half of the&lt;br&gt;
repositories with deployment show the conjunction, the problem is not structural, and this falls». Measured: 4 of 10&lt;br&gt;
under the strictest reading. &lt;strong&gt;It does not fall, and barely.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;That resolves the thesis to the &lt;strong&gt;second&lt;/strong&gt; branch under the declared reading, and it has to be said with the same&lt;br&gt;
clarity used for our own finding: &lt;strong&gt;the conjunction of authority is not a rarity; it is the norm of the ecosystem.&lt;/strong&gt; If&lt;br&gt;
it is the norm, the scan is not a product — anyone runs it in a second, and ours is not billed for speed either.&lt;br&gt;
&lt;strong&gt;What is scarce is closure:&lt;/strong&gt; that the number goes down, that the residue has a name and a record, and that the next&lt;br&gt;
scan can prove it did not go back up.&lt;/p&gt;

&lt;p&gt;The branch that kills the thesis would have been the first. The second came out. &lt;strong&gt;The product that survives this&lt;br&gt;
measurement is the one already described in the 8 → 3 → 0 section, not the one described in the headline.&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  If you want to know where your single signing point is
&lt;/h2&gt;

&lt;p&gt;You do not need to install anything or give us access to your code. A repository name is enough: the instrument reads&lt;br&gt;
the declared surface of your workflows and returns, in seconds, how many jobs concentrate publishing authority and how&lt;br&gt;
many of their inputs somebody else can move.&lt;/p&gt;

&lt;p&gt;If the result is «there is no declared chain of authority», that is the finding: absence is published too.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Do you want the measurement on your repository? Leave the name (&lt;code&gt;owner/repo&lt;/code&gt;) in the comments of this article and I&lt;br&gt;
will publish the count in the same thread: how many jobs concentrate publishing authority, and how many of their&lt;br&gt;
inputs somebody else can move. Without cloning your code, without asking you for a key, without installing anything on&lt;br&gt;
your machine.&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Read on dev.to. The canonical version of this piece, with the full measurement and the command that reproduces the number: &lt;a href="https://alexisromtz-lab.github.io/la-auditora/portafolio/articulos/en/el-hackeo-de-6-3b-no-fue-un-bug-de-codigo/?utm_source=devto&amp;amp;utm_medium=article&amp;amp;utm_campaign=the-63b-hack-was-not-a-code-bug-on9" rel="noopener noreferrer"&gt;the full article&lt;/a&gt; · Code and scripts: &lt;a href="https://github.com/alexisromtz-lab/la-auditora" rel="noopener noreferrer"&gt;github.com/alexisromtz-lab/la-auditora&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;A note on method:&lt;/strong&gt; the return codes I use here are indexed with their declared cause and the fingerprint that seals them at &lt;a href="https://indice-rc.vercel.app" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app&lt;/a&gt; — and the gate that emits them can be driven by hand, with no network calls, at &lt;a href="https://indice-rc.vercel.app/simulador.html" rel="noopener noreferrer"&gt;https://indice-rc.vercel.app/simulador.html&lt;/a&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>devops</category>
      <category>supplychain</category>
      <category>opensource</category>
    </item>
  </channel>
</rss>
