@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 CHANGED
@@ -49,16 +49,18 @@ brew install legiosai/tap/quartermaster # macOS and Linux
49
49
  npm install -g @legios/quartermaster # anywhere
50
50
  ```
51
51
 
52
- **The bar item, on macOS and Linux:** the first time you run `qm` in a terminal,
53
- it asks once whether to put it in the bar and start it at every login. The
52
+ **The bar item, on all three:** the first time you run `qm` in a terminal, it
53
+ asks once whether to put it in the bar and start it at every login — the menu
54
+ bar on macOS, the top bar on GNOME, the notification area on Windows. The
54
55
  install itself can't: brew can't start anything from a formula, the `.deb` drops
55
- the files and leaves, and a tool that reads OAuth tokens shouldn't register login
56
- agents nobody asked for. Without the question: `brew services start
57
- quartermaster` on macOS, and on Linux
56
+ the files and leaves, npm's postinstall won't register anything either, and a
57
+ tool that reads OAuth tokens shouldn't register login agents nobody asked for.
58
+ Without the question: `brew services start quartermaster` on macOS, and
58
59
 
59
60
  ```sh
60
- qm-indicator --instalar-extension # the item that opens the panel on click
61
+ qm-indicator --instalar-extension # Linux: the item that opens the panel on click
61
62
  qm-indicator --instalar-arranque # and start it once: qm-indicator &
