ccdeck 3.36.5 → 3.36.7

package/dist/web/index.html

@@ -64,7 +64,7 @@
           stored === "light" || (stored !== "dark" && light) ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-B18vwZ9I.js"></script>
+    <script type="module" crossorigin src="/assets/index-B1ngNkKH.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BkXTN4dZ.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdeck",
-  "version": "3.36.5",
+  "version": "3.36.7",
   "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

@@ -64,7 +64,9 @@
     "3.36.0",
     "3.36.1",
     "3.36.4",
-    "3.36.5"
+    "3.36.5",
+    "3.36.6",
+    "3.36.7"
   ],
   "3.36.3": [
     {

package/src/server/activation.mjs

@@ -0,0 +1,76 @@
+// Whether this deck got set up, and how long its first session took to arrive —
+// the "does a new install actually work" half of the usage reports
+// (reports.mjs).
+//
+// WHAT IT ANSWERS. An "install" event says somebody ran ccdeck once. It does not
+// say whether the Claude hooks went in, whether Codex is being watched, or
+// whether a session ever reached the deck — and an install that never sees a
+// session is somebody who tried ccdeck and left. So two facts ride on the
+// reports that carry facts:
+//
+//   - `claudeHooks`: "ok" when this boot installed the hooks, "failed" when it
+//     tried and could not (a settings.json it refuses to rewrite), "off" when it
+//     did not try (no Claude Code found, or --no-claude);
+//   - `codexWatch`: "on" when the Codex rollout watcher runs, else "off".
+//
+// and one "activated" event goes out per install, when its first session
+// arrives, saying how long after the install that was — in coarse buckets,
+// never a time.
+//
+// The boot (bin/deck.js) is what knows the setup, and it reaches this module
+// through noteSetup. This file imports nothing, so the boot can load it early.
+
+/** Not known yet, until the boot says. */
+let setup = null;
+let settle;
+const known = new Promise(r => { settle = r; });
+
+/**
+ * What the boot set up. `claude` is the hook install job — a promise of null
+ * (not attempted), `{ ok: true }` or `{ ok: false }` — or null when Claude is
+ * not wanted; `codex` is whether the rollout watcher runs. Never throws, and a
+ * job that rejects reads as "failed".
+ */
+export function noteSetup({ claude = null, codex = false } = {}) {
+  Promise.resolve(claude)
+    .then(
+      job => (job == null ? "off" : job.ok ? "ok" : "failed"),
+      () => "failed",
+    )
+    .then(claudeHooks => {
+      setup = { claudeHooks, codexWatch: codex ? "on" : "off" };
+      settle();
+    });
+}
+
+/** The setup facts, or none while the boot has not said. */
+export function setupFacts() {
+  return setup ? { ...setup } : {};
+}
+
+/** Resolves once the boot has said, or after `ms`, whichever is first — so a
+ *  report never waits on a boot that will not say (a test, a respawn). */
+export function whenSetupKnown(ms = 10_000) {
+  let timer;
+  return Promise.race([
+    known,
+    new Promise(r => { timer = setTimeout(r, ms); timer.unref?.(); }),
+  ]).finally(() => clearTimeout(timer));
+}
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+
+/** How long after the install the first session came, as a bucket: "5m" (under
+ *  five minutes), "1h", "1d", "7d", or "later". A clock that went backwards
+ *  reads as the shortest. */
+export function sinceInstallBucket(installedAt, firstAt) {
+  const ms = Date.parse(firstAt) - Date.parse(installedAt);
+  if (!Number.isFinite(ms)) return undefined;
+  if (ms < 5 * MINUTE) return "5m";
+  if (ms < HOUR) return "1h";
+  if (ms < DAY) return "1d";
+  if (ms < 7 * DAY) return "7d";
+  return "later";
+}

package/src/server/deck-prefs.mjs

@@ -46,6 +46,7 @@ import { DENIED, foreignPath, quarantinePath, setAsideForeign } from "./prefs-se
 import { deckDataDir } from "./deck-home.mjs";
 import { PRODUCT } from "./brand.mjs";
 import { normaliseOrigins } from "./account-origins.mjs";
+import { normaliseUsage } from "./usage-day.mjs";
 
 /** Set to "1" to keep the deck off the desktop whatever the stored preference
  *  says. Same sheet of switches as AGENTS_DECK_NO_DOWNLOAD and
@@ -90,8 +91,16 @@ export const DEFAULTS = Object.freeze({
   // are what the install last said, so an update is told once and "active" at
   // most once a day; `forget` is an id whose deletion has been asked for and
   // not yet acknowledged, retried on the next start so switching off while
-  // offline still ends in a deletion.
-  report: Object.freeze({ installId: "", lastVersion: "", lastActiveDay: "", forget: "" }),
+  // offline still ends in a deletion; `usage` is the day's tally of sessions,
+  // subagents and projects, counts and days only, so a restart carries it on
+  // (usage-day.mjs); `installedAt` is when the id was made, and
+  // `firstSessionAt`/`firstProvider`/`activationSent` the install's first
+  // session and whether the "activated" event saying so got through — the times
+  // stay here, only a bucket leaves (activation.mjs).
+  report: Object.freeze({
+    installId: "", lastVersion: "", lastActiveDay: "", forget: "", usage: null,
+    installedAt: "", firstSessionAt: "", firstProvider: "", activationSent: false,
+  }),
   // The accounts this deck signed in itself, and the re-sign-in prompts
   // somebody put off (#1893) — keyed by account identity, written by the deck
   // and never by a page. See account-origins.mjs.
@@ -291,7 +300,8 @@ export function normalise(raw) {
   };
 }
 
-/** The reporter's own state, coerced: four strings, empty when absent. */
+/** The reporter's own state, coerced: strings empty when absent, the day's
+ *  tally null until there is one, and one flag. */
 function normaliseReport(raw) {
   const src = raw && typeof raw === "object" ? raw : {};
   const text = v => (typeof v === "string" ? v : "");
@@ -300,6 +310,11 @@ function normaliseReport(raw) {
     lastVersion: text(src.lastVersion),
     lastActiveDay: text(src.lastActiveDay),
     forget: text(src.forget),
+    usage: src.usage && typeof src.usage === "object" ? normaliseUsage(src.usage) : null,
+    installedAt: text(src.installedAt),
+    firstSessionAt: text(src.firstSessionAt),
+    firstProvider: text(src.firstProvider),
+    activationSent: src.activationSent === true,
   };
 }
 

package/src/server/event-pipeline.mjs

@@ -30,6 +30,8 @@ import { appendLogLine } from "./log-writer.mjs";
 import { activity } from "./lifecycle.mjs";
 // The session LRU and the transcript watch — see session-tracking.mjs.
 import { outputWatch, touchSession } from "./session-tracking.mjs";
+// How much the deck was used today, for the "active" report — see usage-day.mjs.
+import { usageDay } from "./usage-day.mjs";
 // What the deck learns about a session that its hooks never say, read off the
 // transcript and sent back through pushEvent — see session-enrichment.mjs.
 import { knownModelId, maybeResolveContext, maybeResolveModel, maybeResolveSessionName, maybeResolveUsage } from "./session-enrichment.mjs";
@@ -212,6 +214,8 @@ export function pushEvent(raw, source, opts = {}) {
   // rollout JSONL under ~/.codex/sessions/. The Claude scanners short-circuit
   // when transcript_path is absent (always the case for Codex hooks).
   if (source === "hook" && !opts.replay) {
+    // A hook is somebody running the CLI, which is what the day's usage counts.
+    usageDay.noteUse(raw);
     if (raw && raw.provider === "codex") {
       maybeResolveCodex(raw);
     } else if (!raw?.transcript_path || isClaudeTranscriptPath(raw.transcript_path)) {
@@ -228,10 +232,18 @@ export function pushEvent(raw, source, opts = {}) {
       // Where the transcript IS, learned from the one place it is free. The
       // four scanners above read it on this event; the watch reads it between
       // events, which is the whole of what it adds.
-      if (raw?.transcript_path) outputWatch.note(raw.session_id, raw.transcript_path);
+      if (raw?.transcript_path) {
+        outputWatch.note(raw.session_id, raw.transcript_path);
+        usageDay.noteProject(raw.transcript_path);
+      }
     } else {
       noteRefusedTranscript(raw.transcript_path);
     }
+  } else if (source === "codex" && !opts.replay) {
+    // Codex has no hooks: its sessions arrive from the rollout watcher, which
+    // emits only what a rollout gains while the deck watches. That is use too.
+    usageDay.noteUse(raw);
+    usageDay.noteFolder(raw?.cwd);
   }
 
   return evt;

package/src/server/output-watch.mjs

@@ -147,19 +147,6 @@ export function createOutputWatch(io = {}) {
   function clear() { seen.clear(); }
   function size() { return seen.size; }
 
-  /** How many distinct projects the live sessions sit in, read off the paths
-   *  already held — no new state. Claude keeps one transcript folder per project
-   *  under ~/.claude/projects, so distinct folders are distinct projects. Only
-   *  the count is ever read; no path or project name leaves. */
-  function projectCount() {
-    const projects = new Set();
-    for (const { path } of seen.values()) {
-      const cut = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
-      projects.add(cut > 0 ? path.slice(0, cut) : path);
-    }
-    return projects.size;
-  }
-
   /**
    * One tick. Stats each named session's file, reads only what is new, and
    * answers with EVERY block that landed in it, oldest first — see blocksIn
@@ -283,5 +270,5 @@ export function createOutputWatch(io = {}) {
     }
   }
 
-  return { note, forget, clear, size, projectCount, poll };
+  return { note, forget, clear, size, poll };
 }

package/src/server/reports.mjs

@@ -12,7 +12,11 @@
 //   - an "active" event at most once a UTC day, which is how many people use
 //     ccdeck gets counted without counting anything else about them, and which
 //     alone also carries coarse counts of how much: how many sessions,
-//     subagents and projects — numbers, never their names,
+//     subagents and projects the deck heard from on the last day it was used,
+//     and that day's date — numbers, never their names (see usage-day.mjs),
+//   - an "activated" event, once, when a new install's first session arrives:
+//     how long after the install it came, as a bucket ("5m", "1h", "1d", "7d",
+//     "later"), and whether it was a Claude or a Codex session (activation.mjs),
 //   - errors: a request handler that threw on this server, or an error the page
 //     caught, with home folders, email addresses and key-shaped strings
 //     scrubbed out before they leave,
@@ -25,11 +29,14 @@
 // the channel (the desktop app, npm, or a source checkout) and the runtime, plus
 // a coarse sketch of the environment: the logical CPU count, the RAM in MB, the
 // locale, the shell and terminal names, and the Claude Code and Codex CLI
-// versions. Every one of those is a small fixed token or a number, safe by
-// construction — no path, no hostname, no user name, no project name, no prompt,
-// no free text ever reaches any field, so there is nothing in them to scrub. A
-// field that cannot be told is left out rather than guessed. The install id is
-// random, made at the first check-in, and tied to nothing on the machine.
+// versions — and, on install, update, active and activated, what the boot set
+// up: whether the Claude hooks went in ("ok", "failed", "off") and whether
+// Codex is watched ("on", "off"). Every one of those is a small fixed token or
+// a number, safe by construction — no path, no hostname, no user name, no
+// project name, no prompt, no free text ever reaches any field, so there is
+// nothing in them to scrub. A field that cannot be told is left out rather than
+// guessed. The install id is random, made at the first check-in, and tied to
+// nothing on the machine.
 //
 // The one field that IS derived from the machine is `deviceId`: a stable, hashed
 // device id sent with EVERY report — install, update and active — while reports
@@ -62,6 +69,8 @@ import { reportsVetoed } from "./deck-prefs.mjs";
 import { isGitCheckout } from "./install-layout.mjs";
 import { heldPrefs, prefsRead } from "./prefs-state.mjs";
 import { RUNNING_VERSION } from "./running-version.mjs";
+import { usageDay, utcDay } from "./usage-day.mjs";
+import { setupFacts, sinceInstallBucket, whenSetupKnown } from "./activation.mjs";
 
 export const REPORTS_API = "https://api.ccdeck.dev";
 const PKG_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
@@ -80,7 +89,10 @@ const SAME_ERROR_QUIET_MS = 60 * 60 * 1000;
 const MESSAGE_MAX = 500;
 const STACK_MAX = 4000;
 
-const EMPTY_REPORT = Object.freeze({ installId: "", lastVersion: "", lastActiveDay: "", forget: "" });
+const EMPTY_REPORT = Object.freeze({
+  installId: "", lastVersion: "", lastActiveDay: "", forget: "", usage: null,
+  installedAt: "", firstSessionAt: "", firstProvider: "", activationSent: false,
+});
 
 /** Is this deck sending reports right now? The switch, which is on unless
  *  somebody turned it off, and the machine's consent. */
@@ -307,9 +319,14 @@ export function scrub(text, home = homedir()) {
  * @param {() => { claudeVersion?: string, codexVersion?: string }} [deps.versions] the CLI
  *   versions to fold into the facts, read fresh on every send so a background
  *   probe's answer rides along the moment it arrives. Default: none.
- * @param {() => ({ sessions?: number, subagents?: number, projects?: number } | Promise<...>)} [deps.usage]
- *   the coarse counts the "active" report carries, read only when an "active" is
- *   about to be sent. Default: none.
+ * @param {ReturnType<typeof import("./usage-day.mjs").createUsageDay>} [deps.usage]
+ *   the day's tally: the "active" report carries the last finished day's totals,
+ *   read only when an "active" is about to be sent, and the tally is saved into
+ *   the prefs so a restart does not lose the day. Default: the deck's own.
+ * @param {() => { claudeHooks?: string, codexWatch?: string }} [deps.setup] what the
+ *   boot set up, folded into install, update and active (activation.mjs).
+ * @param {() => Promise<unknown>} [deps.setupKnown] what start() waits for besides the
+ *   prefs, so the first install event carries the setup. Bounded.
  */
 export function createReporter({
   fetchImpl = globalThis.fetch,
@@ -320,7 +337,9 @@ export function createReporter({
   home = homedir(),
   ready = prefsRead,
   versions = () => ({}),
-  usage = () => ({}),
+  usage = usageDay,
+  setup = setupFacts,
+  setupKnown = () => whenSetupKnown(),
 } = {}) {
   const errorsSent = [];
   const lastSentAt = new Map();
@@ -348,13 +367,30 @@ export function createReporter({
     return { ...facts, ...versionFacts() };
   }
 
-  /** The coarse usage the "active" report carries: only whole counts of zero or
-   *  more survive, and a provider that throws or is slow costs the report
-   *  nothing. */
-  async function coarseUsage() {
+  /** What the boot set up — the Claude hooks and the Codex watcher — as the two
+   *  fixed tokens activation.mjs names, or nothing while it has not said. */
+  function setupNow() {
     try {
-      const raw = (await usage()) ?? {};
+      const s = setup() ?? {};
       const out = {};
+      addIf(out, "claudeHooks", ["ok", "failed", "off"].includes(s.claudeHooks) ? s.claudeHooks : undefined);
+      addIf(out, "codexWatch", ["on", "off"].includes(s.codexWatch) ? s.codexWatch : undefined);
+      return out;
+    } catch {
+      return {};
+    }
+  }
+
+  /** The coarse usage the "active" report carries: the last finished day before
+   *  `today`, its date as `usageDay` and its counts beside it. Nothing at all
+   *  when there is no such day yet — a first launch has no yesterday — and only
+   *  whole counts of zero or more survive. A tally that throws costs the report
+   *  nothing. */
+  function coarseUsage(today) {
+    try {
+      const raw = usage.finished(today);
+      if (!raw || typeof raw.day !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(raw.day) || raw.day >= today) return {};
+      const out = { usageDay: raw.day };
       addIf(out, "sessions", count(raw.sessions));
       addIf(out, "subagents", count(raw.subagents));
       addIf(out, "projects", count(raw.projects));
@@ -364,6 +400,35 @@ export function createReporter({
     }
   }
 
+  /** The tally the last save wrote, so a save with nothing new writes nothing. */
+  let usageSaved = -1;
+
+  /** Keep the day's tally in the prefs, beside the install id, so a restart
+   *  carries it on. Only while reports are on and under the id it belongs to:
+   *  switching off drops it with the id. Never throws. */
+  async function saveUsage() {
+    try {
+      const at = usage.version();
+      if (at === usageSaved) return;
+      const p = prefs.current();
+      if (!reportsOn(p, env) || !p.report.installId) return;
+      await remember(p.report.installId, { usage: usage.saved() });
+      usageSaved = at;
+    } catch {
+      // A settings file that cannot be written this minute; the next save tries again.
+    }
+  }
+
+  /** The tally an earlier run saved, merged in once the prefs are read. */
+  function restoreUsage() {
+    try {
+      const saved = prefs.current().report?.usage;
+      if (saved) usage.restore(saved);
+    } catch {
+      // A saved tally that will not read: this run's counting goes on without it.
+    }
+  }
+
   async function call(method, path, body) {
     try {
       const res = await fetchImpl(REPORTS_API + path, {
@@ -411,31 +476,75 @@ export function createReporter({
     // The id is made here, the first time there is something to send under it.
     if (!prefs.current().report.installId) {
       await prefs.update(prev =>
-        prev.reports === false || prev.report.installId ? undefined : { report: { ...prev.report, installId: randomUUID() } },
+        prev.reports === false || prev.report.installId
+          ? undefined
+          // When the id is made is when this install began: the clock the first
+          // session is measured against. Kept here, never sent as a time.
+          : { report: { ...prev.report, installId: randomUUID(), installedAt: now().toISOString() } },
       );
     }
     const { installId, lastVersion, lastActiveDay } = prefs.current().report;
     if (!installId) return;
     if (!lastVersion) {
-      if (await call("POST", "/v1/app/events", { installId, kind: "install", ...factsNow() })) {
+      if (await call("POST", "/v1/app/events", { installId, kind: "install", ...factsNow(), ...setupNow() })) {
         await remember(installId, { lastVersion: facts.version });
       }
     } else if (lastVersion !== facts.version) {
-      if (await call("POST", "/v1/app/events", { installId, kind: "update", fromVersion: lastVersion, ...factsNow() })) {
+      if (await call("POST", "/v1/app/events", { installId, kind: "update", fromVersion: lastVersion, ...factsNow(), ...setupNow() })) {
         await remember(installId, { lastVersion: facts.version });
       }
     }
 
-    const today = now().toISOString().slice(0, 10);
+    const today = utcDay(now());
     if (lastActiveDay !== today) {
       // Usage rides on the "active" event alone, and is read only here — the one
       // report it belongs to — so a checkIn that sends nothing new never asks the
       // deck for its counts.
-      const used = await coarseUsage();
-      if (await call("POST", "/v1/app/events", { installId, kind: "active", ...factsNow(), ...used })) {
+      const used = coarseUsage(today);
+      if (await call("POST", "/v1/app/events", { installId, kind: "active", ...factsNow(), ...setupNow(), ...used })) {
+        if (used.usageDay) usage.markSent(used.usageDay);
         await remember(installId, { lastActiveDay: today });
       }
     }
+    await sendActivation();
+    await saveUsage();
+  }
+
+  /**
+   * The install's first session, said once: an "activated" event with how long
+   * after the install it came, in a bucket, and which CLI it came from.
+   *
+   * Only for an install whose start this deck saw — `installedAt` is made with
+   * the id, so an install from before this version has none and is never
+   * measured: its first session was long ago, and "now" would be a lie. The time
+   * is taken from the first use this run heard, so a session that arrived before
+   * the first check-in had an id is still dated when it happened. A send that
+   * cannot get through is tried again at the next check-in.
+   */
+  async function sendActivation() {
+    const first = usage.firstUse?.();
+    let r = prefs.current().report;
+    if (!reportsOn(prefs.current(), env) || !r.installId || !r.installedAt || r.activationSent) return;
+    if (!r.firstSessionAt) {
+      if (!first) return;
+      await remember(r.installId, { firstSessionAt: first.at, firstProvider: first.provider });
+      r = prefs.current().report;
+      if (!r.firstSessionAt) return;
+    }
+    const body = { installId: r.installId, kind: "activated", ...factsNow(), ...setupNow() };
+    addIf(body, "firstSession", sinceInstallBucket(r.installedAt, r.firstSessionAt));
+    addIf(body, "firstProvider", r.firstProvider === "codex" || r.firstProvider === "claude" ? r.firstProvider : undefined);
+    if (await call("POST", "/v1/app/events", body)) await remember(r.installId, { activationSent: true });
+  }
+
+  /** The first session this run heard, sent the moment it lands rather than at
+   *  the next check-in, hours later or on a next launch that may never come. */
+  async function onFirstSession() {
+    try {
+      await sendActivation();
+    } catch {
+      // A settings file that cannot be written this minute; the next check-in tries again.
+    }
   }
 
   /** The heartbeat. While reports are on and an id exists, tell the API this deck
@@ -494,10 +603,12 @@ export function createReporter({
 
   /** The heartbeat timer, rescheduled from itself so each beat carries fresh
    *  jitter — a fixed interval would let a fleet that started as one beat as one.
-   *  Unref'd, so it never holds the process open. */
+   *  Unref'd, so it never holds the process open. Each beat also saves the day's
+   *  tally if it moved, so a deck that stops loses ten minutes of it at most. */
   function scheduleNextPing() {
     pingTimer = setTimeout(() => {
       void ping();
+      void saveUsage();
       scheduleNextPing();
     }, PING_EVERY_MS + Math.floor(Math.random() * PING_JITTER_MS));
     pingTimer.unref?.();
@@ -508,7 +619,10 @@ export function createReporter({
    *  open. The first check-in already puts a freshly launched deck online, so the
    *  first ping is a full interval out — nothing pings at boot. */
   function start() {
-    Promise.resolve(ready).catch(() => {}).then(checkIn);
+    Promise.all([Promise.resolve(ready).catch(() => {}), Promise.resolve(setupKnown()).catch(() => {})])
+      .then(restoreUsage)
+      .then(checkIn)
+      .then(() => usage.onFirstUse?.(() => void onFirstSession()));
     if (!timer) {
       timer = setInterval(() => void checkIn(), CHECK_IN_EVERY_MS);
       timer.unref?.();
@@ -523,36 +637,16 @@ export function createReporter({
     pingTimer = null;
   }
 
-  return { checkIn, ping, setReports, reportError, start, stop };
+  return { checkIn, ping, setReports, reportError, restoreUsage, saveUsage, sendActivation, start, stop };
 }
 
 // ── the deck's own providers ─────────────────────────────────────────────────
 //
 // Kept here rather than in the modules they read, so reports.mjs stays the one
 // place that decides what leaves — and reached by lazy import, so the reporter's
-// own module graph does not pull the session tracker, the enrichment cache or
-// the CLI probe into a fast path like `--version` that imports it for nothing.
-
-/** The coarse counts the "active" report carries, read from the state the deck
- *  already keeps — the LRU of tracked sessions, the per-session subagent
- *  signatures, and the folders those sessions' transcripts sit in. Never new
- *  tracking, and never anything but a number: no session id, project name or
- *  path, only how many. `projects` is the distinct transcript folders among the
- *  live sessions, so it counts Claude projects; a Codex-only deck sends no
- *  transcript path and so reports no projects. */
-async function deckUsage() {
-  const out = {};
-  try {
-    const { trackedSessionCount, trackedProjectCount } = await import("./session-tracking.mjs");
-    out.sessions = trackedSessionCount();
-    out.projects = trackedProjectCount();
-  } catch { /* counts unavailable: omitted */ }
-  try {
-    const { trackedSubagentCount } = await import("./session-enrichment.mjs");
-    out.subagents = trackedSubagentCount();
-  } catch { /* count unavailable: omitted */ }
-  return out;
-}
+// own module graph does not pull the CLI probe into a fast path like
+// `--version` that imports it for nothing. The day's usage tally is imported
+// directly: usage-day.mjs imports nothing.
 
 // The CLI versions, detected once in the background, off the boot path. The
 // first send starts the probe (past boot, and not while the machine has vetoed
@@ -572,4 +666,4 @@ function deckCliVersions() {
 }
 
 /** The deck's own reporter. */
-export const reporter = createReporter({ versions: deckCliVersions, usage: deckUsage });
+export const reporter = createReporter({ versions: deckCliVersions });

package/src/server/session-enrichment.mjs

@@ -77,21 +77,6 @@ function knownModelId(sid) {
   return cachedModelId(modelBySession.get(sid));
 }
 
-/** How many subagents the deck has seen across the sessions it still tracks —
- *  the coarse "subagents" count the "active" report carries
- *  (reports.mjs). Reused, not new state: `subsSig` is already the per-session
- *  signature of the subagent models resolved for it, so its keys are the
- *  subagents. A signature that will not parse is skipped rather than guessed at.
- *  Only ever a number leaves — never an id, a model, a name or a path. */
-export function trackedSubagentCount() {
-  let n = 0;
-  for (const cached of modelBySession.values()) {
-    if (!cached?.subsSig) continue;
-    try { n += Object.keys(JSON.parse(cached.subsSig)).length; } catch { /* unparseable signature: not counted */ }
-  }
-  return n;
-}
-
 /** Read the main session JSONL. Returns the root model and any
  *  legacy-schema subagent models (older CC versions kept subagent blocks
  *  inline with `isSidechain:true` + `parentToolUseID`). Current CC versions

package/src/server/session-tracking.mjs

@@ -147,23 +147,6 @@ function forgetSession(sid) {
   forgetCodexSession(sid);
 }
 
-/** How many sessions the deck is still tracking — the size of the LRU the watch
- *  polls, which is the coarse "how many sessions" the "active" report
- *  counts (reports.mjs). Reused, not new state: the Map is already the deck's
- *  own answer to which sessions it still holds anything for. Never a session id,
- *  a name or a path — only the count. */
-function trackedSessionCount() {
-  return sessionTouchedAt.size;
-}
-
-/** How many distinct projects those live sessions sit in — the same live set,
- *  counted by the folder each session's transcript is in. Reused, not new state:
- *  the watch already holds every live session's transcript path. Never a project
- *  name or path — only the count. */
-function trackedProjectCount() {
-  return outputWatch.projectCount();
-}
-
 function touchSession(sid) {
   if (!sid || typeof sid !== "string") return;
   // Re-insert so the Map's own insertion order *is* the LRU order and eviction
@@ -256,4 +239,4 @@ async function handleForget(req, res) {
 // What index.mjs calls besides HARD_TRACKED_SESSIONS. Listed rather than
 // marked at each declaration, so the declarations read as they did where they
 // came from.
-export { handleForget, outputWatch, startOutputWatch, touchSession, trackedProjectCount, trackedSessionCount };
+export { handleForget, outputWatch, startOutputWatch, touchSession };