@legios/quartermaster 0.1.13 → 0.1.15
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +11 -7
- package/bin/qm-barra.swift +95 -2
- package/bin/qm-indicator +115 -6
- package/bin/qm-tray +10 -0
- package/bin/qm-tray.ps1 +154 -4
- package/bin/qm.mjs +25 -0
- package/dist/adapters/barra.js +129 -13
- package/dist/adapters/barra.js.map +1 -1
- package/dist/cli/qm.js +22 -9
- package/dist/cli/qm.js.map +1 -1
- package/dist/render/barras.js +19 -2
- package/dist/render/barras.js.map +1 -1
- package/extension/gnome43/quartermaster@legios/metadata.json +1 -1
- package/extension/quartermaster@legios/metadata.json +1 -1
- package/package.json +1 -1
- package/scripts/gate-lazo.py +396 -0
- package/scripts/hacer-cambios.mjs +0 -0
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@legios/quartermaster",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.15",
|
|
4
4
|
"description": "Cuánta cuota te queda en TODOS los perfiles de Claude Code de la máquina, más Codex y los proveedores de opencode. Sin red y sin credenciales: el número sale del cache que Claude Code deja en disco.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"claude-code",
|
|
@@ -0,0 +1,396 @@
|
|
|
1
|
+
"""El calentado no puede dejar de ocurrir en silencio.
|
|
2
|
+
|
|
3
|
+
EL CASO. El 2026-09-15, con 0.1.13 recién publicada, el indicador de GNOME de
|
|
4
|
+
esta máquina dejó de preguntarle al endpoint a las 02:35 y estuvo SIETE HORAS Y
|
|
5
|
+
MEDIA sin escribir una sola línea. Medido, no supuesto: el proceso vivo,
|
|
6
|
+
`estado.json` reescrito hacía un minuto, `endpoint.json` e `historial.jsonl`
|
|
7
|
+
congelados a las 02:35, y el log al día —un `pedido` mandado a mano aparecía al
|
|
8
|
+
instante—. No fue la suspensión, que es el caso que el código ya contempla:
|
|
9
|
+
CLOCK_BOOTTIME y CLOCK_MONOTONIC daban lo mismo y la máquina llevaba 14 h de
|
|
10
|
+
uptime continuo. Forzar un `refrescar()`, que es lo que rearma el calentado, no
|
|
11
|
+
lo revivió en diez minutos con la cadencia en un techo de cinco.
|
|
12
|
+
|
|
13
|
+
Lo que mostraba mientras tanto, contra lo que decía el servidor:
|
|
14
|
+
|
|
15
|
+
mostraba main ~0/30% · teams ~0/29% · codex ~0/30%
|
|
16
|
+
endpoint main 7/31% · teams 10/30% · codex 0/30%
|
|
17
|
+
|
|
18
|
+
El `~` estaba —no mentía— pero un monitor que deja de monitorear sin decirlo es
|
|
19
|
+
exactamente el bug del que nació este repo.
|
|
20
|
+
|
|
21
|
+
LA FORMA, que es lo que se comprueba acá. El calentado se rearmaba desde UN solo
|
|
22
|
+
lugar: el final de `refrescar()`. Cualquier corte en esa cadena lo apagaba para
|
|
23
|
+
toda la vida del proceso, y había un estado —`calentando` en True sin
|
|
24
|
+
`calentando_desde`— que caía en un `else` que rearmaba sin anotar nada. Diez
|
|
25
|
+
vueltas del temporizador, cero líneas.
|
|
26
|
+
|
|
27
|
+
Se comprueban las tres defensas, manejando los callbacks a mano como se los
|
|
28
|
+
haría correr GLib, sin levantar interfaz:
|
|
29
|
+
|
|
30
|
+
1. una bandera pegada SIN instante se trata como pegada: se anota y se suelta;
|
|
31
|
+
2. el vigía, que no depende del calentado ni del sondeo, anota el atraso una
|
|
32
|
+
vez y lo destraba;
|
|
33
|
+
3. el sondeo periódico sobrevive a una excepción de `refrescar()`: la anota y
|
|
34
|
+
devuelve True, porque un callback de GLib que no devuelve un valor
|
|
35
|
+
verdadero se queda sin fuente y se lleva el lazo puesto.
|
|
36
|
+
"""
|
|
37
|
+
|
|
38
|
+
import importlib.machinery
|
|
39
|
+
import importlib.util
|
|
40
|
+
import os
|
|
41
|
+
import pathlib
|
|
42
|
+
import re
|
|
43
|
+
import shutil
|
|
44
|
+
import subprocess
|
|
45
|
+
import sys
|
|
46
|
+
import tempfile
|
|
47
|
+
|
|
48
|
+
RAIZ = pathlib.Path(__file__).resolve().parent.parent
|
|
49
|
+
|
|
50
|
+
for _s in (sys.stdout, sys.stderr):
|
|
51
|
+
try:
|
|
52
|
+
_s.reconfigure(encoding="utf-8", errors="replace")
|
|
53
|
+
except (AttributeError, ValueError):
|
|
54
|
+
pass
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def cargar():
|
|
58
|
+
spec = importlib.util.spec_from_loader(
|
|
59
|
+
"qmi", importlib.machinery.SourceFileLoader("qmi", str(RAIZ / "bin/qm-indicator")))
|
|
60
|
+
m = importlib.util.module_from_spec(spec)
|
|
61
|
+
spec.loader.exec_module(m)
|
|
62
|
+
return m
|
|
63
|
+
|
|
64
|
+
|
|
65
|
+
class RelojFalso:
|
|
66
|
+
"""GLib de mentira: no corre nada, anota qué se armó. El reloj avanza a mano."""
|
|
67
|
+
|
|
68
|
+
def __init__(self):
|
|
69
|
+
self.armados = []
|
|
70
|
+
self.ahora = 10_000 * 1_000_000
|
|
71
|
+
self.vivas = {}
|
|
72
|
+
|
|
73
|
+
def avanzar(self, segundos):
|
|
74
|
+
self.ahora += segundos * 1_000_000
|
|
75
|
+
|
|
76
|
+
def get_monotonic_time(self):
|
|
77
|
+
return self.ahora
|
|
78
|
+
|
|
79
|
+
def timeout_add_seconds(self, seg, _fn):
|
|
80
|
+
self.armados.append(seg)
|
|
81
|
+
idc = len(self.armados)
|
|
82
|
+
self.vivas[idc] = self.ahora + seg * 1_000_000
|
|
83
|
+
return idc
|
|
84
|
+
|
|
85
|
+
def timeout_add(self, _ms, _fn):
|
|
86
|
+
return 1
|
|
87
|
+
|
|
88
|
+
def source_remove(self, idc):
|
|
89
|
+
self.vivas.pop(idc, None)
|
|
90
|
+
return True
|
|
91
|
+
|
|
92
|
+
|
|
93
|
+
def banco(m):
|
|
94
|
+
"""Un Indicador sin interfaz, con el estado que se quiera."""
|
|
95
|
+
ind = object.__new__(m.Indicador)
|
|
96
|
+
ind.calentando = False
|
|
97
|
+
ind.calentando_desde = None
|
|
98
|
+
ind.reloj = None
|
|
99
|
+
ind.proxima_lectura = None
|
|
100
|
+
ind.piezas = []
|
|
101
|
+
ind.minutos_al_techo = None
|
|
102
|
+
ind._ultimo_calentado = None
|
|
103
|
+
ind._vigia_avisado = False
|
|
104
|
+
ind._fallo_calentado = None
|
|
105
|
+
ind._motivos_calentado = set()
|
|
106
|
+
ind.qm = "/bin/true"
|
|
107
|
+
return ind
|
|
108
|
+
|
|
109
|
+
|
|
110
|
+
def correr(prueba):
|
|
111
|
+
"""Devuelve (renglones anotados, temporizadores armados)."""
|
|
112
|
+
m = cargar()
|
|
113
|
+
anotado = []
|
|
114
|
+
m.registrar = lambda evento, **d: anotado.append(
|
|
115
|
+
evento + ("" if not d else " " + " ".join(
|
|
116
|
+
f"{k}={v}" for k, v in d.items() if v is not None)))
|
|
117
|
+
reloj = RelojFalso()
|
|
118
|
+
m.GLib = reloj
|
|
119
|
+
prueba(m, banco(m), reloj)
|
|
120
|
+
return anotado, reloj.armados
|
|
121
|
+
|
|
122
|
+
|
|
123
|
+
def bandera_pegada(m, ind, _reloj):
|
|
124
|
+
ind.calentando = True
|
|
125
|
+
ind.calentando_desde = None
|
|
126
|
+
for _ in range(10):
|
|
127
|
+
m.Indicador.calentar(ind)
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
def vigia_con_atraso(m, ind, reloj):
|
|
131
|
+
ind.calentando = True
|
|
132
|
+
ind._ultimo_calentado = reloj.get_monotonic_time() - 1800 * 1_000_000
|
|
133
|
+
# Con un temporizador armado y su fecha YA VENCIDA, que es el estado real de
|
|
134
|
+
# un calentado parado: la guarda anti-hambre ve que cualquier fecha nueva es
|
|
135
|
+
# «más lejos» y, sin forzar, no rearmaría nada. La defensa contra el hambre
|
|
136
|
+
# apagaría a la defensa contra el silencio.
|
|
137
|
+
ind.reloj = 99
|
|
138
|
+
ind.proxima_lectura = reloj.get_monotonic_time() - 600 * 1_000_000
|
|
139
|
+
for _ in range(3):
|
|
140
|
+
m.Indicador._vigia(ind)
|
|
141
|
+
|
|
142
|
+
|
|
143
|
+
def hambre(m, ind, reloj):
|
|
144
|
+
"""El sondeo empatado con la cadencia: ¿llega a vencer el calentado?
|
|
145
|
+
|
|
146
|
+
Es el caso REAL: `cadencia()` devuelve SEGUNDOS_SONDEO cuando no hay nada
|
|
147
|
+
alto, y `refrescar()` —que corre cada SEGUNDOS_SONDEO— rearma el calentado
|
|
148
|
+
en cada vuelta. Si rearmar ALEJA la fecha, el calentado no vence jamás.
|
|
149
|
+
"""
|
|
150
|
+
ind.piezas = [] # nada alto: cadencia() da el techo
|
|
151
|
+
m.Indicador.programar_calentado(ind) # como el arranque
|
|
152
|
+
for _ in range(12): # doce sondeos = una hora
|
|
153
|
+
reloj.avanzar(m.SEGUNDOS_SONDEO)
|
|
154
|
+
m.Indicador.programar_calentado(ind)
|
|
155
|
+
# ¿Quedó alguna fecha en el pasado? Ésa es la que habría disparado.
|
|
156
|
+
ind.vencio = any(t <= reloj.ahora for t in reloj.vivas.values())
|
|
157
|
+
|
|
158
|
+
|
|
159
|
+
def sondeo_que_revienta(m, ind, _reloj):
|
|
160
|
+
def revienta():
|
|
161
|
+
raise RuntimeError("un refresco cualquiera que falla")
|
|
162
|
+
ind.refrescar = revienta
|
|
163
|
+
ind.devuelto = [m.Indicador._sondear(ind) for _ in range(3)]
|
|
164
|
+
|
|
165
|
+
|
|
166
|
+
def vigia_de_macos() -> list[str]:
|
|
167
|
+
"""El vigía de la barra de macOS, EJECUTADO.
|
|
168
|
+
|
|
169
|
+
Compilar no alcanza: lo que hay que comprobar es que con una lectura
|
|
170
|
+
reciente se calle, que con una vieja avise UNA vez, y que rearme. Se le saca
|
|
171
|
+
el cuerpo a `func vigia()` y se lo envuelve con lo que nombra —el reloj, la
|
|
172
|
+
bandera, `registrar`, `duracion` y `programar`— igual que hace
|
|
173
|
+
gate-duraciones con la escalera.
|
|
174
|
+
"""
|
|
175
|
+
texto = (RAIZ / "bin/qm-barra.swift").read_text(encoding="utf-8")
|
|
176
|
+
i = texto.index(" func vigia() {")
|
|
177
|
+
j = texto.index("\n }\n", i) + len("\n }\n")
|
|
178
|
+
cuerpo = texto[i:j].replace("func vigia()", "func vigia()")
|
|
179
|
+
# `duracion` de verdad, para que la frase sea la que se va a leer.
|
|
180
|
+
dur_i = texto.index("func duracion(_ segundos: Int) -> String {")
|
|
181
|
+
nivel, k = 0, dur_i
|
|
182
|
+
while True:
|
|
183
|
+
if texto[k] == "{":
|
|
184
|
+
nivel += 1
|
|
185
|
+
elif texto[k] == "}":
|
|
186
|
+
nivel -= 1
|
|
187
|
+
if nivel == 0:
|
|
188
|
+
break
|
|
189
|
+
k += 1
|
|
190
|
+
duracion = texto[dur_i:k + 1]
|
|
191
|
+
|
|
192
|
+
# Y `programar()`, que es donde vivía el hambre: rearmar no puede ALEJAR.
|
|
193
|
+
prog_i = texto.index(" func programar(forzando: Bool = false) {")
|
|
194
|
+
nivel, k = 0, prog_i
|
|
195
|
+
while True:
|
|
196
|
+
if texto[k] == "{":
|
|
197
|
+
nivel += 1
|
|
198
|
+
elif texto[k] == "}":
|
|
199
|
+
nivel -= 1
|
|
200
|
+
if nivel == 0:
|
|
201
|
+
break
|
|
202
|
+
k += 1
|
|
203
|
+
programar = texto[prog_i:k + 1].replace("self.calentarCodex()", "calentados += 1")
|
|
204
|
+
# Contar los rearmes DE VERDAD: el stub que los contaba ya no está, porque
|
|
205
|
+
# ahora se ejecuta el `programar()` real —que es justo lo que hay que medir,
|
|
206
|
+
# porque su guarda anti-hambre podía dejar al vigía sin rearmar nada.
|
|
207
|
+
# El contador va donde el rearme OCURRE —justo antes de guardar el timer
|
|
208
|
+
# nuevo— y no al entrar: puesto arriba contaba llamadas, y una llamada que
|
|
209
|
+
# la guarda rechaza no es un rearme. Medido: daba 3 cuando eran 0.
|
|
210
|
+
assert "rearmes" not in programar
|
|
211
|
+
assert programar.count(" reloj = t") == 1
|
|
212
|
+
programar = programar.replace(" reloj = t", " rearmes += 1\n reloj = t", 1)
|
|
213
|
+
|
|
214
|
+
guion = f"""import Foundation
|
|
215
|
+
{duracion}
|
|
216
|
+
let VIGIA_PLAZO: TimeInterval = 20 * 60
|
|
217
|
+
let SEGUNDOS_SONDEO: TimeInterval = 300
|
|
218
|
+
let MINIMO_RED: TimeInterval = 60
|
|
219
|
+
var anotado: [String] = []
|
|
220
|
+
func registrar(_ t: String) {{ anotado.append(t) }}
|
|
221
|
+
var rearmes = 0
|
|
222
|
+
var calentados = 0
|
|
223
|
+
class Barra {{
|
|
224
|
+
var calentadoEn: Date?
|
|
225
|
+
var vigiaAviso = false
|
|
226
|
+
var reloj: Timer?
|
|
227
|
+
var minutosAlTecho: Double? = nil
|
|
228
|
+
func cadencia() -> TimeInterval {{ SEGUNDOS_SONDEO }} // todo tranquilo
|
|
229
|
+
{programar}
|
|
230
|
+
{cuerpo}
|
|
231
|
+
}}
|
|
232
|
+
let b = Barra()
|
|
233
|
+
|
|
234
|
+
// 1 · el vigía
|
|
235
|
+
let v = Barra()
|
|
236
|
+
v.calentadoEn = Date()
|
|
237
|
+
v.vigia()
|
|
238
|
+
print("callado:\\(anotado.isEmpty)")
|
|
239
|
+
v.calentadoEn = Date().addingTimeInterval(-1800)
|
|
240
|
+
v.vigia(); v.vigia(); v.vigia()
|
|
241
|
+
print("avisos:\\(anotado.count)")
|
|
242
|
+
print("rearmes:\\(rearmes)")
|
|
243
|
+
|
|
244
|
+
// 2 · el hambre: refrescar() rearma en cada vuelta y no puede correr la fecha
|
|
245
|
+
b.programar()
|
|
246
|
+
let primera = b.reloj!.fireDate
|
|
247
|
+
for _ in 0..<12 {{ b.programar() }}
|
|
248
|
+
print("alejado:\\(b.reloj!.fireDate > primera)")
|
|
249
|
+
|
|
250
|
+
// 3 · y la guarda no puede dejar al vigía sin rearmar: con una fecha ya agendada,
|
|
251
|
+
// la del vigía es «más lejos» y sin forzar la guarda la rechazaría.
|
|
252
|
+
let c = Barra()
|
|
253
|
+
c.programar() // deja una fecha agendada
|
|
254
|
+
c.calentadoEn = Date().addingTimeInterval(-1800)
|
|
255
|
+
c.vigiaAviso = false
|
|
256
|
+
let antes = rearmes
|
|
257
|
+
c.vigia()
|
|
258
|
+
print("vigiaRearmo:\\(rearmes > antes)")
|
|
259
|
+
"""
|
|
260
|
+
with tempfile.TemporaryDirectory() as d:
|
|
261
|
+
f = pathlib.Path(d) / "v.swift"
|
|
262
|
+
f.write_text(guion, encoding="utf-8")
|
|
263
|
+
r = subprocess.run(["swift", str(f)], capture_output=True, text=True,
|
|
264
|
+
encoding="utf-8", timeout=300)
|
|
265
|
+
if r.returncode != 0:
|
|
266
|
+
# Las últimas líneas, no la última: un error de Swift termina en la
|
|
267
|
+
# línea del fuente y sin las de arriba no dice qué estuvo mal.
|
|
268
|
+
cola = (r.stderr or "swift falló").strip().splitlines()
|
|
269
|
+
errores = [l for l in cola if ": error:" in l] or cola[-4:]
|
|
270
|
+
raise RuntimeError(" / ".join(errores[:3]))
|
|
271
|
+
return r.stdout.strip().splitlines()
|
|
272
|
+
|
|
273
|
+
|
|
274
|
+
def main() -> int:
|
|
275
|
+
fallas = []
|
|
276
|
+
|
|
277
|
+
# Que las defensas EXISTAN, antes de probarlas. Sin esto, una versión que no
|
|
278
|
+
# las tiene sale por un traceback en vez de por un rojo que se pueda leer,
|
|
279
|
+
# y un gate ilegible es medio gate.
|
|
280
|
+
m = cargar()
|
|
281
|
+
for nombre, para_que in (("_vigia", "mirar desde afuera que el calentado siga ocurriendo"),
|
|
282
|
+
("_sondear", "que una excepción del refresco no se lleve la fuente")):
|
|
283
|
+
if not hasattr(m.Indicador, nombre):
|
|
284
|
+
fallas.append(f"no existe `Indicador.{nombre}`, que es lo que hace falta para {para_que}")
|
|
285
|
+
if fallas:
|
|
286
|
+
for f in fallas:
|
|
287
|
+
print(f"GATE ROJO: {f}", file=sys.stderr)
|
|
288
|
+
return 1
|
|
289
|
+
|
|
290
|
+
# 1 · la bandera pegada sin instante
|
|
291
|
+
anotado, _ = correr(bandera_pegada)
|
|
292
|
+
if not any(l.startswith("calentar.colgado") for l in anotado):
|
|
293
|
+
fallas.append("diez vueltas del temporizador con `calentando` pegada y sin instante "
|
|
294
|
+
"no anotaron un solo `calentar.colgado`: ése es el silencio de siete horas")
|
|
295
|
+
if not any(l.startswith("calentar ") for l in anotado):
|
|
296
|
+
fallas.append("después de soltar la bandera pegada el calentado no volvió a ocurrir")
|
|
297
|
+
|
|
298
|
+
# 2 · el vigía
|
|
299
|
+
anotado, armados = correr(vigia_con_atraso)
|
|
300
|
+
parado = [l for l in anotado if l.startswith("calentar.parado")]
|
|
301
|
+
if not parado:
|
|
302
|
+
fallas.append("el vigía no anotó nada con el calentado parado media hora")
|
|
303
|
+
elif len(parado) != 1:
|
|
304
|
+
fallas.append(f"el vigía anotó {len(parado)} veces en tres vueltas: tiene que avisar "
|
|
305
|
+
"una vez por corte, si no el log no se puede leer")
|
|
306
|
+
if not armados:
|
|
307
|
+
fallas.append("el vigía anotó el atraso pero no rearmó el calentado")
|
|
308
|
+
|
|
309
|
+
# 3 · el hambre: el sondeo empatado con la cadencia
|
|
310
|
+
m2 = cargar()
|
|
311
|
+
m2.registrar = lambda *a, **k: None
|
|
312
|
+
reloj2 = RelojFalso()
|
|
313
|
+
m2.GLib = reloj2
|
|
314
|
+
ind2 = banco(m2)
|
|
315
|
+
hambre(m2, ind2, reloj2)
|
|
316
|
+
if not ind2.vencio:
|
|
317
|
+
fallas.append("con el sondeo y la cadencia empatados, doce vueltas de una hora "
|
|
318
|
+
"no dejaron vencer NI UN calentado: cada refresco corría la fecha "
|
|
319
|
+
"más lejos y el calentado no ocurría nunca")
|
|
320
|
+
|
|
321
|
+
# 4 · el vigía arranca con reloj puesto
|
|
322
|
+
fuente = (RAIZ / "bin/qm-indicator").read_text(encoding="utf-8")
|
|
323
|
+
if "self._ultimo_calentado: int | None = GLib.get_monotonic_time()" not in fuente:
|
|
324
|
+
fallas.append("`_ultimo_calentado` arranca en None: si el PRIMER calentado nunca "
|
|
325
|
+
"termina, el vigía no mira nunca y el silencio vuelve")
|
|
326
|
+
swift = (RAIZ / "bin/qm-barra.swift").read_text(encoding="utf-8")
|
|
327
|
+
if "if calentadoEn == nil { calentadoEn = Date() }" not in swift:
|
|
328
|
+
fallas.append("la barra de macOS arma el vigía sin ponerle reloj: mismo agujero")
|
|
329
|
+
if "$script:CalentadoEn = Get-Date" not in (RAIZ / "bin/qm-tray.ps1").read_text(encoding="utf-8"):
|
|
330
|
+
fallas.append("la bandeja de Windows arma el vigía sin ponerle reloj: mismo agujero")
|
|
331
|
+
|
|
332
|
+
# 5 · el sondeo que sobrevive a su propio error
|
|
333
|
+
m = cargar()
|
|
334
|
+
anotado = []
|
|
335
|
+
m.registrar = lambda evento, **d: anotado.append(evento)
|
|
336
|
+
reloj = RelojFalso()
|
|
337
|
+
m.GLib = reloj
|
|
338
|
+
ind = banco(m)
|
|
339
|
+
sondeo_que_revienta(m, ind, reloj)
|
|
340
|
+
if not all(ind.devuelto):
|
|
341
|
+
fallas.append("un `refrescar()` que tira deja al sondeo devolviendo un valor falso: "
|
|
342
|
+
"GLib le saca la fuente y con ella se va el único rearme del calentado")
|
|
343
|
+
if not any(l.startswith("sondeo.reventó") for l in anotado):
|
|
344
|
+
fallas.append("el sondeo se tragó la excepción sin anotarla")
|
|
345
|
+
|
|
346
|
+
# 5 · el vigía de macOS, ejecutado donde haya swiftc
|
|
347
|
+
exigidos = {x for x in os.environ.get("QM_GATE_EXIGE", "").split(",") if x}
|
|
348
|
+
salteado = ""
|
|
349
|
+
if shutil.which("swift") is None:
|
|
350
|
+
if "swift" in exigidos:
|
|
351
|
+
fallas.append("falta swift y este job lo exige: el vigía de la barra de macOS "
|
|
352
|
+
"quedaría sólo compilado, no corrido")
|
|
353
|
+
else:
|
|
354
|
+
salteado = " · salteado: el vigía de macOS (no hay swift en esta máquina)"
|
|
355
|
+
else:
|
|
356
|
+
try:
|
|
357
|
+
crudo = vigia_de_macos()
|
|
358
|
+
dicho = dict(l.split(":", 1) for l in crudo)
|
|
359
|
+
# Lo que dijo, pegado a cada rojo: un gate que dice «no cuadra» sin
|
|
360
|
+
# decir qué contestó obliga a adivinar, y adivinar es lo que este
|
|
361
|
+
# repo no hace.
|
|
362
|
+
fallas_antes = len(fallas)
|
|
363
|
+
if dicho.get("callado") != "true":
|
|
364
|
+
fallas.append("el vigía de macOS avisa con una lectura RECIENTE: cría lobo")
|
|
365
|
+
if dicho.get("avisos") != "1":
|
|
366
|
+
fallas.append(f"el vigía de macOS avisó {dicho.get('avisos')} veces en tres "
|
|
367
|
+
"vueltas: tiene que ser una por corte")
|
|
368
|
+
if dicho.get("rearmes") != "3":
|
|
369
|
+
fallas.append(f"el vigía de macOS rearmó {dicho.get('rearmes')} veces y "
|
|
370
|
+
"tenían que ser 3: avisar sin rearmar no destraba nada")
|
|
371
|
+
if dicho.get("vigiaRearmo") != "true":
|
|
372
|
+
fallas.append("la guarda anti-hambre de macOS deja al vigía sin rearmar: "
|
|
373
|
+
"con la fecha ya vencida, la fecha nueva siempre es «más "
|
|
374
|
+
"lejos» y la defensa contra el hambre apaga a la del silencio")
|
|
375
|
+
if dicho.get("alejado") != "false":
|
|
376
|
+
fallas.append("en macOS, doce refrescos seguidos ALEJAN la fecha del "
|
|
377
|
+
"calentado: con el .claude.json reescribiéndose cada veinte "
|
|
378
|
+
"segundos, el calentado no vence nunca")
|
|
379
|
+
if len(fallas) > fallas_antes:
|
|
380
|
+
fallas.append("lo que contestó el Swift: " + " · ".join(crudo))
|
|
381
|
+
except Exception as e: # noqa: BLE001
|
|
382
|
+
fallas.append(f"no pude correr el vigía de macOS: {e}")
|
|
383
|
+
|
|
384
|
+
if fallas:
|
|
385
|
+
for f in fallas:
|
|
386
|
+
print(f"GATE ROJO: {f}", file=sys.stderr)
|
|
387
|
+
return 1
|
|
388
|
+
print("lazo: la bandera pegada se suelta y se anota, el vigía avisa una vez y rearma, "
|
|
389
|
+
"y el sondeo sobrevive a su propio error")
|
|
390
|
+
if salteado:
|
|
391
|
+
print(salteado)
|
|
392
|
+
return 0
|
|
393
|
+
|
|
394
|
+
|
|
395
|
+
if __name__ == "__main__":
|
|
396
|
+
raise SystemExit(main())
|
|
Binary file
|