ccdeck 3.45.0 → 3.46.0

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

@@ -1 +1 @@
-import"./app-BW3NYUYB.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-r8Ymr47Q.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/app-BW3NYUYB.js">
-    <link rel="stylesheet" crossorigin href="/assets/app-C5RY_wZ4.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.45.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,36 @@
     "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",

package/src/server/claude-accounts.mjs

@@ -59,6 +59,10 @@ 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";
@@ -232,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) {
@@ -473,17 +472,25 @@ 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)
@@ -505,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, telemetry: orgTelemetry[acct.organizationUuid] ?? null });
+    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
@@ -514,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,
+  });
 }
 
 /**
@@ -532,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, telemetry = 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;
 
@@ -540,7 +552,8 @@ function rosterRow({ seq, num, acct, row, identity, now, key, origin = null, tel
   // 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,
   });
@@ -713,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;
 
@@ -752,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);
 }
 
 /**
@@ -827,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,

package/src/server/installer.mjs

@@ -18,9 +18,9 @@ import { shellQuoteArg } from "./exec.mjs";
 // The read-before-rewrite and the atomic replace every settings writer goes
 // through — see atomic-write.mjs.
 import { readSettingsForWrite, writeFileAtomic, createTemp, renameWithRetry } from "./atomic-write.mjs";
-// Skill activity's typed-command entry, its opt-in and its version gate — see
-// skill-hook.mjs for why it is not in CLAUDE_EVENTS.
-import { USER_PROMPT_EXPANSION, skillHookDecision } from "./skill-hook.mjs";
+// Skill activity's typed-command entry, its off switch and its version gate —
+// see skill-hook.mjs for why it is not in CLAUDE_EVENTS.
+import { USER_PROMPT_EXPANSION, skillHookDecision, skillHookEnabled } from "./skill-hook.mjs";
 // The discovery dir every deck registers in and every hook reads — see
 // discovery.mjs, which keeps this deck's record there.
 import { AGENT_DAG_DIR } from "./discovery.mjs";
@@ -87,8 +87,8 @@ const PROVIDERS = {
     hookInstallDir: join(CLAUDE_DIR, "agent-dag"),
     events: CLAUDE_EVENTS,
     versioned: VERSIONED_CLAUDE_EVENTS,
-    // UserPromptExpansion, for Skill activity (#2181): opt-in, and gated on
-    // every Claude Code found being 2.1.116 or newer (skill-hook.mjs).
+    // UserPromptExpansion, for Skill activity (#2181): on unless turned off,
+    // and gated on every Claude Code found being 2.1.116 or newer (skill-hook.mjs).
     skillHook: true,
     ensureDir: CLAUDE_DIR,
   },
@@ -445,10 +445,27 @@ async function decideSkillHook(options, settings, before, backupPath) {
   return decision;
 }
 
+/**
+ * Whether Claude Code reports typed slash commands to this deck now, for the
+ * Skills tab: "on" when our UserPromptExpansion entry is in settings.json,
+ * "off" when the deck was started with the entry turned off, and "skipped"
+ * when the gate or the file kept it out (the boot report says which). Read
+ * from the file rather than remembered from the boot, because the launcher
+ * installed it in another process and the file is what Claude Code reads.
+ */
+export async function skillHookState(env = process.env, settingsPath = PROVIDERS.claude.settingsPath) {
+  if (!skillHookEnabled(env)) return "off";
+  try {
+    return holdsOurs(JSON.parse(await readFile(settingsPath, "utf8"))?.hooks?.[USER_PROMPT_EXPANSION]) ? "on" : "skipped";
+  } catch {
+    return "skipped";
+  }
+}
+
 /** Install hooks for a single provider. Returns {settingsPath, hookPath, events, changed}.
  *  `claudeVersions` is the suite's: the Claude Code versions to gate the
  *  versioned events on, in place of the ones on this machine's disk.
- *  `skillHook` is the suite's too: skillHookDecision's options (the opt-in,
+ *  `skillHook` is the suite's too: skillHookDecision's options (the switch,
  *  the installs found, the probe), in place of this machine's. The answer
  *  carries the decision as `skillHook` for the claude provider. */
 export async function installHooks({ provider = "claude", beforeWrite = null, claudeVersions = null, skillHook = null } = {}) {
@@ -490,7 +507,7 @@ export async function installHooks({ provider = "claude", beforeWrite = null, cl
     current.hooks[evt] = cleaned;
   }
   // A gated event this machine's Claude Code does not know — or, for Skill
-  // activity's, one nobody asked for — loses our entry, and the key goes with
+  // activity's, one turned off — loses our entry, and the key goes with
   // it when nothing of the user's is left under it: that key is the thing an
   // older Claude Code cannot read.
   // A value under that key that is not a list, or a list with nothing of ours

package/src/server/login-service.mjs

@@ -403,8 +403,8 @@ export const SETTING_VARS = Object.freeze([
   "AGENTS_DECK_NO_INSTALL", "AGENTS_DECK_NO_DOWNLOAD", "AGENTS_DECK_NO_UPDATE_CHECK", "AGENTS_DECK_NO_STATUS",
   "AGENTS_DECK_NO_FRESHEN", "AGENTS_DECK_NO_NOTIFY", "AGENTS_DECK_NO_LAN", "AGENTS_DECK_NO_REPORTS",
   "AGENTS_DECK_CSWAP", "AGENTS_DECK_CLAUDE", "AGENTS_DECK_CCUSAGE", "CLAUDE_SWAP_BACKUP", "AGENTS_DECK_LHM_PORT",
-  // The opt-in for Skill activity's typed-command hook (skill-hook.mjs). A deck
-  // started at login without it would take the entry back out.
+  // The off switch for Skill activity's typed-command hook (skill-hook.mjs). A
+  // deck started at login without it would put the entry back in.
   "AGENTS_DECK_SKILL_HOOK",
 ]);
 

package/src/server/skill-hook.mjs

@@ -1,6 +1,9 @@
 // Whether the deck may add the UserPromptExpansion hook that Skill activity
-// counts typed slash commands with (#2181) — and, until somebody asks for it,
-// the answer is no.
+// counts typed slash commands with (#2181). It is the only signal for them: a
+// typed skill never calls the Skill tool, and UserPromptSubmit also carries a
+// prompt that only starts like a command (`/etc is full`, an unknown command
+// Claude Code hands to the model), so without this entry the Skills tab counts
+// none of the commands a person types. On by default, behind the version gate.
 //
 // WHY THIS ENTRY IS GATED HARDER THAN STOPFAILURE. A hook event name Claude
 // Code does not know is not skipped by every version. Up to 2.1.100 it made
@@ -23,7 +26,8 @@
 // it costs the user every setting they have.
 //
 // WHAT HAS TO BE TRUE before the entry is written:
-//   - the deck was started with AGENTS_DECK_SKILL_HOOK=1 — never by default;
+//   - the deck was not started with AGENTS_DECK_SKILL_HOOK turned off (any
+//     value but 1; unset or empty is on);
 //   - at least one Claude Code was found, the way the deck finds `claude`: the
 //     candidate list (claude-dir.mjs) and AGENTS_DECK_CLAUDE;
 //   - EVERY one found says which version it is, and every one is 2.1.116 or
@@ -31,11 +35,11 @@
 //     one that will not say its version is treated as an old one.
 // A version is read off disk first (claude-dir.mjs, no child process). Only
 // for an install whose layout does not name one — a wrapper script, an unusual
-// prefix — and only once the user has opted in, is that binary asked
+// prefix — and only while the entry is not turned off, is that binary asked
 // `--version`, by its full path and as argv, and believed only when it answers
 // the way Claude Code does: `<x.y.z> (Claude Code)`.
 //
-// Every boot re-decides. A machine that stops passing — the opt-in removed, a
+// Every boot re-decides. A machine that stops passing — the entry turned off, a
 // Claude Code rolled back, a second, older one installed — has the entry taken
 // back out by the next start (installer.mjs), and the user's own
 // UserPromptExpansion hooks are left where they are.
@@ -56,13 +60,15 @@ export const SKILL_HOOK_SINCE = claudeVersionAtLeast(USER_PROMPT_EXPANSION_SINCE
   ? USER_PROMPT_EXPANSION_SINCE
   : UNKNOWN_EVENT_TOLERATED_SINCE;
 
-/** Set to "1" to ask for the entry. Anything else, or nothing, is no. */
+/** Set to "0" to leave the entry out. Unset, empty or "1" is on. */
 export const SKILL_HOOK_ENV = "AGENTS_DECK_SKILL_HOOK";
 
-/** Whether the person starting the deck asked for the entry. Only the exact
- *  string "1": a typo or a "true" does not turn it on. */
-export function skillHookOptedIn(env = process.env) {
-  return env?.[SKILL_HOOK_ENV] === "1";
+/** Whether the person starting the deck left the entry on. Any value but "1"
+ *  turns it off, so a "false", an "off" or a typo is honoured as a no rather
+ *  than read as a yes; only unset or empty is no instruction at all. */
+export function skillHookEnabled(env = process.env) {
+  const value = env?.[SKILL_HOOK_ENV];
+  return value === undefined || value === "" || value === "1";
 }
 
 /** A `--version` that is not quick is not Claude Code's fast path. */
@@ -92,7 +98,7 @@ async function askVersion(runImpl, bin, timeout) {
 /**
  * The decision, and why:
  *
- *   { install: false, state: "off",     reason: "not-enabled" }
+ *   { install: false, state: "off",     reason: "turned-off" }
  *   { install: false, state: "skipped", reason: "no-claude" | "version-unknown" | "too-old", versions }
  *   { install: true,  state: "on",      versions }
  *
@@ -105,15 +111,15 @@ async function askVersion(runImpl, bin, timeout) {
  */
 export async function skillHookDecision({
   env = process.env,
-  optedIn = skillHookOptedIn(env),
+  enabled = skillHookEnabled(env),
   installs,
   runImpl = run,
   timeout = PROBE_TIMEOUT_MS,
 } = {}) {
   const since = SKILL_HOOK_SINCE;
-  // Off is decided before anything is looked at: a deck that was not asked
-  // spends nothing on the question, and spawns nothing.
-  if (!optedIn) return { install: false, state: "off", reason: "not-enabled", since, versions: [] };
+  // Off is decided before anything is looked at: a deck told to leave the
+  // entry out spends nothing on the question, and spawns nothing.
+  if (!enabled) return { install: false, state: "off", reason: "turned-off", since, versions: [] };
   let found;
   try {
     found = Array.isArray(installs) ? [...installs] : claudeCodeInstalls();
@@ -140,16 +146,16 @@ export async function skillHookDecision({
 }
 
 /**
- * The boot report's row for the entry — `{ ok, detail }` — or null when there
- * is nothing to say, which is the default: nobody asked for it, and a deck
- * that was not asked prints exactly what it printed before. `dash` is the
- * screen's own (bin/cli/screen.js), so the line carries no punctuation a
- * legacy console cannot draw.
+ * The boot report's row for the entry — `{ ok: false, detail }` — or null when
+ * there is nothing to say: installed, which is the default and needs no line,
+ * or turned off by the person starting the deck, who knows. Only an entry the
+ * gate or the file kept out is said, since then the Skills tab counts no typed
+ * command. `dash` is the screen's own (bin/cli/screen.js), so the line carries
+ * no punctuation a legacy console cannot draw.
  */
 export function skillHookStatus(decision, dash = "-") {
-  if (!decision || decision.state === "off") return null;
+  if (!decision || decision.state === "off" || decision.state === "on") return null;
   const found = (decision.versions ?? []).map(v => v ?? "unknown").join(", ");
-  if (decision.state === "on") return { ok: true, detail: `on ${dash} counts typed slash commands (Claude Code ${found})` };
   const why = {
     "no-claude": "no Claude Code found",
     "version-unknown": `a Claude Code here does not say its version (found: ${found})`,

package/src/server/system-metrics.mjs

@@ -264,6 +264,10 @@ function loadSeries(at, coreCount) {
     warnAt: coreCount,
     critAt: null,
     restsAtZero: false,
+    // What the chart's reading divides by, so a point read after the fact says
+    // how many times over the cores it was — the live note's figure, for a
+    // minute that is no longer live.
+    cores: coreCount,
     points,
   }];
 }

package/src/server/tool-audit-routes.mjs

@@ -1,5 +1,7 @@
 import { toolAudit } from './tool-audit.mjs';
 import { readBody, send } from './http-io.mjs';
+import { skillHookState } from './installer.mjs';
+import { deckProviders } from './deck-scope.mjs';
 const calendarDate = value => /^\d{4}-\d{2}-\d{2}$/.test(value ?? '') && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
 export function auditQuery(params) {
   const provider = params.get('provider') ?? 'all';
@@ -31,6 +33,8 @@ export async function handleToolAudit(req, res) {
     try { report = await audit.report(query, controller.signal); }
     catch (e) { if (controller.signal.aborted) return; throw e; }
     finally { res.off('close', cancel); }
+    // The Skills tab says when the commands a person types cannot be counted.
+    if (report.ok && query.view === 'skills' && deckProviders().claude) report.typedCommands = await skillHookState();
     return send(res, report.ok ? 200 : 409, report);
   }
   let body; try { body = JSON.parse(await readBody(req, res, 2048)); } catch { return send(res, 400, { ok: false, reason: 'bad_body' }); }

package/src/server/traffic-radar-config.mjs

@@ -58,6 +58,39 @@ export function radarVariables(settings, source) {
   }));
 }
 
+export const LAUNCH_SOURCE = "Process launch environment";
+
+/** Allowlisted telemetry variables from a NUL-separated /proc environ. Every
+ *  other variable, credentials included, is dropped while parsing. */
+export function environVariables(buffer) {
+  const env = {};
+  for (const entry of buffer.toString("utf8").split("\0")) {
+    const split = entry.indexOf("=");
+    const key = entry.slice(0, split);
+    if (split > 0 && RADAR_KEYS.includes(key)) env[key] = entry.slice(split + 1);
+  }
+  return radarVariables({ env }, LAUNCH_SOURCE);
+}
+
+/** One row per variable and value across running Claude processes, so sessions
+ *  launched alike read as one source; the lowest PID keeps rows for different
+ *  values of a variable apart. Launch values are evidence, never switches. */
+export function launchVariables(processes) {
+  const rows = new Map();
+  for (const { pid, variables } of [...processes].sort((a, b) => a.pid - b.pid)) {
+    for (const variable of variables) {
+      const id = JSON.stringify([variable.key, variable.value, variable.rawValue ?? null]);
+      const row = rows.get(id);
+      if (row) row.more++;
+      else rows.set(id, { variable, pid, more: 0 });
+    }
+  }
+  return [...rows.values()].map(({ variable, pid, more }) => ({
+    ...variable, source: `${LAUNCH_SOURCE} · PID ${pid}${more ? ` and ${more} more` : ""}`, launch: true,
+    ...(BOOLEAN_KEYS.includes(variable.key) ? { editable: false } : {}),
+  }));
+}
+
 async function readBoundedJson(path) {
   const file = await open(path, "r");
   try {