@legios/quartermaster 0.1.6 → 0.1.8

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 CHANGED
@@ -49,6 +49,12 @@ brew install legiosai/tap/quartermaster # macOS and Linux
49
49
  npm install -g @legios/quartermaster # anywhere
50
50
  ```
51
51
 
52
+ **The menu bar item on macOS:** the first time you run `qm` in a terminal, it
53
+ asks once whether to put it in the menu bar and start it at every login. The
54
+ install itself can't: brew can't start anything from a formula, and a tool that
55
+ reads OAuth tokens shouldn't register login agents nobody asked for. Without the
56
+ question: `brew services start quartermaster`.
57
+
52
58
  **Windows:** the installer from the [latest
53
59
  release](https://github.com/legiosai/quartermaster/releases/latest). Per-user
54
60
  and no UAC: it puts `qm` on your `PATH`, the tray in the Start menu, and — if
@@ -126,15 +132,51 @@ journalctl --user -b | grep qm-indicator
126
132
  ```
127
133
 
128
134
  ```
135
+ qm-indicator: pedido accion=actualizar
136
+ qm-indicator: calentar cuentas=.claude,.claude-teams,codex
129
137
  qm-indicator: panel.abierto donde=arriba-derecha alto=1032
130
138
  qm-indicator: panel.cerrado vivio_ms=3999
131
139
  qm-indicator: panel.agarre-roto
132
- qm-indicator: calentar cuentas=codex
140
+ qm-indicator: aviso clave=teams|weekly_all|2026-09-13T11:00|80 urgente=False
141
+ qm-indicator: qm.sin-datos motivo=qm salió 2: opción desconocida
133
142
  ```
134
143
 
144
+ The events, and the question each one answers:
145
+
146
+ | event | answers |
147
+ | --- | --- |
148
+ | `pedido` | did the click reach the indicator at all? |
149
+ | `calentar` / `calentar.fallo` | which accounts were re-read, and why a refresh did not happen |
150
+ | `panel.abierto` / `panel.cerrado` | `vivio_ms` — a panel that lived 40 ms was not closed by you |
151
+ | `panel.agarre-roto` | the compositor took the grab away |
152
+ | `aviso` / `aviso.repetido` / `aviso.fallo` | it fired, it was suppressed as a duplicate, or the notification server refused it |
153
+ | `qm.sin-datos` | why there is no number, instead of only a phrase on screen |
154
+ | `reinicio` | the process replaced itself because the source changed |
155
+ | `suspension.duerme` / `.vuelve` | the machine slept, and the quota was re-read on resume |
156
+ | `calentar.colgado` | a warm never called back and its flag was released after the deadline |
157
+
135
158
  `vivio_ms` is the one that matters for "the panel closes on its own": a panel
136
159
  that lives 40 ms was not closed by you. `QM_SILENCIO=1` turns it off.
137
160
 
161
+ **The macOS menu bar writes a log too**, timestamped and capped at 1 MB. With
162
+ brew it is `$(brew --prefix)/var/log/quartermaster.log`:
163
+
164
+ ```
165
+ 2026-09-14T11:40:02-03:00 [qm-barra] arranca · qm=/opt/homebrew/opt/quartermaster/libexec/bin/qm · pid 812
166
+ 2026-09-14T11:40:03-03:00 [qm-barra] posición: ancho=125.0 x=985.0..1110.0 muescaDerechaMinX=825.0 pantalla=1470.0 escondido=false
167
+ 2026-09-14T11:40:04-03:00 [qm-barra] calentar · .claude: sin credencial — corré: …
168
+ 2026-09-14T12:02:10-03:00 [qm-barra] aviso: quartermaster · teams — …
169
+ 2026-09-14T13:15:40-03:00 [qm-barra] calentado (--calentar) falló: salió 1
170
+ 2026-09-14T13:21:41-03:00 [qm-barra] calentado volvió a andar
171
+ ```
172
+
173
+ It writes changes, not repeats: the item's position once per screen when it
174
+ moves, a refresh or a read the first time it fails and again when it recovers,
175
+ why an account was not refreshed (once per reason), and every notification —
176
+ with a line if `osascript` did not show it.
177
+ `escondido=true` is the one to look for when the item does not appear: macOS
178
+ put it under the notch or ran out of room.
179
+
138
180
  ## Where you can see it