63
+ bin/qm-tray --instalar-arranque # Windows, from WSL: then run bin/qm-tray
62
64
  ```
63
65
 
64
66
  Saying yes on Linux **also installs the GNOME extension**, which is what makes a
@@ -74,7 +76,9 @@ extension already in place, or a GNOME Shell to install ours into. Without those
74
76
  the process would start anyway and nothing would appear up there, which is worse
75
77
  than not offering. `qm --diagnostico` says which one is missing.
76
78
 
77
- **Windows:** the installer from the [latest
79
+ **Windows:** `npm install -g @legios/quartermaster` inside WSL works too, and
80
+ the first `qm` asks the same question — the tray ships in the package. For a
81
+ native install without WSL, the installer from the [latest
78
82
  release](https://github.com/legiosai/quartermaster/releases/latest). Per-user
79
83
  and no UAC: it puts `qm` on your `PATH`, the tray in the Start menu, and — if
80
84
  you leave the box ticked — the tray in startup.
@@ -31,6 +31,12 @@ import Foundation
31
31
  let SEGUNDOS_SONDEO: TimeInterval = 300
32
32
  // Coalescer escrituras: Claude Code reescribe .claude.json varias veces seguidas.
33
33
  let DEBOUNCE: TimeInterval = 1.5
34
+ /// Cada cuánto mira el vigía, y a partir de qué atraso da la alarma. El plazo
35
+ /// son cuatro sondeos: con la cadencia en su techo, un calentado que no ocurrió
36
+ /// en veinte minutos no es lentitud, es que el lazo se cortó.
37
+ let VIGIA_SEGUNDOS: TimeInterval = 60
38
+ let VIGIA_PLAZO: TimeInterval = 20 * 60
39
+
34
40
  /// Piso para cualquier cadencia que salga a la RED.
35
41
  ///
36
42
  /// La primera versión bajaba a 20 s cuando una barra pasaba el 90 %, y como
@@ -876,6 +882,13 @@ final class Barra: NSObject, NSApplicationDelegate {
876
882
  }
877
883
  var pendiente: DispatchWorkItem?
878
884
  var reloj: Timer?
885
+ /// Cuándo terminó el último calentado, y si el vigía ya avisó de este corte.
886
+ /// Es lo que mira `vigia`: la pregunta no es «¿está armado el timer?» —eso
887
+ /// se puede creer y estar equivocado— sino «¿cuándo fue la última vez que
888
+ /// de verdad le preguntamos al servidor?».
889
+ var calentadoEn: Date?
890
+ var vigiaAviso = false
891
+ var relojVigia: Timer?
879
892
  /// Sin esto macOS le aplica App Nap —es una app sin ventanas— y los timers
880
893
  /// se corren minutos. Medido: un sondeo de 5 min que no disparó en 7.
881
894
  var actividad: NSObjectProtocol?
@@ -923,6 +936,7 @@ final class Barra: NSObject, NSApplicationDelegate {
923
936
  options: [.userInitiated, .idleSystemSleepDisabled],
924
937
  reason: "mirar la cuota a tiempo")
925
938
  refrescar()
939
+ armarVigia()
926
940
  calentarCodex()
927
941
  }
928
942
 
@@ -946,9 +960,45 @@ final class Barra: NSObject, NSApplicationDelegate {
946
960
 
947
961
  var minutosAlTecho: Double? = nil
948
962
 
949
- func programar() {
963
+ /// Agenda el próximo calentado, y NUNCA lo aleja.
964
+ ///
965
+ /// Esto se llama al final del armado del menú, y el menú se arma en cada
966
+ /// `refrescar()` — que acá lo dispara el vigía de archivos, y Claude Code
967
+ /// reescribe su .claude.json cada veinte segundos. Rearmar siempre
968
+ /// significaba correr la fecha del calentado con cada escritura ajena:
969
+ /// el calentado no llegaba a vencer nunca.
970
+ ///
971
+ /// Del lado de GNOME, que tiene la misma forma con el sondeo periódico en
972
+ /// vez del vigía de archivos, pasó de verdad: medido el 2026-09-15, un solo
973
+ /// calentado al arrancar y siete horas y media sin ninguno, con la bandera
974
+ /// libre y un temporizador armado todo el tiempo —armado y reiniciado, que
975
+ /// es distinto de disparado—.
976
+ ///
977
+ /// La regla es simple: una fecha más lejos que la que ya hay no reemplaza a
978
+ /// nada. Apretar la cadencia sigue andando, porque ésa siempre es más cerca.
979
+ func programar(forzando: Bool = false) {
980
+ let cuanto = cadencia()
981
+ let cuando = Date().addingTimeInterval(cuanto)
982
+ // `forzando` es para el vigía: cuando el calentado está parado, la fecha
983
+ // agendada YA VENCIÓ, así que cualquier fecha nueva es «más lejos» y la
984
+ // guarda la rechazaría. La defensa contra el hambre desactivaba a la
985
+ // defensa contra el silencio.
986
+ if let r = reloj, r.isValid {
987
+ if !forzando, cuando >= r.fireDate { return }
988
+ // Forzando también tiene un límite: sólo reemplaza un reloj cuya
989
+ // fecha YA PASÓ. El vigía corre cada minuto y, una vez que avisó,
990
+ // llamaba a esto con `forzando` en cada vuelta: cada llamada
991
+ // invalidaba el Timer de cinco minutos recién armado y ponía otro
992
+ // de cinco minutos. Un reloj que se reemplaza cada 60 s con uno de
993
+ // 300 s no dispara nunca. Medido el 2026-09-16: «lo rearmo» a las
994
+ // 13:57 del día anterior, y desde ahí veinte horas sin un solo
995
+ // calentado, con el proceso vivo, el token vigente desde las 09:32
996
+ // y el vigía «rearmando» en silencio cada minuto. La defensa
997
+ // contra el silencio se había vuelto la causa del silencio.
998
+ if forzando, r.fireDate > Date() { return }
999
+ }
950
1000
  reloj?.invalidate()
951
- let t = Timer(timeInterval: cadencia(), repeats: false) { _ in
1001
+ let t = Timer(timeInterval: cuanto, repeats: false) { _ in
952
1002
  // Codex primero: su número no está en ningún disco hasta que
953
1003
  // alguien lo pide, y el refresco de abajo lee del cache.
954
1004
  self.calentarCodex()
@@ -960,6 +1010,47 @@ final class Barra: NSObject, NSApplicationDelegate {
960
1010
  reloj = t
961
1011
  }
962
1012
 
1013
+ /// Que el calentado no pueda dejar de ocurrir en silencio.
1014
+ ///
1015
+ /// `programar()` arma un Timer de UNA sola vez, y el único lugar que lo
1016
+ /// vuelve a armar es el final del armado del menú. Cualquier corte en esa
1017
+ /// cadena apaga el calentado para toda la vida del proceso y sin ruido.
1018
+ ///
1019
+ /// Pasó del lado de GNOME, que tiene la misma forma: el 2026-09-15, con
1020
+ /// 0.1.13, el indicador de Linux dejó de preguntarle al endpoint y estuvo
1021
+ /// siete horas y media sin escribir una línea, con el proceso vivo y el
1022
+ /// item redibujándose. Acá no se esperó a que pasara.
1023
+ ///
1024
+ /// Esto mira desde afuera, se repite solo y no depende del calentado: si
1025
+ /// pasó el plazo sin una lectura, lo ANOTA una vez y lo rearma.
1026
+ func armarVigia() {
1027
+ // Con la hora de arranque y no en nil: si el PRIMER calentado nunca
1028
+ // termina, un vigía que espera a tener una marca no mira nunca.
1029
+ if calentadoEn == nil { calentadoEn = Date() }
1030
+ relojVigia?.invalidate()
1031
+ let t = Timer(timeInterval: VIGIA_SEGUNDOS, repeats: true) { [weak self] _ in
1032
+ self?.vigia()
1033
+ }
1034
+ t.tolerance = 0
1035
+ RunLoop.main.add(t, forMode: .common)
1036
+ relojVigia = t
1037
+ }
1038
+
1039
+ func vigia() {
1040
+ guard let desde = calentadoEn else { return }
1041
+ let atraso = Date().timeIntervalSince(desde)
1042
+ guard atraso > VIGIA_PLAZO else {
1043
+ vigiaAviso = false
1044
+ return
1045
+ }
1046
+ // Una vez por corte, no una por minuto: el log tiene que poder leerse.
1047
+ if !vigiaAviso {
1048
+ registrar("el calentado no ocurre hace \(duracion(Int(atraso))): lo rearmo")
1049
+ vigiaAviso = true
1050
+ }
1051
+ programar(forzando: true)
1052
+ }
1053
+
963
1054
  /// Refresca las dos puntas —el endpoint de cada perfil de Claude y el de
964
1055
  /// Codex— y deja los números en el cache de qm, para que las lecturas de la
965
1056
  /// barra —que son `--breve`— sigan tardando milisegundos y encuentren algo
@@ -1017,6 +1108,8 @@ final class Barra: NSObject, NSApplicationDelegate {
1017
1108
  self.motivosCalentado.insert(m)
1018
1109
  registrar(m)
1019
1110
  }
1111
+ self.calentadoEn = Date()
1112
+ self.vigiaAviso = false
1020
1113
  self.refrescar()
1021
1114
  }
1022
1115
  }
package/bin/qm-indicator CHANGED
@@ -65,6 +65,11 @@ ACTIVA_SEGUNDOS = 600
65
65
  # es que su callback no va a llegar.
66
66
  CALENTADO_PLAZO_US = 120 * 1_000_000
67
67
  SEGUNDOS_SONDEO = 300
68
+ #: Cada cuánto mira el vigía, y a partir de qué atraso da la alarma. El plazo es
69
+ #: cuatro sondeos: con la cadencia en su techo de 300 s, un calentado que no
70
+ #: ocurrió en 20 minutos no es lentitud, es que el lazo se cortó.
71
+ VIGIA_SEGUNDOS = 60
72
+ VIGIA_PLAZO_US = 4 * SEGUNDOS_SONDEO * 1_000_000
68
73
  # Piso para cualquier cadencia que salga a la RED. Claude Code pide la cuota del
69
74
  # orden de una vez por sesión; un endpoint no documentado, que además puede
70
75
  # desaparecer sin aviso, no es lugar para sondear más rápido que esto. Y la
@@ -1730,6 +1735,14 @@ class Indicador:
1730
1735
  # y sólo las que se mueven, así que que un motivo no aparezca NO dice
1731
1736
  # que se arregló.
1732
1737
  self._motivos_calentado: set[str] = set()
1738
+ # Cuándo terminó el último calentado. Es lo que mira el vigía: la
1739
+ # pregunta no es «¿está armado el temporizador?» —eso se puede creer y
1740
+ # estar equivocado— sino «¿cuándo fue la última vez que de verdad le
1741
+ # preguntamos al servidor?».
1742
+ # Arranca con la hora de arranque y no en None: si el PRIMER calentado
1743
+ # nunca termina, un vigía que espera a tener una marca no mira nunca.
1744
+ self._ultimo_calentado: int | None = GLib.get_monotonic_time()
1745
+ self._vigia_avisado = False
1733
1746
  self.reloj: int | None = None
1734
1747
  self.proxima_lectura: int | None = None
1735
1748
  self.turno = 0
@@ -1741,9 +1754,15 @@ class Indicador:
1741
1754
  self.vigilar_extension()
1742
1755
  self.vigilar_tema()
1743
1756
  self.vigilar_version()
1744
- GLib.timeout_add_seconds(SEGUNDOS_SONDEO, self.refrescar)
1757
+ # Envuelto, y devolviendo True SIEMPRE. Un callback de GLib que tira
1758
+ # deja de devolver un valor verdadero y la fuente se QUITA: una sola
1759
+ # excepción en un refresco mataba el sondeo para siempre, y con él al
1760
+ # calentado, que se rearma desde acá. El envoltorio no arregla el error
1761
+ # —lo anota— pero no deja que se lleve puesto al lazo.
1762
+ GLib.timeout_add_seconds(SEGUNDOS_SONDEO, self._sondear)
1745
1763
  self.programar_calentado(5)
1746
1764
  self.vigilar_suspension()
1765
+ GLib.timeout_add_seconds(VIGIA_SEGUNDOS, self._vigia)
1747
1766
 
1748
1767
  # Vigilancia de archivos ------------------------------------------------
1749
1768
  def vigilar(self) -> None:
@@ -2073,11 +2092,39 @@ class Indicador:
2073
2092
  seg = min(seg, 120)
2074
2093
  return max(MINIMO_RED, seg)
2075
2094
 
2076
- def programar_calentado(self, segundos: int | None = None) -> None:
2095
+ def programar_calentado(self, segundos: int | None = None, forzar: bool = False) -> None:
2096
+ """Agenda el próximo calentado, y NUNCA lo aleja.
2097
+
2098
+ Acá estaba el hambre. Esto rearmaba siempre, y `refrescar()` lo llama en
2099
+ cada vuelta; el sondeo corre cada SEGUNDOS_SONDEO y `cadencia()` devuelve
2100
+ exactamente eso cuando no hay nada alto —el caso normal—. Los dos
2101
+ temporizadores quedaban empatados en 300 s y el del sondeo llegaba
2102
+ primero, así que cada sondeo reiniciaba la cuenta regresiva del
2103
+ calentado justo antes de que venciera. El calentado no ocurría NUNCA.
2104
+
2105
+ Medido el 2026-09-15 con 0.1.13: un solo calentado al arrancar y después
2106
+ siete horas y media sin ninguno, con `calentando` en False y un
2107
+ temporizador armado todo el tiempo —armado y reiniciado, que es distinto
2108
+ de disparado—. Y por eso forzar un `refrescar()` no lo revivía: volvía a
2109
+ correr la cuenta 300 s más allá.
2110
+
2111
+ La regla es simple: una fecha que está más lejos que la que ya hay no
2112
+ reemplaza a nada. Apretar la cadencia —que es para lo que existe volver
2113
+ a llamar— sigue funcionando, porque ésa siempre es más cerca.
2114
+ """
2115
+ cuanto = self.cadencia() if segundos is None else segundos
2116
+ cuando = GLib.get_monotonic_time() + cuanto * 1_000_000
2117
+ # `forzar` es para el vigía, y no es un detalle: cuando el calentado está
2118
+ # parado, la fecha agendada YA VENCIÓ, así que cualquier fecha nueva es
2119
+ # «más lejos» y la guarda de arriba la rechazaría. La defensa contra el
2120
+ # hambre desactivaba a la defensa contra el silencio. Lo encontró el gate
2121
+ # corriendo el Swift, no leyéndolo.
2122
+ if (not forzar and self.reloj is not None and self.proxima_lectura is not None
2123
+ and cuando >= self.proxima_lectura):
2124
+ return
2077
2125
  if self.reloj is not None:
2078
2126
  GLib.source_remove(self.reloj)
2079
- cuanto = self.cadencia() if segundos is None else segundos
2080
- self.proxima_lectura = GLib.get_monotonic_time() + cuanto * 1_000_000
2127
+ self.proxima_lectura = cuando
2081
2128
  self.reloj = GLib.timeout_add_seconds(cuanto, self.calentar)
2082
2129
 
2083
2130
  def falta_para_lectura(self) -> float | None:
@@ -2088,6 +2135,57 @@ class Indicador:
2088
2135
  return 0.0
2089
2136
  return max(0.0, (self.proxima_lectura - GLib.get_monotonic_time()) / 1_000_000)
2090
2137
 
2138
+ def _sondear(self) -> bool:
2139
+ """El refresco periódico, que NUNCA puede sacarse su propia fuente."""
2140
+ try:
2141
+ self.refrescar()
2142
+ except Exception as e: # noqa: BLE001 — anotar y seguir, no morir callado
2143
+ registrar("sondeo.reventó", error=f"{type(e).__name__}: {e}"[:110])
2144
+ return True
2145
+
2146
+ def _vigia(self) -> bool:
2147
+ """Que el calentado no pueda dejar de ocurrir en silencio.
2148
+
2149
+ El 2026-09-15, con 0.1.13, este indicador dejó de preguntarle al
2150
+ endpoint a las 02:35 y estuvo siete horas y media sin escribir una sola
2151
+ línea: el proceso vivo, `estado.json` reescrito hacía un minuto y la
2152
+ cuota de hacía siete horas. Forzar un `refrescar()` —que rearma el
2153
+ calentado— no lo revivió en diez minutos, con la cadencia en un techo de
2154
+ cinco. No fue la suspensión: BOOTTIME y MONOTONIC daban lo mismo.
2155
+
2156
+ La causa de fondo no es una línea, es la FORMA: el calentado se rearmaba
2157
+ desde un solo lugar —el final de `refrescar()`—, así que cualquier corte
2158
+ en esa cadena lo apagaba para toda la vida del proceso y sin ruido.
2159
+
2160
+ Esto lo mira desde afuera y no se puede quedar callado: es una fuente
2161
+ que devuelve True siempre, no depende del calentado ni del sondeo, y
2162
+ pregunta lo único que importa —cuánto hace que no le preguntamos al
2163
+ servidor—. Si se pasa del plazo, lo ANOTA y lo destraba.
2164
+ """
2165
+ try:
2166
+ ahora = GLib.get_monotonic_time()
2167
+ desde = self._ultimo_calentado
2168
+ atraso = None if desde is None else ahora - desde
2169
+ if atraso is None or atraso <= VIGIA_PLAZO_US:
2170
+ self._vigia_avisado = False
2171
+ return True
2172
+ # Una vez por corte, no una por minuto: el log tiene que poder
2173
+ # leerse. Se vuelve a habilitar solo cuando el calentado vuelve.
2174
+ if not self._vigia_avisado:
2175
+ registrar("calentar.parado",
2176
+ hace=duracion(int(atraso / 1_000_000)),
2177
+ calentando=self.calentando,
2178
+ desde=self.calentando_desde is not None,
2179
+ reloj=self.reloj is not None)
2180
+ self._vigia_avisado = True
2181
+ # Y destrabarlo: la bandera pegada se suelta y se rearma ya.
2182
+ self.calentando = False
2183
+ self.calentando_desde = None
2184
+ self.programar_calentado(1, forzar=True)
2185
+ except Exception as e: # noqa: BLE001 — el vigía no puede ser lo que se cae
2186
+ registrar("vigia.reventó", error=f"{type(e).__name__}: {e}"[:110])
2187
+ return True
2188
+
2091
2189
  def calentar(self) -> bool:
2092
2190
  self.reloj = None
2093
2191
  if self.calentando:
@@ -2107,9 +2205,18 @@ class Indicador:
2107
2205
  # llega— no hay nada más que lo apague. Así que además de
2108
2206
  # reprogramar, se le pone un plazo: pasado eso, el callback no viene
2109
2207
  # y la bandera se suelta.
2208
+ # `desde` en None con `calentando` en True es un estado que el
2209
+ # código no debería poder producir —se ponen juntas— y por eso
2210
+ # mismo era el único silencio posible: con el `is not None` de
2211
+ # antes, ese caso caía al `else` y se rearmaba para siempre sin
2212
+ # anotar nada. Ahora una bandera sin instante se trata como lo que
2213
+ # es: pegada.
2110
2214
  desde = self.calentando_desde
2111
- if desde is not None and (GLib.get_monotonic_time() - desde) > CALENTADO_PLAZO_US:
2112
- registrar("calentar.colgado", segundos=int((GLib.get_monotonic_time() - desde) / 1_000_000))
2215
+ pasado = desde is None or (GLib.get_monotonic_time() - desde) > CALENTADO_PLAZO_US
2216
+ if pasado:
2217
+ registrar("calentar.colgado",
2218
+ segundos=None if desde is None else int((GLib.get_monotonic_time() - desde) / 1_000_000),
2219
+ sin_instante=desde is None or None)
2113
2220
  self.calentando = False
2114
2221
  self.calentando_desde = None
2115
2222
  else:
@@ -2176,6 +2283,8 @@ class Indicador:
2176
2283
  fallo = f"salió {proc.get_exit_status()}"
2177
2284
  if primera:
2178
2285
  fallo += f": {primera[0][:110]}"
2286
+ self._ultimo_calentado = GLib.get_monotonic_time()
2287
+ self._vigia_avisado = False
2179
2288
  self._anotar_calentado(fallo)
2180
2289
  # Los motivos por cuenta van aunque el calentado haya salido 0: que una
2181
2290
  # cuenta no se pueda calentar no hace fallar a las otras, y sin esto la
package/bin/qm-tray CHANGED
@@ -35,6 +35,16 @@ GUION=$(wslpath -w "$AQUI/qm-tray.ps1")
35
35
  # la misma razón: el arranque automático no pasa por el .bashrc del usuario.
36
36
  QM=$(command -v qm 2>/dev/null || echo "$AQUI/qm")
37
37
 
38
+ # `--instalar-arranque` se traduce a la forma de PowerShell. La bandera se
39
+ # escribe igual en las tres plataformas —qm-barra, qm-indicator y ésta— para
40
+ # que el ofrecimiento de la primera corrida de `qm` no tenga que saber cuál
41
+ # está abajo; lo que cambia es que del otro lado del exec manda PowerShell, que
42
+ # nombra sus parámetros con un guion y en CamelCase.
43
+ if [ "${1-}" = "--instalar-arranque" ]; then
44
+ shift
45
+ set -- -InstalarArranque "$@"
46
+ fi
47
+
38
48
  # -WindowStyle Hidden deja una consola parpadeando un instante al arrancar.
39
49
  # Es el precio de no empaquetar un .exe, y pasa una sola vez por sesión.
40
50
  exec powershell.exe -NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden \
package/bin/qm-tray.ps1 CHANGED
@@ -101,12 +101,44 @@ param(
101
101
  # El tema es una lectura del registro, y en un runner de CI no está el que
102
102
  # uno quiere comprobar. En modo captura se fuerza a mano.
103
103
  [switch]$Oscuro,
104
- [switch]$Claro
104
+ [switch]$Claro,
105
+
106
+ # ── el arranque de sesión ─────────────────────────────────────────────
107
+ # Escribe el acceso directo en la carpeta de Inicio de Windows y sale. Es la
108
+ # misma bandera que `qm-barra --instalar-arranque` y `qm-indicator
109
+ # --instalar-arranque`, y existe para que quien ofrece la barra en la primera
110
+ # corrida de `qm` no tenga que saber qué hay abajo en cada plataforma.
111
+ #
112
+ # Va acá y no en el lanzador de WSL porque el acceso directo necesita la ruta
113
+ # de ESTE archivo en coordenadas de Windows, y este archivo la sabe sin
114
+ # traducir nada: `$PSCommandPath`. Del otro lado habría que pasarla por
115
+ # `wslpath` y volver a escaparla.
116
+ [switch]$InstalarArranque
105
117
  )
