ccdeck 3.44.0 → 3.46.0

package/dist/web/assets/{index-BQbOfxbL.js → index-DmENqVdt.js}

@@ -1 +1 @@
-import"./app-CQIstkMF.js";(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const e of document.querySelectorAll('link[rel="modulepreload"]'))i(e);new MutationObserver(e=>{for(const r of e)if(r.type==="childList")for(const o of r.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&i(o)}).observe(document,{childList:!0,subtree:!0});function s(e){const r={};return e.integrity&&(r.integrity=e.integrity),e.referrerPolicy&&(r.referrerPolicy=e.referrerPolicy),e.crossOrigin==="use-credentials"?r.credentials="include":e.crossOrigin==="anonymous"?r.credentials="omit":r.credentials="same-origin",r}function i(e){if(e.ep)return;e.ep=!0;const r=s(e);fetch(e.href,r)}})();
+import"./app-DhGvSH7o.js";(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const e of document.querySelectorAll('link[rel="modulepreload"]'))i(e);new MutationObserver(e=>{for(const r of e)if(r.type==="childList")for(const o of r.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&i(o)}).observe(document,{childList:!0,subtree:!0});function s(e){const r={};return e.integrity&&(r.integrity=e.integrity),e.referrerPolicy&&(r.referrerPolicy=e.referrerPolicy),e.crossOrigin==="use-credentials"?r.credentials="include":e.crossOrigin==="anonymous"?r.credentials="omit":r.credentials="same-origin",r}function i(e){if(e.ep)return;e.ep=!0;const r=s(e);fetch(e.href,r)}})();

package/dist/web/index.html

@@ -77,9 +77,9 @@
         document.documentElement.setAttribute("data-density", density === "tightest" || density === "tighter" || density === "compact" || density === "comfortable" ? density : "default");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-BQbOfxbL.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/app-CQIstkMF.js">
-    <link rel="stylesheet" crossorigin href="/assets/app-Ch-0CYlK.css">
+    <script type="module" crossorigin src="/assets/index-DmENqVdt.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/app-DhGvSH7o.js">
+    <link rel="stylesheet" crossorigin href="/assets/app-BlRY6EME.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdeck",
-  "version": "3.44.0",
+  "version": "3.46.0",
   "description": "Local dashboard for Claude Code and Codex CLI sessions: which Claude Code session needs input, every tool call and Claude Code subagent live, token cost and quota, several Claude accounts. Run npx ccdeck.",
   "type": "module",
   "bin": {

package/release-notes.json

@@ -80,6 +80,54 @@
     "3.43.1",
     "3.43.3"
   ],