139
181
 
140
182
  | | |
@@ -65,6 +65,43 @@ func rutaQm() -> String {
65
65
  return (NSHomeDirectory() as NSString).appendingPathComponent(".local/bin/qm")
66
66
  }
67
67
 
68
+ // ── el log ───────────────────────────────────────────────────────────────
69
+ // Todo lo que la barra tiene para decir va a stderr, que launchd (o `brew
70
+ // services`) manda a un archivo. Antes ahí sólo quedaba dónde se dibujaba el
71
+ // item, sin hora, un renglón por minuto; lo que de verdad importa —un calentado
72
+ // que falla, una lectura que no vuelve, un aviso que no sale— se tiraba. Un
73
+ // calentado roto se veía igual que uno sano: la barra seguía mostrando el
74
+ // número viejo con su edad, y el archivo no decía por qué.
75
+ //
76
+ // Con hora, y con tope: el archivo lo abre launchd y nadie lo rota.
77
+
78
+ let LOG_MAXIMO_BYTES: off_t = 1_000_000
79
+ let colaLog = DispatchQueue(label: "quartermaster.log")
80
+ let horaLog: ISO8601DateFormatter = {
81
+ let f = ISO8601DateFormatter()
82
+ f.formatOptions = [.withInternetDateTime]
83
+ f.timeZone = .current
84
+ return f
85
+ }()
86
+
87
+ func registrar(_ texto: String) {
88
+ let ahora = Date()
89
+ colaLog.async {
90
+ // Sólo se recorta un archivo de verdad: corriendo a mano, stderr es la
91
+ // terminal y no hay nada que recortar.
92
+ var st = stat()
93
+ if fstat(STDERR_FILENO, &st) == 0, (st.st_mode & S_IFMT) == S_IFREG, st.st_size > LOG_MAXIMO_BYTES {
94
+ ftruncate(STDERR_FILENO, 0)
95
+ lseek(STDERR_FILENO, 0, SEEK_SET)
96
+ FileHandle.standardError.write(
97
+ "\(horaLog.string(from: ahora)) [qm-barra] log recortado: pasaba de \(LOG_MAXIMO_BYTES) bytes\n"
98
+ .data(using: .utf8)!)
99
+ }
100
+ let una = texto.replacingOccurrences(of: "\n", with: " / ")
101
+ FileHandle.standardError.write("\(horaLog.string(from: ahora)) [qm-barra] \(una)\n".data(using: .utf8)!)
102
+ }
103
+ }
104
+
68
105
  /// La paleta de estado, la misma del tablero y validada contra los dos fondos
69
106
  /// que puede tener la barra. El color va en la MARCA, nunca en el texto: el
70
107
  /// número se queda con el color de etiqueta del sistema, que se adapta solo.
@@ -375,7 +412,12 @@ func notificar(titulo: String, cuerpo: String) {
375
412
  let p = Process()
376
413
  p.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
377
414
  p.arguments = ["-e", "display notification \"\(limpio(cuerpo))\" with title \"\(limpio(titulo))\""]
378
- try? p.run()
415
+ registrar("aviso: \(titulo) — \(cuerpo)")
416
+ // Si osascript no sale 0 el aviso no se vio, y es el único rastro de eso.
417
+ p.terminationHandler = { t in
418
+ if t.terminationStatus != 0 { registrar("el aviso no salió: osascript salió \(t.terminationStatus)") }
419
+ }
420
+ do { try p.run() } catch { registrar("el aviso no salió: no pude correr osascript: \(error.localizedDescription)") }
379
421
  }
380
422
 
381
423
 