106
118
 
107
119
  Set-StrictMode -Version Latest
108
120
  $ErrorActionPreference = 'Stop'
109
121
 
122
+ if ($InstalarArranque) {
123
+ $sh = New-Object -ComObject WScript.Shell
124
+ $lnk = $sh.CreateShortcut((Join-Path $sh.SpecialFolders('Startup') 'quartermaster.lnk'))
125
+ $lnk.TargetPath = 'powershell.exe'
126
+ # -QmLinux se conserva: el arranque de sesión no pasa por el .bashrc, así que
127
+ # sin esto la bandeja no encontraría el qm de adentro de WSL.
128
+ # Se llama $linea y no $args: $args es una variable automática de PowerShell
129
+ # y pisarla adentro de un script es pedir un bug que no se ve.
130
+ $linea = '-NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File "' + $PSCommandPath + '"'
131
+ if ($QmLinux) { $linea += ' -QmLinux "' + $QmLinux + '"' }
132
+ if ($Iconos) { $linea += ' -Iconos "' + $Iconos + '"' }
133
+ $lnk.Arguments = $linea
134
+ # 7 es minimizado: sin esto parpadea una consola en cada inicio de sesión.
135
+ $lnk.WindowStyle = 7
136
+ $lnk.Description = 'quartermaster · cuota en la bandeja'
137
+ $lnk.Save()
138
+ Write-Host ('escrito: ' + $lnk.FullName)
139
+ exit 0
140
+ }
141
+
110
142
  # ¿Pidieron explícitamente el qm de adentro de WSL? Se captura ACÁ, al nivel