+  "3.46.0": [
+    {
+      "title": "🔗 Jira, GitHub and GitLab panels are easier to read and navigate",
+      "body": "Jira rows show each issue's status, lists answer the arrow keys and fit a phone, and a failed refresh says “Not updated”."
+    },
+    {
+      "title": "📡 Radar finds more Claude Code processes on Linux",
+      "body": "It now sees Claude Code started from its versioned install folder, plus connection attempts that got no reply and the telemetry variables it was launched with."
+    },
+    {
+      "title": "🗺️ Plans are easier to follow on the session canvas",
+      "body": "A session's plan now shows on its note and as “plan 2/5” at every zoom. Subagents line up in one column, closer to their parent."
+    },
+    {
+      "title": "✅ The active account follows your Claude Code login",
+      "body": "After a /login, the accounts panel, Switch, Auto-switch and Usage use the account Claude Code is signed in to. Auto-switch can now be set up while it is off."
+    },
+    {
+      "title": "📊 Account capacity and the Reset calendar have their own buttons",
+      "body": "Both open from the left stripe, under Claude accounts, instead of from the small gauge in the accounts panel's header."
+    },
+    {
+      "title": "🧩 Skill activity has its own button and counts typed skills",
+      "body": "It opens from the right stripe. To count skills you start with a slash command, the deck now adds a UserPromptExpansion hook to Claude Code's settings.json (2.1.116 or newer); AGENTS_DECK_SKILL_HOOK=0 leaves it out."
+    },
+    {
+      "title": "📈 Load history keeps the reading you click",
+      "body": "Click a minute on a chart to keep its reading. Saved limit resets now show their expiry time, and Tool activity has a clearer icon."
+    }
+  ],
+  "3.45.0": [
+    {
+      "title": "🔗 Read-only Jira, GitHub and GitLab panels beside your agents",
+      "body": "Settings › Integrations connects Jira (Cloud, Server or Data Center), GitHub, and GitLab.com or your own GitLab, each with a token, and a control on the left stripe opens its panel: a Jira board's backlog in Jira's own order, or a project's branches, pull or merge requests, pipelines and issues, with the item beside the list. The panels only read: they never comment, merge, re-run a job or change an issue. The token stays on this machine, in a file only you can read, and goes only to that connection's own API. Nothing is read until you connect a tracker, and then only while its panel is open."
+    },
+    {
+      "title": "📤 Each account says what its organization's telemetry sends",
+      "body": "A Team or Enterprise organization can turn on Claude Code's telemetry for every member, and Claude Code applies it without asking. Each account of such an organization now carries a line under its name: “Telemetry · usage data”, or “Telemetry · prompts, tool details” in the warning colour when your prompts and tool details are sent too. Its tooltip names the organization and where the data goes. After a switch, Auto-switch's notification and the row's “Now active” note say it too. The deck changes nothing; it learns what the organization turns on from a Claude Code session run on one of its accounts, and until then that account shows no line."
+    },
+    {
+      "title": "⚠️ A warning when a paired deck is on the same Claude login",
+      "body": "A Claude login renews once, so when two machines use one copied login, the one that renews second is signed out. When a paired deck on Local network says it is on the login this deck is using, the live account's row now says “Also active on” and names that deck, with what to do: use a different account on one of the machines, or sign in on each one separately. A switch onto such a login says so too, and so does one desktop notification per incident, “Login active on another deck” in Settings › Notifications, which is on by default."
+    },
+    {
+      "title": "📱 A phone opens one panel at most when the deck loads",
+      "body": "On a window 640 px wide or less, a reload used to open Accounts, Usage and the machine panel on top of each other, with none of the board in sight. It now opens at most one of them, preferring Usage over the machine panel, and Accounts and the session list open from the dock. A wider window loads exactly as before, and nothing you chose is forgotten."
+    }
+  ],
   "3.44.0": [
     {
       "title": "⛔ A turn that stops on an error now shows as stopped",

package/src/server/account-notify.mjs

@@ -1,4 +1,4 @@
-// Four notifications about the accounts the deck is on, and the rules for when
+// Five notifications about the accounts the deck is on, and the rules for when
 // each is said.
 //
 //   SWAP       the deck's own auto-switch tick moved the live Claude account.
@@ -13,6 +13,11 @@
 //              every session on the machine shares the login, so they stop
 //              together — with how many stopped and that each needs a
 //              "continue" once a working login is active.
+//   ELSEWHERE  the Claude account this deck is on is the one a paired deck says
+//              it is on too (#2192). Said once per incident — from the moment
+//              both are on it until one of them is not — because the next
+//              renewal signs one of the two machines out, and nothing on the
+//              desktop says so before it does. See lan-elsewhere.mjs.
 //
 // SPARSE BY CONSTRUCTION. Each window is a record keyed by provider, account
 // and window, holding the reset instant it is about and the levels already said
@@ -42,6 +47,7 @@
 // injected — the shape block-notify.mjs uses, for the reason it gives: what the
 // suite cannot run is what drifts.
 import { switchCanCure } from "./stop-failure.mjs";
+import { deckList } from "./lan-elsewhere.mjs";
 
 /** The levels a window is announced at, lowest first. */
 export const LEVELS = Object.freeze([90, 100]);
@@ -403,6 +409,23 @@ export function stuckNotice({ fromName }) {
   return { who: SWAP_WHO, body: `${from}'s login expired · no other account is ready to switch to` };
 }
 
+/**
+ * "Claude · work@x.com", "Also active on iMac. When one machine renews this
+ * login, the other is signed out — use a different account on one of them."
+ *
+ * The decks by the names Local network's list gives them. The reason is the
+ * sentence, because it is the whole of why this is worth a notification: the
+ * same account on two machines is ordinary, one copied login live on two is
+ * what breaks, and the remedy is one press on either machine.
+ */
+export function elsewhereNotice({ accountName, decks }) {
+  return {
+    who: whoFor("claude", accountName),
+    body: `Also active on ${cut(deckList(decks), NAME_MAX)}. When one machine renews this login, the other is `
+      + "signed out — use a different account on one of them.",
+  };
+}
+
 /** The records, as read back from disk: anything that is not one is dropped,
  *  and so is one nobody has read for RECORD_KEEP_MS. */
 export function normaliseRecords(raw, now) {
@@ -435,9 +458,9 @@ function laterUnref(fn, ms) {
  *
  *   notify(title, body, meta)  the OS call — injected, never awaited by a poll
  *                              or a tick, and its failure goes to `onError`
- *   settings()                 `{ swap, quota, reset, stopped }`, asked per
- *                              decision, so a switch pressed mid-run takes
- *                              effect at once
+ *   settings()                 `{ swap, quota, reset, stopped, elsewhere }`,
+ *                              asked per decision, so a switch pressed mid-run
+ *                              takes effect at once
  *   load() / save(records)     the disk, both best effort
  *   now, later                 the clock and the hold timer, for the suite
  *
@@ -459,6 +482,11 @@ export function createAccountNotifier({
   let policy = null;
   /** Threshold notices held for a tick, by record key. */
   const held = new Map();
+  /** The account whose ELSEWHERE incident is open — this deck and another on
+   *  it — and therefore already said, or null. One at a time, because this
+   *  deck is on one account at a time. Kept in memory: a restart in the middle
+   *  of an incident says it once more, which is a restart's news as well. */
+  let elsewhereOpen = null;
   let holdTimer = null;
   let saving = Promise.resolve();
   /** The stop incident being gathered or held, or the one already said while
@@ -617,8 +645,13 @@ export function createAccountNotifier({
    * `{ email, organizationUuid, alias }` — read after the tick, for the names
    * and the keys of the two accounts a switch moved between. `startedAt` is
    * when the tick began, which decides whether it can answer for a stop.
+   *
+   * `telemetryOf`, when given, answers what an organization's telemetry
+   * settings turn on, as one sentence or null (org-telemetry.mjs's
+   * telemetryClause): the swap notice carries it for the account it moved to,
+   * because an unattended switch is exactly when nobody saw it coming.
    */
-  async function tick(result, accounts, { startedAt = null } = {}) {
+  async function tick(result, accounts, { startedAt = null, telemetryOf = null } = {}) {
     try {
       await ready;
       if (!result || typeof result !== "object") return;
@@ -686,7 +719,12 @@ export function createAccountNotifier({
           cured.said = true;
           if (cured.timer) { clearTimeout(cured.timer); cured.timer = null; }
         }
-        say(cured && s.stopped ? withStopped(notice, cured.ids.size) : notice);
+        const told = cured && s.stopped ? withStopped(notice, cured.ids.size) : notice;
+        // Only for an account the store and the tick agree on: an organization
+        // read off the wrong slot would put another company's policy on it.
+        const toOrg = to?.key ? accounts?.[String(result.to?.number)]?.organizationUuid : null;
+        const telemetry = toOrg && telemetryOf ? telemetryOf(toOrg) : null;
+        say(telemetry ? { ...told, body: `${told.body}\n${telemetry}` } : told);
       }
       await persist();
     } catch (err) {
@@ -721,11 +759,35 @@ export function createAccountNotifier({
     }
   }
 
+  /**
+   * What Local network says about the account this deck is on: `account` is
+   * `{ key, name }`, or null when this deck is on none, and `decks` the paired
+   * decks that say they are on it too, by name.
+   *
+   * ONCE PER INCIDENT. The incident opens when both are on it, is said then —
+   * if the switch is on at that moment — and closes when either moves off it
+   * or the other deck stops saying so (lan-elsewhere.mjs holds a deck's word
+   * for five minutes, which is what keeps a dropped round from closing it). A
+   * new one is news again; the same one, every minute, is not.
+   */
+  async function elsewhere(account, decks) {
+    try {
+      await ready;
+      const key = account?.key && Array.isArray(decks) && decks.length > 0 ? account.key : null;
+      if (key === elsewhereOpen) return;
+      elsewhereOpen = key;
+      if (key && settings().elsewhere) say(elsewhereNotice({ accountName: account.name, decks }));
+    } catch (err) {
+      onError?.(err);
+    }
+  }
+
   return {
     ready,
     observe,
     tick,
     stopped,
+    elsewhere,
     /** The loop was switched on or off. Off, nothing will carry what is held. */
     autoSwitch(on) {
       autoOn = on === true;

package/src/server/account-watch.mjs

@@ -24,6 +24,10 @@ import { writeFileAtomic } from "./atomic-write.mjs";
 // What a StopFailure says, and the words a notification names a session by.
 import { stopFailureOf, switchCanCure } from "./stop-failure.mjs";
 import { whoOf } from "./block-notify.mjs";
+// Which deck is on what, as Local network last heard it, and the identity rule
+// its keys are made by (#2192).
+import { elsewhereNow } from "./lan-elsewhere.mjs";
+import { accountKey } from "./lan-copies.mjs";
 
 const PKG_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
@@ -42,10 +46,19 @@ export function recordsPath(home = deckDataDir()) {
  */
 export const WATCH_MS = 2 * 60_000;
 
+/**
+ * How often the notifier asks Local network whether the account this deck is
+ * on is live on another deck too (#2192). A round is a minute, so asking more
+ * often finds nothing new; and with no deck on any account of this one's, the
+ * look is the engine's status and nothing else — the store is not read.
+ */
+export const ELSEWHERE_WATCH_MS = 60_000;
+
 let _deps = null;
 let _notifier = null;
 let _autoOn = false;
 let _timer = null;
+let _elsewhereTimer = null;
 let _watching = null;
 /** The auto-switch loop's "tick now", handed in by the loop as it loads
  *  (cswap-auto-loop.mjs `tickSoon`). Null until then, and on a deck that never
@@ -110,11 +123,23 @@ export function noteAutoTick(result, meta = {}) {
   if (!n || !result) return Promise.resolve();
   // A dead login with nowhere to go is named too, so its notice can say whose.
   const named = result.switched || result.reason === "login-expired";
-  return (named ? storeAccounts() : Promise.resolve(null))
-    .then(accounts => n.tick(result, accounts, meta))
+  return (named ? Promise.all([storeAccounts(), result.switched ? telemetryReader() : null]) : Promise.resolve([null, null]))
+    .then(([accounts, telemetryOf]) => n.tick(result, accounts, { ...meta, telemetryOf }))
     .catch(() => {});
 }
 
+/** What each organization's settings were last seen to turn on, as the
+ *  sentence a swap notice carries (org-telemetry.mjs), or null. */
+async function telemetryReader() {
+  try {
+    const { knownOrgTelemetry, telemetryClause } = await import(pathToFileURL(join(PKG_ROOT, "src/server/org-telemetry.mjs")).href);
+    const records = await knownOrgTelemetry();
+    return org => telemetryClause(records?.[org]);
+  } catch {
+    return null;
+  }
+}
+
 /** The loop's way to be asked for a tick now. Called once, as it loads. */
 export function connectEarlyTick(fn) {
   _tickSoon = typeof fn === "function" ? fn : null;
@@ -199,6 +224,35 @@ export function watchOnce(providers) {
   return _watching;
 }
 
+/**
+ * One look at whether the account this deck is on is one a paired deck says it
+ * is on too, handed to the notifier, which says it once per incident.
+ *
+ * The store is read only when some deck is on some account, and through the
+ * roster's own cache, which the panel and every LAN round already keep warm. A
+ * roster that could not be read says nothing and closes nothing: not knowing
+ * which account this deck is on is not the same as being on none.
+ */
+export async function watchElsewhereOnce(now = Date.now()) {
+  const n = notifier();
+  if (!n) return;
+  try {
+    const on = elsewhereNow(now);
+    if (on.size === 0) return n.elsewhere(null, []);
+    const { fetchClaudeAccounts } = await import(pathToFileURL(join(PKG_ROOT, "src/server/claude-accounts.mjs")).href);
+    const got = await fetchClaudeAccounts();
+    if (!got?.ok || !Array.isArray(got.accounts)) return;
+    const live = got.accounts.find(a => a?.active === true);
+    if (!live?.email) return n.elsewhere(null, []);
+    const key = accountKey(live.email, live.orgUuid);
+    const name = typeof live.alias === "string" && live.alias.trim() ? live.alias.trim() : live.email;
+    return n.elsewhere({ key, name }, on.get(key) ?? []);
+  } catch {
+    // The roster's own failures are its panel's to say; here there is nothing
+    // to compare this time.
+  }
+}
+
 /**
  * Start reading quota on a timer, from startServer once the port is bound —
  * never at import, because a launcher imports the server module only to ask
@@ -210,4 +264,9 @@ export function startAccountWatch({ providers } = {}) {
   _timer.unref?.();
   const first = setTimeout(() => { watchOnce(providers).catch(() => {}); }, 15_000);
   first.unref?.();
+  // And Local network's word on the account this deck is on, on its own clock:
+  // it costs nothing while no deck is on anything, and it is said whichever of
+  // the quota switches is on.
+  _elsewhereTimer = setInterval(() => { watchElsewhereOnce().catch(() => {}); }, ELSEWHERE_WATCH_MS);
+  _elsewhereTimer.unref?.();
 }

package/src/server/claude-accounts.mjs

@@ -52,9 +52,17 @@ import { nextReadAt, nudgeCollector } from "./claude-collector.mjs";
 // (#1893). Pure, and keyed the way LAN sync keys accounts.
 import { hasRecovered, reauthFor } from "./account-origins.mjs";
 import { accountKey } from "./lan-copies.mjs";
+// What each organization's Claude settings were last seen to turn on, so a row
+// can say it before anyone switches to the account. See its header for when the
+// shared remote-settings.json can be pinned on an organization at all.
+import { observeOrgTelemetry } from "./org-telemetry.mjs";
 // Whether a switch target's stored login is known dead, and whether a
 // collection would read it first (#2184). Pure, and imports nothing.
 import { collectionWouldRead, deadLoginOf } from "./login-guard.mjs";
+// Which slot is active: the one Claude Code is signed in as, matched the way
+// `cswap list` matches it, rather than the number only cswap's own commands
+// move. See its header for the drift that made this a module.
+import { activeFrom, readLiveLogin } from "./claude-login.mjs";
 import { dirname, join } from "node:path";
 import { existsSync } from "node:fs";
 import { homedir, platform } from "node:os";
@@ -228,19 +236,14 @@ async function readJson(path) {
   }
 }
 
-/** claude-swap's sequence.json — the accounts, their order and which slot is
- *  active — or null when it is missing or will not parse. seedFirstAccount
- *  tells those two apart first, so it reads the file itself. */
+/** claude-swap's sequence.json — the accounts, their order and which slot
+ *  cswap last recorded as active (which is not always who is signed in: see
+ *  claude-login.mjs) — or null when it is missing or will not parse.
+ *  seedFirstAccount tells those two apart first, so it reads the file itself. */
 async function readSequence(root) {
   return readJson(join(root, "sequence.json"));
 }
 
-/** The slot a sequence.json names as active, as the string its `accounts` are
- *  keyed by, or null when it names none. */
-function activeSlot(seq) {
-  return seq?.activeAccountNumber != null ? String(seq.activeAccountNumber) : null;
-}
-
 /** The usage rows in claude-swap's cache/usage.json, keyed by slot — see
  *  usageRows for which of them may be believed. */
 async function readUsageRows(root) {
@@ -467,18 +470,27 @@ async function readRoster(now, gen) {
   }
 
   const rows = await readUsageRows(root);
+  const orgTelemetry = await observeOrgTelemetry({ seq }).catch(() => ({}));
+
+  // WHO IS ACTIVE IS WHO CLAUDE CODE IS SIGNED IN AS. sequence.json's
+  // activeAccountNumber moves only when a cswap command switches, so a
+  // `/login` made anywhere else left the panel on the previous account for
+  // good, and every decision taken from the roster — Switch, Auto-switch, the
+  // expired-login guard, the paired decks' in-use mark — with it. Read on every
+  // roster read; the stored number stands only when no login can be read.
+  const active = activeFrom(seq, await readLiveLogin());
 
   // Kick a collection for the NEXT poll if anything is due — either because
   // claude-swap's schedule says so, or because an account has never been
   // fetched at all.
-  nudgeCollector(rows, Object.keys(seq.accounts), now, seq.activeAccountNumber);
+  nudgeCollector(rows, Object.keys(seq.accounts), now, active.num);
 
   // Who the CLI says is signed in, asked ONLY when the store claims the active
   // account is in trouble — see authTrouble. That is the one case where the
   // stored verdict and the live truth can disagree, and it is rare: a healthy
   // machine never spends this subprocess. Never fatal, because a CLI that
   // cannot be reached is not evidence either way.
-  const activeNum = activeSlot(seq);
+  const activeNum = active.num;
   const activeRow = activeNum ? rows[activeNum] : null;
   const identity = (activeRow?.consecutiveFailures ?? 0) > 0
     ? await currentIdentity().catch(() => null)
@@ -500,7 +512,7 @@ async function readRoster(now, gen) {
     const row = rows[num];
     const key = accountKey(acct.email, acct.organizationUuid);
     const origin = Object.hasOwn(origins, key) ? origins[key] : null;
-    const shown = rosterRow({ seq, num, acct, row, identity, now, key, origin });
+    const shown = rosterRow({ activeNum, num, acct, row, identity, now, key, origin, telemetry: orgTelemetry[acct.organizationUuid] ?? null });
     accounts.push(shown);
     // A put-off incident is over once a read succeeds after it, and the
     // put-off goes with it (#1893) — said here, where the read is, rather than
@@ -509,7 +521,12 @@ async function readRoster(now, gen) {
   }
   tidyOrigins(origins, recovered, seq.accounts);
 
-  return finish({ ok: true, accounts, activeNum: seq.activeAccountNumber ?? null, fetchedAt: now });
+  // `unlistedLogin`: Claude Code is signed in as an account claude-swap does
+  // not hold, so no row is active and the panel says whose login it is.
+  return finish({
+    ok: true, accounts, activeNum: activeNum != null ? Number(activeNum) : null,
+    unlistedLogin: active.unlisted, fetchedAt: now,
+  });
 }
 
 /**
@@ -527,7 +544,7 @@ function observedMs(seconds) {
   return Number.isFinite(ms) && ms > 0 && Number.isFinite(new Date(ms).getTime()) ? ms : null;
 }
 
-function rosterRow({ seq, num, acct, row, identity, now, key, origin = null }) {
+function rosterRow({ activeNum, num, acct, row, identity, now, key, origin = null, telemetry = null }) {
   const matches = rowIsFor(row, acct);
   const good = matches ? row.lastGood : null;
 
@@ -535,7 +552,8 @@ function rosterRow({ seq, num, acct, row, identity, now, key, origin = null }) {
   // When claude-swap last TRIED, well or not. A refusal counts against a login
   // only when it came after the deck last signed that login in (#1893).
   const attemptedAtMs = matches ? observedMs(row.lastAttemptAt) : null;
-  const isActive = String(seq.activeAccountNumber) === num;
+  // The slot Claude Code is signed in as, from readRoster (claude-login.mjs).
+  const isActive = activeNum === num;
   const trouble = authTrouble(row, {
     matches, isActive, identity, email: acct.email, fetchedAt: fetchedAtMs, now,
   });
@@ -617,6 +635,11 @@ function rosterRow({ seq, num, acct, row, identity, now, key, origin = null }) {
     // claude-swap has refused its login since: `{ key, since, dismissed }`.
     // `key` and `since` together name it, for "Not now" to send back.
     reauth: reauth ? { key, ...reauth } : null,
+    // What this account's organization last turned on for Claude Code's
+    // telemetry export, when the deck has seen its settings (org-telemetry.mjs):
+    // `{ orgName, level, content, destinations, seenAt }`. `level` "off" was
+    // seen off; null was never seen, which is unknown and not "off".
+    telemetry: telemetry ?? null,
   };
 }
 
@@ -703,12 +726,13 @@ export function authTrouble(row, {
  *
  * Returns null rather than a partial when anything about the row is unsure:
  * the caller's fallback is to fetch for itself, and a wrong number is worse
- * than a slow one.
+ * than a slow one. That includes a login claude-swap does not hold: there is
+ * no row for it, and the stored active slot's would be someone else's numbers.
  */
 export async function activeAccountUsage() {
   const root = backupRoot();
   const seq  = await readSequence(root);
-  const num  = activeSlot(seq);
+  const num  = activeFrom(seq, await readLiveLogin()).num;
   const acct = num ? seq?.accounts?.[num] : null;
   if (!acct) return null;
 
@@ -742,7 +766,7 @@ export async function requestCollection() {
   const seq   = await readSequence(root);
   if (!seq?.accounts) return false;
   const rows  = await readUsageRows(root);
-  return nudgeCollector(rows, Object.keys(seq.accounts), Date.now(), seq.activeAccountNumber);
+  return nudgeCollector(rows, Object.keys(seq.accounts), Date.now(), activeFrom(seq, await readLiveLogin()).num);
 }
 
 /**
@@ -817,7 +841,9 @@ async function switchTarget(num) {
   const acct = seq?.accounts?.[key];
   if (!acct) return null;
   const row = (await readUsageRows(root))[key];
-  return { acct, row, matches: rowIsFor(row, acct), active: activeSlot(seq) === key };
+  // Active the way cswap's switch decides "already on it": the slot Claude
+  // Code is signed in as, which is the switch that writes nothing live.
+  return { acct, row, matches: rowIsFor(row, acct), active: activeFrom(seq, await readLiveLogin()).num === key };
 }
 
 /**

package/src/server/claude-login.mjs

@@ -0,0 +1,111 @@
+// Who Claude Code is signed in as right now, and which claude-swap slot that is.
+//
+// The roster used to call the slot in sequence.json's `activeAccountNumber` the
+// active account. claude-swap writes that number only when one of its own
+// commands switches or adds, so a `/login` in Claude Code — or `claude auth
+// login`, or anything else that signs in without cswap — left it naming the
+// previous account for good. The panel showed A while `cswap list` and Claude
+// Code's /status both said B; ↻ re-read the same stale number; and Switch on B
+// did nothing, because cswap saw it was already on B and wrote nothing.
+//
+// `cswap list` never trusts that number. It reads the live identity out of
+// Claude Code's global config and matches it to a slot (switcher.py
+// _get_current_account and _find_account_slot). This module is that rule, so
+// the deck and `cswap list` cannot answer "who is active" two ways.
+//
+// A file read, never a spawn and never the keychain: it runs on every roster
+// read. And only when the file has changed: .claude.json can be large, so an
+// unchanged one costs a stat, as org-telemetry.mjs keeps it. Only when there is
+// no live identity to read — no config file, one that will not parse, or one
+// with nobody signed in — does the stored number stand in, which is what the
+// roster did before.
+import { readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { posix, win32 } from "node:path";
+import { claudeConfigDir } from "./claude-dir.mjs";
+
+async function exists(path, statFile) {
+  try { await statFile(path); return true; } catch { return false; }
+}
+
+/**
+ * The global config file Claude Code keeps its signed-in account in, chosen
+ * the way claude-swap's paths.py get_global_config_path chooses it: the legacy
+ * `<config dir>/.config.json` while Claude Code would still use it, otherwise
+ * `($CLAUDE_CONFIG_DIR || home)/.claude.json`.
+ */
+export async function claudeGlobalConfigPath({
+  env = process.env, home = homedir(), platform = process.platform, statFile = stat,
+} = {}) {
+  const { join } = platform === "win32" ? win32 : posix;
+  const configDir = claudeConfigDir(env, home, platform);
+  const global = join(env.CLAUDE_CONFIG_DIR?.trim() ? configDir : home, ".claude.json");
+  const legacy = join(configDir, ".config.json");
+  try {
+    const st = await statFile(legacy);
+    if (st.isFile() && (st.size > 0 || ((st.mode & 0o222) !== 0 && !(await exists(global, statFile))))) return legacy;
+  } catch { /* no legacy file: the global one */ }
+  return global;
+}
+
+// The last answer, and the file it was read from: path, mtime and size.
+let _last = null;
+
+/**
+ * Who Claude Code is signed in as — `{ email, orgUuid }` from the config's
+ * `oauthAccount` — or null when that cannot be read. `orgUuid` is "" for a
+ * login with no organization, as claude-swap normalises it.
+ */
+export async function readLiveLogin({
+  env = process.env, home = homedir(), platform = process.platform, statFile = stat, read = readFile,
+} = {}) {
+  try {
+    const path = await claudeGlobalConfigPath({ env, home, platform, statFile });
+    const st = await statFile(path);
+    if (_last?.path === path && _last.mtimeMs === st.mtimeMs && _last.size === st.size) return _last.login;
+    const oauth = JSON.parse(String(await read(path, "utf8")).replace(/^/, ""))?.oauthAccount;
+    const email = typeof oauth?.emailAddress === "string" ? oauth.emailAddress : "";
+    const login = email
+      ? { email, orgUuid: typeof oauth.organizationUuid === "string" ? oauth.organizationUuid : "" }
+      : null;
+    _last = { path, mtimeMs: st.mtimeMs, size: st.size, login };
+    return login;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The slot holding that login, matched on (email, organizationUuid) exactly as
+ * claude-swap's _find_account_slot matches it — the email as written, a slot
+ * with no organization key as "" (one whose key is null matches nothing, as
+ * there) — or null when no slot holds it.
+ */
+export function slotOfLogin(seq, login) {
+  if (!login) return null;
+  for (const [num, acct] of Object.entries(seq?.accounts ?? {})) {
+    const org = acct && Object.hasOwn(acct, "organizationUuid") ? acct.organizationUuid : "";
+    if (acct?.email === login.email && org === login.orgUuid) return num;
+  }
+  return null;
+}
+
+/**
+ * Which slot is active, and on whose word:
+ *
+ *   - `{ num, unlisted: null, source: "login" }`: Claude Code is signed in as
+ *     slot `num`, whatever sequence.json last recorded;
+ *   - `{ num: null, unlisted: email, source: "login" }`: it is signed in as an
+ *     account claude-swap does not hold, so no row is active and the panel can
+ *     say whose login it is;
+ *   - `{ num, unlisted: null, source: "store" }`: no live identity could be
+ *     read, so sequence.json's number stands, as it always did.
+ */
+export function activeFrom(seq, login) {
+  if (!login) {
+    const stored = seq?.activeAccountNumber;
+    return { num: stored != null ? String(stored) : null, unlisted: null, source: "store" };
+  }
+  const num = slotOfLogin(seq, login);
+  return { num, unlisted: num == null ? login.email : null, source: "login" };
+}

package/src/server/cswap-admin.mjs

@@ -29,6 +29,7 @@ import { HERE } from "./lan-sync.mjs";
 import { withStoreLock } from "./store-lock.mjs";
 import { adminClaudeBin, currentIdentity } from "./claude-identity.mjs";
 import { claudeCliCandidates } from "./claude-dir.mjs";
+import { activeFrom, readLiveLogin } from "./claude-login.mjs";
 import { cswapBin } from "./cswap-install.mjs";
 import { PRODUCT } from "./brand.mjs";
 
@@ -249,7 +250,12 @@ async function claudeBin() {
   return adminClaudeBin();
 }
 
-/** Slot → email for everything currently in the store, plus the active slot. */
+/**
+ * Slot → email for everything currently in the store, plus the active slot
+ * twice over: `activeNum` as the store records it, which is what a cswap
+ * command moves and what a verdict on one reads back, and `liveNum`, the slot
+ * Claude Code is signed in as (claude-login.mjs), which is who the user is on.
+ */
 export async function readStore() {
   try {
     const seq = JSON.parse(await readFile(join(backupRoot(), "sequence.json"), "utf8"));
@@ -262,9 +268,10 @@ export async function readStore() {
       // bundle carrying both must not report them as one - see identityKey.
       orgs: Object.fromEntries(Object.entries(accounts).map(([k, v]) => [k, v?.organizationUuid ?? ""])),
       activeNum: seq?.activeAccountNumber ?? null,
+      liveNum: activeFrom(seq, await readLiveLogin()).num,
     };
   } catch {
-    return { slots: [], emails: {}, orgs: {}, activeNum: null };
+    return { slots: [], emails: {}, orgs: {}, activeNum: null, liveNum: null };
   }
 }
 
@@ -608,7 +615,9 @@ async function spawnLogin(email) {
   _login = {
     state: "awaiting_url",
     child,
-    previousActive: before.activeNum,
+    // Who the user is on, which a /login made outside cswap can make another
+    // account than the store records: the restore puts THAT one back.
+    previousActive: before.liveNum,
     previousEmail: identity?.email ?? null,
     before,
     url: null,