@@ -706,6 +748,14 @@ final class Barra: NSObject, NSApplicationDelegate {
706
748
  /// Lo último que se vio, para decidir cada cuánto volver a mirar.
707
749
  var ultimas: [Trozo] = []
708
750
  var avisoBarraLlena = false
751
+ /// Lo último que se anotó de cada cosa, para anotar CAMBIOS y no repetir:
752
+ /// la posición se revisa en cada redibujo —un renglón por minuto, igual en
753
+ /// cada vuelta— y un calentado roto falla en cada sondeo.
754
+ var ultimaPosicion: [String: String] = [:]
755
+ var ultimaFalla: String?
756
+ var ultimoCalentado: String?
757
+ /// Los motivos por cuenta ya anotados en esta corrida («.claude: sin credencial»).
758
+ var motivosCalentado: Set<String> = []
709
759
  /// `perfil|barra` -> [minuto de reinicio, porcentaje] de la última vuelta.
710
760
  /// Persistido: es lo que permite notar que una ventana se dio vuelta.
711
761
  var previos: [String: [Int]] = Barra.leerPrevios()
@@ -730,6 +780,9 @@ final class Barra: NSObject, NSApplicationDelegate {
730
780
  // barra llena, cmd-arrastrar el item a un hueco es LA salida, y sin
731
781
  // esto se perdería en cada arranque.
732
782
  item.autosaveName = "quartermaster"
783
+ // El renglón que separa una corrida de otra en el log: sin esto no se
784
+ // sabe si dos líneas son del mismo proceso ni desde cuándo corre.
785
+ registrar("arranca · qm=\(rutaQm()) · pid \(ProcessInfo.processInfo.processIdentifier)")
733
786
  item.button?.title = "qm…"
734
787
  item.menu = NSMenu()
735
788
  actividad = ProcessInfo.processInfo.beginActivity(
@@ -792,11 +845,45 @@ final class Barra: NSObject, NSApplicationDelegate {
792
845
  p.arguments = vale.isEmpty || vale.count == self.ultimas.count
793
846
  ? ["--calentar"]
794
847
  : ["--calentar", "--cuentas=" + vale.joined(separator: ",")]
848
+ // stdout no dice nada; stderr es el porqué de cada cuenta que no se
849
+ // calentó, y antes iba a /dev/null junto con el código de salida.
850
+ let errores = Pipe()
795
851
  p.standardOutput = FileHandle.nullDevice
796
- p.standardError = FileHandle.nullDevice
797
- try? p.run()
798
- p.waitUntilExit()
799
- DispatchQueue.main.async { self.refrescar() }
852
+ p.standardError = errores
853
+ // Dos cosas distintas, y mezclarlas daba un log que mentía:
854
+ // · el calentado FALLÓ: salió distinto de 0, ninguna cuenta volvió.
855
+ // Se anota cuando empieza y cuando vuelve a andar.
856
+ // · una cuenta no se calentó (sin credencial, token vencido) aunque
857
+ // otras sí. Cada motivo se anota una vez y no tiene «volvió»: los
858
+ // calentados alternan entre todas las cuentas y sólo las que se
859
+ // mueven, así que que un motivo no aparezca NO dice que se arregló.
860
+ var fallo: String?
861
+ var motivos: [String] = []
862
+ do {
863
+ try p.run()
864
+ let dicho = String(data: errores.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
865
+ p.waitUntilExit()
866
+ motivos = dicho.split(separator: "\n").map { $0.trimmingCharacters(in: .whitespaces) }.filter { !$0.isEmpty }
867
+ if p.terminationStatus != 0 {
868
+ fallo = "calentado (\(p.arguments?.joined(separator: " ") ?? "")) falló: salió \(p.terminationStatus)"
869
+ }
870
+ } catch {
871
+ fallo = "calentado falló: no pude correr qm: \(error.localizedDescription)"
872
+ }
873
+ DispatchQueue.main.async {
874
+ if let fallo {
875
+ if fallo != self.ultimoCalentado { registrar(fallo) }
876
+ self.ultimoCalentado = fallo
877
+ } else if self.ultimoCalentado != nil {
878
+ registrar("calentado volvió a andar")
879
+ self.ultimoCalentado = nil
880
+ }
881
+ for m in motivos where !self.motivosCalentado.contains(m) {
882
+ self.motivosCalentado.insert(m)
883
+ registrar(m)
884
+ }
885
+ self.refrescar()
886
+ }
800
887
  }
801
888
  }
802
889
 
@@ -859,11 +946,17 @@ final class Barra: NSObject, NSApplicationDelegate {
859
946
 
860
947
  switch lectura {
861
948
  case .falla(let porque):
949
+ // En el menú ya se veía; en el log no, así que una lectura que falló
950
+ // y se recuperó sola no dejaba rastro de haber pasado.
951
+ if porque != ultimaFalla { registrar("lectura de qm falló: \(porque)") }
952
+ ultimaFalla = porque
862
953
  item.button?.attributedTitle = comoRenglones("qm ✕")
863
954
  item.button?.image = icono("exclamationmark.triangle.fill")
864
955
  agregar(menu, porque, activo: false)
865
956
 
866
957
  case .ok(let perfiles):
958
+ if ultimaFalla != nil { registrar("lectura de qm volvió a andar") }
959
+ ultimaFalla = nil
867
960
  vigilar(perfiles)
868
961
  // Por cuenta: la sesión (la ventana corta) y la barra que frena
869
962
  // antes. Son dos preguntas distintas —«¿puedo seguir ahora?» y
@@ -995,13 +1088,18 @@ final class Barra: NSObject, NSApplicationDelegate {
995
1088
  let suya = v.screen ?? NSScreen.main
996
1089
  let afuera = suya.map { v.frame.minX < $0.frame.minX || v.frame.maxX > $0.frame.maxX } ?? false
997
1090
  let escondido = afuera || tapadoPorLaMuesca()
998
- // A stderr, siempre: es lo único que explica por qué no se ve nada.
1091
+ // Al log, porque es lo único que explica por qué no se ve nada. Pero
1092
+ // sólo cuando CAMBIA, y por pantalla: con tres monitores esto se
1093
+ // revisaba en cada redibujo y dejaba el mismo renglón una vez por minuto.
999
1094
  let pant = v.screen ?? NSScreen.main
1000
- FileHandle.standardError.write(
1001
- ("[qm-barra] titulo=\(item.button?.attributedTitle.string.replacingOccurrences(of: "\n", with: " / ") ?? "?") "
1002
- + "ancho=\(v.frame.width) x=\(v.frame.minX)..\(v.frame.maxX) "
1003
- + "muescaDerechaMinX=\(pant?.auxiliaryTopRightArea?.minX ?? -1) "
1004
- + "pantalla=\(pant?.frame.width ?? -1) escondido=\(escondido)\n").data(using: .utf8)!)
1095
+ let linea = "posición: ancho=\(v.frame.width) x=\(v.frame.minX)..\(v.frame.maxX) "
1096
+ + "muescaDerechaMinX=\(pant?.auxiliaryTopRightArea?.minX ?? -1) "
1097
+ + "pantalla=\(pant?.frame.width ?? -1) escondido=\(escondido)"
1098
+ let clave = "\(pant?.frame.width ?? -1)x\(pant?.frame.height ?? -1)"
1099
+ if ultimaPosicion[clave] != linea {
1100
+ ultimaPosicion[clave] = linea
1101
+ registrar(linea)
1102
+ }
1005
1103
  // Una sola vez por corrida. Antes se re-armaba al volver a entrar, así
1006
1104
  // que un item que oscila entre visible y tapado avisaba en cada vuelta.
1007
1105
  if escondido, !avisoBarraLlena {
@@ -1267,7 +1365,7 @@ final class Barra: NSObject, NSApplicationDelegate {
1267
1365
  .write(to: URL(fileURLWithPath: ruta.replacingOccurrences(of: ".png", with: "\(sufijo).png")))
1268
1366
  }
1269
1367
  }
1270
- FileHandle.standardError.write("[qm-barra] capturado ancho=\(caja.width) alto=\(caja.height) filas=\(vistas.count)\n".data(using: .utf8)!)
1368
+ registrar("capturado ancho=\(caja.width) alto=\(caja.height) filas=\(vistas.count)")
1271
1369
  }
1272
1370
 
1273
1371
  // Acciones -------------------------------------------------------------
package/bin/qm-indicator CHANGED
@@ -56,6 +56,14 @@ from gi.repository import Gdk, Gio, GLib, Gtk, Pango, PangoCairo # noqa: E402
56
56
  ID = "quartermaster"
57
57
  # Red de seguridad: el FileMonitor es el que manda. Esto sólo cubre el caso de
58
58
  # un monitor que se pierda un evento (montajes raros, archivos reemplazados).
59
+ # Cuánto hace falta que una cuenta esté sin usarse para dejar de preguntarle.
60
+ # Diez minutos aguantan una pausa entre prompts sin seguir preguntando por una
61
+ # cuenta que ya cerraste.
62
+ ACTIVA_SEGUNDOS = 600
63
+ # Cuánto se le da a un calentado antes de darlo por colgado. `qm --calentar`
64
+ # tiene su propio timeout de red adentro, así que si en dos minutos no contestó
65
+ # es que su callback no va a llegar.
66
+ CALENTADO_PLAZO_US = 120 * 1_000_000
59
67
  SEGUNDOS_SONDEO = 300
60
68
  # Piso para cualquier cadencia que salga a la RED. Claude Code pide la cuota del
61
69
  # orden de una vez por sesión; un endpoint no documentado, que además puede
@@ -962,6 +970,10 @@ def piezas_de(datos, avisar=None) -> list[dict]:
962
970
  # número que tiene es de una ventana que ya cerró.
963
971
  "reinicia_sesion": ses.get("reinicia") if ses else None,
964
972
  "reinicia_semanal": sem.get("reinicia") if sem else None,
973
+ # Cuándo se usó esta cuenta por última vez. Es lo que distingue una
974
+ # cuenta al 2 % que está quieta de una al 2 % que estás gastando
975
+ # ahora mismo: el número de la segunda se mueve, el de la primera no.
976
+ "ultimo_uso": p.get("ultimoUso"),
965
977
  "viejo": (cuota.get("edadSegundos") or 0) >= VIEJO_SEGUNDOS,
966
978
  })
967
979
  if avisar is not None:
@@ -1440,6 +1452,10 @@ class Avisos:
1440
1452
  self.vistos = set(json.loads(self.ruta.read_text()))
1441
1453
  except (OSError, ValueError):
1442
1454
  self.vistos = set()
1455
+ # Sólo para el registro: qué avisos repetidos ya se dijeron en ESTE
1456
+ # proceso. No se persiste — al reiniciar conviene volver a decirlo una
1457
+ # vez, porque el registro nuevo arranca vacío.
1458
+ self.repetidos_dichos: set[str] = set()
1443
1459
 
1444
1460
  def guardar(self) -> None:
1445
1461
  try:
@@ -1451,9 +1467,21 @@ class Avisos:
1451
1467
  def avisar(self, clave: str, titulo: str, cuerpo: str, urgente: bool) -> None:
1452
1468
  """Una vez por clave y nunca más."""
1453
1469
  if clave in self.vistos:
1470
+ # Que un aviso NO salga por repetido es una decisión, no un
1471
+ # no-evento: explica «no me avisó» cuando el aviso sí correspondía.
1472
+ #
1473
+ # Pero esto se evalúa en CADA refresco, o sea cada pocos segundos
1474
+ # mientras la barra siga alta. Registrarlo siempre son tres líneas
1475
+ # iguales cada veinte segundos hasta que la ventana se reinicie: el
1476
+ # registro deja de leerse y el evento que importa queda enterrado.
1477
+ # Se dice una vez por clave y por proceso, que es cuando aporta.
1478
+ if clave not in self.repetidos_dichos:
1479
+ self.repetidos_dichos.add(clave)
1480
+ registrar("aviso.repetido", clave=clave)
1454
1481
  return
1455
1482
  self.vistos.add(clave)
1456
1483
  self.guardar()
1484
+ registrar("aviso", clave=clave, urgente=urgente)
1457
1485
  self.notificar(titulo, cuerpo, urgente)
1458
1486
 
1459
1487
  def notificar(self, titulo: str, cuerpo: str, urgente: bool) -> None:
@@ -1483,8 +1511,11 @@ class Avisos:
1483
1511
  -1,
1484
1512
  None,
1485
1513
  )
1486
- except GLib.Error:
1487
- pass # sin servidor de notificaciones el indicador igual funciona
1514
+ except GLib.Error as e:
1515
+ # El indicador igual funciona sin servidor de notificaciones, pero
1516
+ # «te liberaste» es el aviso más útil que da el programa: si no sale,
1517
+ # tiene que quedar dicho por qué.
1518
+ registrar("aviso.fallo", motivo=str(e).replace("\n", " ")[:100])
1488
1519
 
1489
1520
 
1490
1521
  # ── leer a qm ────────────────────────────────────────────────────────────
@@ -1563,6 +1594,9 @@ class Indicador:
1563
1594
  self.piezas: list[dict] = []
1564
1595
  self.minutos_al_techo: float | None = None
1565
1596
  self.calentando = False
1597
+ # Desde cuándo. Sin esto, una bandera que se queda pegada no se puede
1598
+ # distinguir de un calentado que recién arrancó.
1599
+ self.calentando_desde: int | None = None
1566
1600
  self.reloj: int | None = None
1567
1601
  self.proxima_lectura: int | None = None
1568
1602
  self.turno = 0
@@ -1576,6 +1610,7 @@ class Indicador:
1576
1610
  self.vigilar_version()
1577
1611
  GLib.timeout_add_seconds(SEGUNDOS_SONDEO, self.refrescar)
1578
1612
  self.programar_calentado(5)
1613
+ self.vigilar_suspension()
1579
1614
 
1580
1615
  # Vigilancia de archivos ------------------------------------------------
1581
1616
  def vigilar(self) -> None:
@@ -1653,12 +1688,67 @@ class Indicador:
1653
1688
  print(f"la versión nueva no compila, me quedo con ésta: {e}", file=sys.stderr)
1654
1689
  return False
1655
1690
  self.panel.menu.popdown()
1691
+ # Un proceso que se reemplaza a sí mismo en silencio explica cualquier
1692
+ # rareza posterior —contadores en cero, panel cerrado, avisos de nuevo—
1693
+ # y hasta acá no dejaba una línea.
1694
+ registrar("reinicio", motivo="el fuente cambió")
1656
1695
  try:
1657
1696
  os.execv(sys.executable, [sys.executable, str(YO), *sys.argv[1:]])
1658
1697
  except OSError as e:
1698
+ registrar("reinicio.fallo", error=str(e)[:80])
1659
1699
  print(f"no pude reiniciarme: {e}", file=sys.stderr)
1660
1700
  return False
1661
1701
 
1702
+ def vigilar_suspension(self) -> None:
1703
+ """Enterarse de que la máquina durmió, y refrescar al volver.
1704
+
1705
+ Sin esto, volver de una suspensión es la peor pantalla que da el
1706
+ programa: los números son de antes de dormir y las ventanas que se
1707
+ reiniciaron mientras tanto salen marcadas «vencida». Todo correcto y
1708
+ todo inútil — lo que hace falta es el número de ahora.
1709
+
1710
+ Y no alcanza con esperar al próximo sondeo. Los timeouts de GLib corren
1711
+ contra el reloj MONOTÓNICO, que en Linux no avanza mientras la máquina
1712
+ duerme: cuatro horas suspendida son cero segundos para el temporizador.
1713
+ El reloj de pared sí saltó, así que la lectura queda vieja de horas
1714
+ mientras el sondeo cree que recién empieza.
1715
+
1716
+ logind avisa con PrepareForSleep: `true` antes de dormir, `false` al
1717
+ volver. El `false` es el que importa.
1718
+
1719
+ Va en el bus del SISTEMA, no en el de sesión. Si no se puede —un
1720
+ contenedor, una máquina sin logind— se sigue sin esto, que es como
1721
+ estaba hasta hoy.
1722
+ """
1723
+ try:
1724
+ sistema = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
1725
+ sistema.signal_subscribe(
1726
+ "org.freedesktop.login1",
1727
+ "org.freedesktop.login1.Manager",
1728
+ "PrepareForSleep",
1729
+ "/org/freedesktop/login1",
1730
+ None,
1731
+ Gio.DBusSignalFlags.NONE,
1732
+ self._al_dormir_o_volver,
1733
+ )
1734
+ self.bus_sistema = sistema
1735
+ except GLib.Error as e:
1736
+ registrar("suspension.sin-logind", motivo=str(e)[:90])
1737
+
1738
+ def _al_dormir_o_volver(self, _con, _emisor, _ruta, _iface, _senal, params) -> None:
1739
+ durmiendo = bool(params[0]) if params and len(params) else False
1740
+ if durmiendo:
1741
+ registrar("suspension.duerme")
1742
+ return
1743
+ registrar("suspension.vuelve")
1744
+ # La bandera se suelta a mano: si había un calentado en vuelo cuando la
1745
+ # máquina se durmió, su callback es justo el que puede no llegar.
1746
+ self.calentando = False
1747
+ self.calentando_desde = None
1748
+ # Y se pregunta YA, no en el próximo sondeo: al volver, lo que hay en
1749
+ # pantalla es de antes de dormir.
1750
+ self.programar_calentado(2)
1751
+
1662
1752
  def vigilar_tema(self) -> None:
1663
1753
  """El tema del escritorio se cambia con esto andando.
1664
1754
 
@@ -1698,14 +1788,24 @@ class Indicador:
1698
1788
  self.pedido_pendiente = None
1699
1789
  try:
1700
1790
  accion = PEDIDO.read_text().split(" ", 1)[0].strip()
1701
- except OSError:
1791
+ except OSError as e:
1792
+ # Un pedido que no se puede leer es un click que se perdió, y sin
1793
+ # esta línea se pierde sin dejar rastro.
1794
+ registrar("pedido.ilegible", error=str(e)[:80])
1702
1795
  return False
1796
+ # Saber si el click LLEGÓ es la mitad de cualquier diagnóstico de «no
1797
+ # hace nada»: separa «la extensión no pidió» de «pidió y no pasó nada».
1798
+ # Sin esto hubo que disparar el pedido a mano y mirar el mtime de
1799
+ # estado.json para saber de qué lado estaba el problema.
1800
+ registrar("pedido", accion=accion or "(vacío)")
1703
1801
  if accion == "alternar":
1704
1802
  # La extensión sólo pide esto cuando NO puede dibujar el panel ella
1705
1803
  # misma; si puede, abre su propio menú y no manda nada.
1706
1804
  self.abrir_panel()
1707
1805
  elif accion == "actualizar":
1708
1806
  self.refrescar()
1807
+ else:
1808
+ registrar("pedido.desconocido", accion=accion[:40])
1709
1809
  return False
1710
1810
 
1711
1811
  def extension_viva(self) -> bool:
@@ -1771,6 +1871,12 @@ class Indicador:
1771
1871
  return True
1772
1872
  return False
1773
1873
 
1874
+ @staticmethod
1875
+ def _activa_hace_poco(t: dict) -> bool:
1876
+ """Si se usó hace poco. Entonces su número se está moviendo."""
1877
+ seg = faltan(t.get("ultimo_uso"))
1878
+ return seg is not None and -ACTIVA_SEGUNDOS <= seg <= 0
1879
+
1774
1880
  def _vale_preguntar(self, t: dict) -> bool:
1775
1881
  """A qué cuentas se les pregunta en el próximo calentado.
1776
1882
 
@@ -1796,6 +1902,18 @@ class Indicador:
1796
1902
  """
1797
1903
  if self._ya_reinicio(t):
1798
1904
  return True
1905
+ # Y la cuenta que estás usando AHORA, esté donde esté.
1906
+ #
1907
+ # El corte de abajo —«una cuenta al 9 % no da noticias»— es cierto de
1908
+ # una cuenta QUIETA. De una que estás gastando es exactamente al revés:
1909
+ # es la única cuyo número está cambiando, y con el corte por nivel se
1910
+ # quedaba sin preguntar hasta llegar al 40 %.
1911
+ #
1912
+ # Medido el 2026-09-13, con dos sesiones abiertas: la cuenta de teams
1913
+ # iba al 2 % y en 55 minutos la barra le preguntó al endpoint UNA vez.
1914
+ # Todos los demás calentados fueron para codex, que estaba al 85 %.
1915
+ if self._activa_hace_poco(t):
1916
+ return True
1799
1917
  return 40 <= self._tope(t) < 100
1800
1918
 
1801
1919
  def cadencia(self) -> int:
@@ -1840,7 +1958,30 @@ class Indicador:
1840
1958
  def calentar(self) -> bool:
1841
1959
  self.reloj = None
1842
1960
  if self.calentando:
1843
- return False
1961
+ # Acá había un `return False` pelado, y eso MATABA el lazo: al
1962
+ # devolver False la fuente de GLib se quita, y como `self.reloj` ya
1963
+ # se soltó arriba, nadie la vuelve a armar. Una sola bandera pegada
1964
+ # dejaba al indicador sin volver a preguntarle al endpoint en lo que
1965
+ # le quedaba de vida — dibujando cada pocos minutos un número que no
1966
+ # se actualizaba nunca.
1967
+ #
1968
+ # Visto el 2026-09-13 después de una suspensión de 4,1 h: el proceso
1969
+ # vivo, estado.json reescrito hacía 4 minutos, y la cuota leída
1970
+ # hacía 5,2 horas.
1971
+ #
1972
+ # `calentando` sólo se apaga en el callback de wait_async. Si ese
1973
+ # callback no llega —y una suspensión en el medio es justo cuando no
1974
+ # llega— no hay nada más que lo apague. Así que además de
1975
+ # reprogramar, se le pone un plazo: pasado eso, el callback no viene
1976
+ # y la bandera se suelta.
1977
+ desde = self.calentando_desde
1978
+ if desde is not None and (GLib.get_monotonic_time() - desde) > CALENTADO_PLAZO_US:
1979
+ registrar("calentar.colgado", segundos=int((GLib.get_monotonic_time() - desde) / 1_000_000))
1980
+ self.calentando = False
1981
+ self.calentando_desde = None
1982
+ else:
1983
+ self.programar_calentado()
1984
+ return False
1844
1985
  args = [self.qm, "--calentar"]
1845
1986
  # Sólo las cuentas que se mueven: refrescar una que va al 9 % es gastar
1846
1987
  # un pedido para confirmar que no pasó nada.
@@ -1856,11 +1997,13 @@ class Indicador:
1856
1997
  self.programar_calentado()
1857
1998
  return False
1858
1999
  self.calentando = True
2000
+ self.calentando_desde = GLib.get_monotonic_time()
1859
2001
  proc.wait_async(None, self._fin_calentado)
1860
2002
  return False
1861
2003
 
1862
2004
  def _fin_calentado(self, proc, resultado) -> None:
1863
2005
  self.calentando = False
2006
+ self.calentando_desde = None
1864
2007
  try:
1865
2008
  proc.wait_finish(resultado)
1866
2009
  except GLib.Error as e:
@@ -1882,6 +2025,12 @@ class Indicador:
1882
2025
  # Dibujo ----------------------------------------------------------------
1883
2026
  def refrescar(self) -> bool:
1884
2027
  datos = self.leer()
2028
+ # `leer_qm` devuelve una FRASE cuando no pudo: se muestra en el menú y
2029
+ # hasta acá no quedaba escrita en ningún lado. Si qm falla a las tres de
2030
+ # la mañana, mañana no hay forma de saber por qué.
2031
+ if isinstance(datos, str) and datos != getattr(self, "_ultimo_fallo", None):
2032
+ registrar("qm.sin-datos", motivo=datos[:110])
2033
+ self._ultimo_fallo = datos if isinstance(datos, str) else None
1885
2034
  self.datos = datos
1886
2035
  for hijo in self.menu.get_children():
1887
2036
  self.menu.remove(hijo)