shadok-ai 0.16.8 → 0.16.10

package/README.md

@@ -84,7 +84,8 @@ Enter to skip; you can add it later from the web UI).
   emoji, or **type a word** (`rocket`, `bug`, `money`…) to search for one; its
   **＋** creates the new agent straight into that group. Dragging an agent onto a
   group files it there, dragging groups reorders them, and double-clicking a name
-  renames it. A question the agent asks shows as an *Approval requested* card. The
+  renames it — a group can also be renamed by clicking its name at the top of the
+  agents column. A question the agent asks shows as an *Approval requested* card. The
   whole cockpit is skinned like Microsoft Teams (grey light mode / near-black dark
   mode, the Shadok mark in the header). On a phone the tools sit in the ⋯ menu and
   the agents sheet lists every group.
@@ -531,16 +532,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.8",
+  "version": "0.16.10",
   "main": "dist/session.js",
   "scripts": {
     "test": "node --import tsx --test --test-timeout=120000 test/*.ts context/*/test/*.test.mjs",

package/public/index.html

@@ -528,6 +528,9 @@
     overflow-y: auto;
   }
   #tabbar .side-label { padding: 0 8px 8px; font-size: 13px; font-weight: 600; color: var(--text); }
+  #tabbar .side-label #viewLabel.editable { cursor: text; border-radius: 4px; padding: 1px 3px; margin: -1px -3px; }
+  #tabbar .side-label #viewLabel.editable:hover { background: var(--bg-inset); box-shadow: inset 0 0 0 1px var(--line); }
+  #tabbar .side-label input.rename { font: inherit; width: calc(100% - 2em); }
   .tab {
     position: relative;
     display: flex;
@@ -3035,7 +3038,7 @@
     <div id="iconEmpty" class="icon-empty" hidden>No emoji for that word.</div>
   </div>
   <nav id="tabbar" aria-label="Agents">
-    <div class="label side-label"><span class="sl-all">Agents</span><span class="sl-view" id="viewLabel"></span></div>
+    <div class="label side-label"><span class="sl-all">Agents</span><span class="sl-view"><span id="viewIcon"></span> <span id="viewLabel"></span></span></div>
     <div id="ungrouped"></div>
     <div id="groups"></div>
     <p id="viewEmpty" class="check-hint" hidden>No agent in this group yet — create one, or drag one onto the group.</p>
@@ -3427,6 +3430,7 @@
 
   const $ = (id) => document.getElementById(id);
   const tabbar = $("tabbar"), newTabBtn = $("newTab"), newGroupBtn = $("newGroup");
+  const viewLabelEl = $("viewLabel");
   const ungroupedEl = $("ungrouped"), groupsEl = $("groups");
   const transcripts = $("transcripts"), thinking = $("thinking");
   const composer = $("composer"), promptInput = $("promptInput"), sendBtn = $("sendBtn");
@@ -4813,11 +4817,34 @@
       if (gi && gi.textContent !== g.icon) gi.textContent = g.icon;
     }
     const g = groups.find((x) => String(x.id) === v);
-    $("viewLabel").textContent = g ? `${g.icon} ${g.nameEl.textContent}` : "Main";
+    $("viewIcon").textContent = g ? g.icon : "";
+    // A cached reference, never $("viewLabel"): while it is being renamed the
+    // span is swapped out for the input, and a lookup by id would return null
+    // and throw on the very next sync.
+    viewLabelEl.textContent = g ? g.nameEl.textContent : "Main";
+    // Only a real group can be renamed here: "Main" is the ungrouped view, not
+    // a group, and has no name of its own to store.
+    viewLabelEl.classList.toggle("editable", !!g);
+    viewLabelEl.title = g ? "Click to rename this group" : "";
     $("viewEmpty").hidden = tabsInView(v).length > 0 || v === "ungrouped";
     renderRail();
   }
 
+  // The column's title names the group you are looking at, so it is where one
+  // reaches to rename it — the rail item needs a double-click and, collapsed to
+  // icons, shows no name at all. Wired ONCE on the stable span: applyView
+  // rewrites its text, never the element.
+  viewLabelEl.addEventListener("click", (e) => {
+    const g = groups.find((x) => String(x.id) === currentView());
+    if (!g) return;
+    e.stopPropagation();
+    inlineRename(tabbar, viewLabelEl, (v) => {
+      g.nameEl.textContent = v;
+      persistGroups();
+      applyView();
+    });
+  });
+
   const moodOf = (t) =>
     ["needs-answer", "unread", "working"].find((m) => t.btnEl.classList.contains(m)) || null;
 
@@ -7095,51 +7122,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