shadok-ai 0.16.6 → 0.16.9

package/README.md

@@ -531,16 +531,19 @@ every 25s (tunable with `SHADOK_WS_PING_MS`) to keep the connection warm, so no
 proxy change is normally needed; if your proxy still cuts it, raise
 `proxy_read_timeout` above the ping interval.
 
-**Sleep / wake.** When a laptop sleeps, the socket's TCP connection usually dies
-without the browser ever seeing a `close`, so it keeps reporting the link as
-"open" while nothing flows. On wake the cockpit no longer trusts that stale
-state: a real wake — the page becoming visible after more than ~10s away, a
-network change (`online`), or a page restored from the back/forward cache —
-tears the suspect socket down and opens a fresh one at once, reattaching to the
-same session. A quick tab switch is left alone (the link is almost certainly
-fine), so you don't pay a reconnect every time you glance away. Previously a
-woken tab waited out the browser's own TCP timeout, tens of seconds to minutes,
-stuck on "reconnecting…".
+**Sleep / wake / network blips.** When the machine comes back (an `online`
+event, the tab becoming visible, a back/forward-cache restore), the cockpit
+revives the links that actually **dropped** — resetting their backoff so a
+genuinely-closed socket reconnects promptly instead of waiting out a delay that
+climbed while you were away. A socket that still reports "open" is left alone:
+`online` fires on every network blip (wifi roam, VPN, interface change), and
+force-reconnecting healthy links on each one reconnected all your agents at
+once — tripping the upstream single-use-token OAuth refresh race so a batch
+stuck on "connecting…". A slept socket that looks "open" but is dead is
+terminated by the server heartbeat (~50s) and reconnects on the resulting
+`close` without that churn. Only a back/forward-cache restore force-replaces an
+"open" socket, because there the restored page's old sockets are dead yet fire
+no `close`.
 
 ### Cross-instance peers
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shadok-ai",
-  "version": "0.16.6",
+  "version": "0.16.9",
   "main": "dist/session.js",
   "scripts": {
     "test": "node --import tsx --test --test-timeout=120000 test/*.ts context/*/test/*.test.mjs",

package/public/index.html

@@ -2272,6 +2272,20 @@
   .tab .lastat, .tab .ctxnum { font-size: 11px; color: var(--text-dim); }
   .tab.active { border-left: 0; border-radius: 6px; box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1); background: var(--bg-raised); font-weight: 600; }
   :root:not([data-mode="light"]) .tab.active { background: var(--bg-inset); box-shadow: inset 0 0 0 1px var(--line); }
+  /* A working agent must stay visible in light mode. Two things hid it: 12% of
+     the accent over a near-white panel is barely a tint, and the white
+     `.tab.active` above comes later at the same weight, so the agent you are
+     watching — the one most likely to be working — went plain white. The tint
+     is mixed INTO the surface (opaque) and the selectors outweigh both
+     `.tab.active` rules, so the active tab keeps its state colour in either mode.
+     `background-COLOR`, never the shorthand: `background` expands to
+     `background-image: none`, and these selectors outweigh `.tab.has-bg`, so the
+     shorthand silently erased the green hatch of an agent with background work
+     still running (measured: light mode, a working non-active row lost it). */
+  :root[data-mode="light"] .tab.working,
+  :root[data-mode="light"] .rail-item.working { background-color: color-mix(in srgb, var(--amber) 22%, var(--bg-raised)); }
+  :root[data-mode="light"] .tab.working.active { background-color: color-mix(in srgb, var(--amber) 18%, var(--bg-raised)); }
+  :root:not([data-mode="light"]) .tab.working.active { background-color: color-mix(in srgb, var(--amber) 16%, var(--bg-inset)); }
   .tab.active .tav .led { border-color: var(--bg-raised); }
   .tab.unread { border-left: 0; border-radius: 6px; font-weight: 700; }
   .group-head { gap: 10px; padding: 8px; font-size: 14px; color: var(--text); border-radius: 6px; }
@@ -7081,51 +7095,45 @@
   // off. Bounded so an update that never lands doesn't leave us hammering.
   let reloadExpectedUntil = 0;
 