111
143
  # del script, y no adentro de ResolverQm: en una función $PSBoundParameters es
112
144
  # el de la función, así que allá esta pregunta siempre daría «no».
@@ -570,6 +602,54 @@ function PctDiario($pre) {
570
602
  # clave cambia sola y el mismo umbral puede volver a avisar. Sin eso, o
571
603
  # spameás cada minuto o avisás una sola vez en la vida.
572
604
 
605
+ # ── el registro ────────────────────────────────────────────────────────
606
+ #
607
+ # De las tres barras, ésta era la única MUDA. La de macOS anota desde 0.1.8 y la
608
+ # de GNOME desde antes; acá, si se te caía la bandeja, no quedaba rastro: las
609
+ # frases de error viajaban al panel y se perdían al cerrarlo. Medido el
610
+ # 2026-09-15 contando escrituras a un log: macOS 12, GNOME 24, Windows 0.
611
+ #
612
+ # Y sirvió inmediatamente: del lado de GNOME el log es lo único que dejó ver que
613
+ # el calentado se había parado siete horas antes.
614
+ #
615
+ # Va a un archivo y no al Visor de eventos: escribir ahí pide permisos de
616
+ # administrador para registrar la fuente, y una herramienta por usuario que se
617
+ # instala sin UAC no los tiene. Se recorta pasando 1 MB, como el de macOS.
618
+ $script:RutaLog = Join-Path $env:LOCALAPPDATA 'quartermaster\bandeja.log'
619
+ $script:LogUltimo = @{}
620
+ # Si la última lectura de qm fue una frase y no un objeto: sirve para anotar la
621
+ # VUELTA, que sin ella toda falla queda abierta para siempre.
622
+ $script:QmFallaba = $false
623
+
624
+ function Registrar {
625
+ param([string]$Evento, [hashtable]$Datos, [switch]$SoloSiCambia)
626
+ try {
627
+ $extra = ''
628
+ if ($Datos) {
629
+ $extra = ' ' + (($Datos.GetEnumerator() | Sort-Object Name |
630
+ Where-Object { $null -ne $_.Value } |
631
+ ForEach-Object { "$($_.Key)=$($_.Value)" }) -join ' ')
632
+ }
633
+ $linea = "$Evento$extra"
634
+ # Lo que se repite cada minuto no se lee. Con -SoloSiCambia, un evento que
635
+ # dice lo mismo que la vez pasada no se vuelve a escribir.
636
+ if ($SoloSiCambia) {
637
+ if ($script:LogUltimo[$Evento] -eq $linea) { return }
638
+ $script:LogUltimo[$Evento] = $linea
639
+ }
640
+ $dir = Split-Path $script:RutaLog -Parent
641
+ if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
642
+ if ((Test-Path $script:RutaLog) -and (Get-Item $script:RutaLog).Length -gt 1MB) {
643
+ $cola = Get-Content $script:RutaLog -Tail 500 -Encoding UTF8
644
+ Set-Content $script:RutaLog -Value $cola -Encoding UTF8
645
+ }
646
+ Add-Content -Path $script:RutaLog -Encoding UTF8 `
647
+ -Value ("{0} {1}" -f (Get-Date -Format 'yyyy-MM-dd HH:mm:ss'), $linea)
648
+ } catch {
649
+ # Un registro que rompe a la bandeja es peor que no tener registro.
650
+ }
651
+ }
652
+
573
653
  $script:RutaAvisos = Join-Path $env:LOCALAPPDATA 'quartermaster\avisados.json'
574
654
  $script:Vistos = @{}
575
655
  try {
@@ -1629,6 +1709,27 @@ function Leer {
1629
1709
  try { return ($salida | ConvertFrom-Json) } catch { return 'qm no devolvió JSON' }
1630
1710
  }
1631
1711
 
1712
+ # `Leer` devuelve un OBJETO cuando pudo y una FRASE cuando no. Esa frase se
1713
+ # mostraba en el panel y se perdía al cerrarlo: si qm fallaba a las tres de la
1714
+ # mañana, al otro día no había forma de saber por qué. Se anota el cambio, no
1715
+ # cada vuelta —una falla repetida cada minuto no se lee— y también la VUELTA,
1716
+ # porque sin ella toda falla queda abierta para siempre.
1717
+ function LeerAnotando {
1718
+ param([string]$argumentos)
1719
+ $r = Leer $argumentos
1720
+ if ($r -is [string]) {
1721
+ Registrar 'qm.sin-datos' @{ motivo = $r } -SoloSiCambia
1722
+ $script:QmFallaba = $true
1723
+ } else {
1724
+ if ($script:QmFallaba) {
1725
+ Registrar 'qm.volvio'
1726
+ $script:LogUltimo.Remove('qm.sin-datos')
1727
+ }
1728
+ $script:QmFallaba = $false
1729
+ }
1730
+ return $r
1731
+ }
1732
+
1632
1733
  # Cada cuánto volver a preguntarle al endpoint.
1633
1734
  #
1634
1735
  # Un intervalo fijo de 5 minutos es inservible para una barra que sube rápido:
@@ -2373,7 +2474,7 @@ function ModeloPaneles($datos, [bool]$avisar) {
2373
2474
  }
2374
2475
 
2375
2476
  function Refrescar {
2376
- $datos = Leer
2477
+ $datos = LeerAnotando
2377
2478
  # Los dos temas, que son dos claves distintas del registro y pueden no
2378
2479
  # coincidir. Si el de las apps cambió, AplicarTema rehace la paleta y vuelve a
2379
2480
  # vestir todos los menús; se redibujan igual acá abajo.
@@ -2668,7 +2769,7 @@ CrearFuentes
2668
2769
  # -Panel elige cuál: 'general' (el de todas las cuentas) o el nombre corto de
2669
2770
  # una, que es exactamente lo que muestra el ícono de esa cuenta.
2670
2771
  function Capturar([string]$ruta, [string]$cual) {
2671
- $datos = Leer
2772
+ $datos = LeerAnotando
2672
2773
  $m = ModeloPaneles $datos $false
2673
2774
  if (-not $cual) { $cual = 'general' }
2674
2775
  if (-not $m.paneles.Contains($cual)) {
@@ -2726,13 +2827,60 @@ $timer = New-Object System.Windows.Forms.Timer
2726
2827
  $timer.Interval = $Segundos * 1000
2727
2828
  # RevisarVersion va PRIMERO: si el archivo cambió, no tiene sentido gastar un
2728
2829
  # calentado y un redibujo con el código viejo antes de saltar al nuevo.
2729
- $timer.Add_Tick({ RevisarVersion; $null = Calentar; Refrescar })
2830
+ # Envuelto: una excepción adentro de un Add_Tick de WinForms se lleva puesta a
2831
+ # la aplicación entera con un diálogo que nadie va a ver, y la bandeja
2832
+ # desaparece sin dejar nada escrito. Anotarla y seguir es siempre mejor.
2833
+ $timer.Add_Tick({
2834
+ try {
2835
+ RevisarVersion
2836
+ $null = Calentar
2837
+ $script:CalentadoEn = Get-Date
2838
+ Refrescar
2839
+ } catch {
2840
+ Registrar 'tick.reventó' @{ error = $_.Exception.Message } -SoloSiCambia
2841
+ }
2842
+ })
2730
2843
  $timer.Start()
2731
2844
 
2845
+ # El vigía, por lo mismo que en GNOME y en macOS: que el calentado no pueda
2846
+ # dejar de ocurrir en silencio. Acá el riesgo es distinto —el Timer de WinForms
2847
+ # se repite solo, no hay un rearme único que se pueda cortar— pero la pregunta
2848
+ # que contesta es la misma: ¿cuánto hace que no le preguntamos al servidor?
2849
+ $script:CalentadoEn = Get-Date
2850
+ $script:VigiaAviso = $false
2851
+ $script:Vigia = New-Object System.Windows.Forms.Timer
2852
+ $script:Vigia.Interval = 60000
2853
+ $script:Vigia.Add_Tick({
2854
+ try {
2855
+ $atraso = (Get-Date) - $script:CalentadoEn
2856
+ if ($atraso.TotalSeconds -le (4 * $Segundos)) { $script:VigiaAviso = $false; return }
2857
+ if (-not $script:VigiaAviso) {
2858
+ Registrar 'calentar.parado' @{ hace = [int]$atraso.TotalSeconds }
2859
+ $script:VigiaAviso = $true
2860
+ }
2861
+ $null = Calentar
2862
+ $script:CalentadoEn = Get-Date
2863
+ Refrescar
2864
+ } catch {
2865
+ Registrar 'vigia.reventó' @{ error = $_.Exception.Message } -SoloSiCambia
2866
+ }
2867
+ })
2868
+ $script:Vigia.Start()
2869
+
2732
2870
  $script:Latido = New-Object System.Windows.Forms.Timer
2733
2871
  $script:Latido.Interval = 1000
2734
2872
  $script:Latido.Add_Tick({ LatirPie })
2735
2873
 
2874
+ # Qué arrancó: con qué qm —puede ser el nativo o el de adentro de WSL, y esa
2875
+ # elección decide si hay números o no hay nada—, con qué cadencia y con qué pid.
2876
+ $script:QmDeArranque = ResolverQm
2877
+ Registrar 'arranca' @{
2878
+ modo = $script:QmDeArranque.Modo
2879
+ qm = $script:QmDeArranque.Qm
2880
+ cadencia = $Segundos
2881
+ pid = $PID
2882
+ }
2883
+
2736
2884
  $null = Calentar
2737
2885
  Refrescar
2738
2886
 
@@ -2740,6 +2888,8 @@ try {
2740
2888
  [System.Windows.Forms.Application]::Run($script:Ctx)
2741
2889
  } finally {
2742
2890
  $timer.Stop()
2891
+ $script:Vigia.Stop()
2892
+ Registrar 'sale'
2743
2893
  $script:Latido.Stop()
2744
2894
  GuardarPrevios
2745
2895
  foreach ($ni in @($script:Bandeja.Values)) {
package/bin/qm.mjs CHANGED
@@ -43,6 +43,31 @@ const compilado = join(RAIZ, 'dist', 'cli', 'qm.js');
43
43
  const fuente = join(RAIZ, 'src', 'cli', 'qm.ts');
44
44
 
45
45
  if (sirveEsteNode() && existsSync(compilado)) {
46
+ // `src/adapters/opencode.ts` usa node:sqlite, que es experimental, así que
47
+ // Node escribe dos renglones en stderr en cada corrida:
48
+ //
49
+ // (node:56893) ExperimentalWarning: SQLite is an experimental feature…
50
+ // (Use `node --trace-warnings ...` to show where the warning was created)
51
+ //
52
+ // Eso no es de qm y no es para quien lo corre, pero sale por el mismo canal
53
+ // por el que qm explica: `qm --calentar` dice por ahí por qué una cuenta no
54
+ // se calentó, y las tres barras anotan esos renglones en su log. Medido el
55
+ // 2026-09-15: el journal del indicador de GNOME quedaba con dos warnings por
56
+ // cada pid de node y el motivo de verdad enterrado entre ellos.
57
+ //
58
+ // El lanzador de shell lo apaga con --disable-warning, pero por ACÁ no pasa:
59
+ // cuando el Node que corre sirve, el CLI se importa en este mismo proceso, y
60
+ // este proceso lo arrancó npm sin banderas. Así que se filtra a mano.
61
+ //
62
+ // Se saca SÓLO esa clase: el manejador de siempre se guarda y se le sigue
63
+ // pasando todo lo demás, para que una deprecación de verdad no se pierda.
64
+ const porDefecto = process.listeners('warning')[0];
65
+ process.removeAllListeners('warning');
66
+ process.on('warning', (w) => {
67
+ if (w.name === 'ExperimentalWarning') return;
68
+ if (porDefecto) porDefecto(w);
69
+ else console.error(w.stack ?? String(w));
70
+ });
46
71
  // El CLI hace su trabajo al importarse y maneja su propio código de salida.
47
72
  await import(pathToFileURL(compilado).href);
48
73
  } else {