-  /** Reconnect every dropped tab immediately (no backoff wait) — fired when the
-   *  machine/tab comes back (online / visible), the common laptop-wake case.
-   *  `force` replaces even a socket that still reports OPEN: after a laptop
-   *  sleep the TCP connection is usually dead while the browser has seen no
-   *  `close`, so `readyState` lies "OPEN" and the gentle path would skip the
-   *  tab — leaving it stranded until the browser's own TCP timeout fires
-   *  (tens of seconds to minutes), which is exactly the "stuck reconnecting,
-   *  very slow" symptom. A CONNECTING socket is always left alone: a link is
-   *  already in flight, and tearing it down would only restart the clock. */
+  /** Revive the tabs whose link actually DROPPED — fired when the machine/tab
+   *  comes back (online / visible). It resets the backoff and reconnects at
+   *  once, so a genuinely-closed socket comes back promptly instead of waiting
+   *  out an exponential delay that climbed while we were away.
+   *
+   *  It deliberately does NOT touch a socket that still reports OPEN. An earlier
+   *  version force-replaced OPEN sockets too (to catch a laptop-sleep "zombie" —
+   *  OPEN on the client, dead on the wire). But `online` fires on EVERY network
+   *  blip (wifi roam, VPN, interface change), and force-closing every healthy
+   *  link on each blip reconnected all N agents at once — tripping the upstream
+   *  OAuth refresh-token race (single-use tokens, concurrent `claude --resume`,
+   *  biting at ~10–30 agents) so a whole batch stuck on "connecting…". That mass
+   *  churn was worse than the zombie it chased: a slept socket is terminated by
+   *  the server heartbeat (~50s) and the resulting `close` reconnects it anyway,
+   *  no force needed. `force` is kept ONLY for a bfcache `pageshow`, where the
+   *  restored page's old sockets are genuinely dead and fire no `close`. */
   function reconnectAllNow(force) {
     for (const t of tabs) {
       if (t.closing || !t.sessionId) continue;
       const st = t.ws && t.ws.readyState;
       if (st === WebSocket.CONNECTING) continue;      // a link is already on its way
-      if (st === WebSocket.OPEN && !force) continue;  // healthy and no reason to doubt it
+      if (st === WebSocket.OPEN && !force) continue;  // healthy — leave it, a blip is not a death
       if (t.reconnectTimer) clearTimeout(t.reconnectTimer);
-      t.reconnectAttempts = 0;
+      t.reconnectAttempts = 0;                        // reset the backoff: reconnect promptly, not after a climbed delay
       const old = t.ws;
       openLink(t);                                    // replaces t.ws with the fresh socket
-      // Close the suspected-zombie only after openLink swapped t.ws, so its
+      // Close a forced (bfcache) zombie only after openLink swapped t.ws, so its
       // `close` handler sees `t.ws !== ws` and does not schedule a competing
       // reconnect. A no-op when `old` was already closed.
       if (old && old !== t.ws) { try { old.close(); } catch {} }
     }
   }
 
-  // A real wake (laptop sleep, bfcache restore, a network change) must force a
-  // fresh link; a quick tab switch must not — forcing there would flash
-  // "reconnecting" and pay a resume round-trip every time you glance away.
-  // The tell is how long we were hidden: seconds for an alt-tab, minutes for a
-  // sleep. `online` and a bfcache `pageshow` are forced outright — the network
-  // or the page itself just changed under us.
-  const STALE_WAKE_MS = 10_000;
-  let hiddenAt = 0;
-  function wokeAfterLongAway() {
-    const away = hiddenAt ? Date.now() - hiddenAt : 0;
-    hiddenAt = 0;
-    return away > STALE_WAKE_MS;
-  }
-  window.addEventListener("online", () => reconnectAllNow(true));
-  window.addEventListener("pageshow", (e) => reconnectAllNow(!!e.persisted || wokeAfterLongAway()));
-  document.addEventListener("visibilitychange", () => {
-    if (document.hidden) { hiddenAt = Date.now(); return; }
-    reconnectAllNow(wokeAfterLongAway());
-  });
+  // Reconnect the links that dropped while we were away — but never disturb a
+  // healthy one (see reconnectAllNow). Only a bfcache restore forces, because
+  // there the old sockets are dead yet fire no `close`.
+  window.addEventListener("online", () => reconnectAllNow(false));
+  window.addEventListener("pageshow", (e) => reconnectAllNow(!!e.persisted));
+  document.addEventListener("visibilitychange", () => { if (!document.hidden) reconnectAllNow(false); });
 
   /**
    * Lists the agents alive in the server right now — including ones spawned