ccdeck 3.36.4 → 3.36.6

package/dist/web/index.html

@@ -64,7 +64,7 @@
           stored === "light" || (stored !== "dark" && light) ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-Cb31GACQ.js"></script>
+    <script type="module" crossorigin src="/assets/index-B2C4N7Bl.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.4",
+  "version": "3.36.6",
   "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

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

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,10 @@ 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).
+  report: Object.freeze({ installId: "", lastVersion: "", lastActiveDay: "", forget: "", usage: null }),
   // 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 +294,8 @@ export function normalise(raw) {
   };
 }
 
-/** The reporter's own state, coerced: four strings, empty when absent. */
+/** The reporter's own state, coerced: four strings, empty when absent, and the
+ *  day's tally, null until there is one. */
 function normaliseReport(raw) {
   const src = raw && typeof raw === "object" ? raw : {};
   const text = v => (typeof v === "string" ? v : "");
@@ -300,6 +304,7 @@ 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,
   };
 }
 

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,7 +232,10 @@ 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);
     }

package/src/server/reports.mjs

@@ -12,7 +12,8 @@
 //   - 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),
 //   - 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,
@@ -62,6 +63,7 @@ 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";
 
 export const REPORTS_API = "https://api.ccdeck.dev";
 const PKG_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
@@ -80,7 +82,7 @@ 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 });
 
 /** Is this deck sending reports right now? The switch, which is on unless
  *  somebody turned it off, and the machine's consent. */
@@ -307,9 +309,10 @@ 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.
  */
 export function createReporter({
   fetchImpl = globalThis.fetch,
@@ -320,7 +323,7 @@ export function createReporter({
   home = homedir(),
   ready = prefsRead,
   versions = () => ({}),
-  usage = () => ({}),
+  usage = usageDay,
 } = {}) {
   const errorsSent = [];
   const lastSentAt = new Map();
@@ -348,13 +351,16 @@ 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
+  /** 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. */
-  async function coarseUsage() {
+  function coarseUsage(today) {
     try {
-      const raw = (await usage()) ?? {};
-      const out = {};
+      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 +370,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, {
@@ -426,16 +461,18 @@ export function createReporter({
       }
     }
 
-    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();
+      const used = coarseUsage(today);
       if (await call("POST", "/v1/app/events", { installId, kind: "active", ...factsNow(), ...used })) {
+        if (used.usageDay) usage.markSent(used.usageDay);
         await remember(installId, { lastActiveDay: today });
       }
     }
+    await saveUsage();
   }
 
   /** The heartbeat. While reports are on and an id exists, tell the API this deck
@@ -494,10 +531,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 +547,7 @@ 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.resolve(ready).catch(() => {}).then(restoreUsage).then(checkIn);
     if (!timer) {
       timer = setInterval(() => void checkIn(), CHECK_IN_EVERY_MS);
       timer.unref?.();
@@ -523,34 +562,16 @@ export function createReporter({
     pingTimer = null;
   }
 
-  return { checkIn, ping, setReports, reportError, start, stop };
+  return { checkIn, ping, setReports, reportError, restoreUsage, saveUsage, 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 and the per-session subagent
- *  signatures. Never new tracking, and never anything but a number: no session
- *  id, name or path. `projects` is left out for now — its only source is the
- *  disk-backed, per-account rollup (account-projects.mjs), which has no cheap
- *  synchronous count — so the field is simply not sent. */
-async function deckUsage() {
-  const out = {};
-  try {
-    const { trackedSessionCount } = await import("./session-tracking.mjs");
-    out.sessions = trackedSessionCount();
-  } catch { /* count 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
@@ -570,4 +591,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,15 +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;
-}
-
 function touchSession(sid) {
   if (!sid || typeof sid !== "string") return;
   // Re-insert so the Map's own insertion order *is* the LRU order and eviction
@@ -248,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, trackedSessionCount };
+export { handleForget, outputWatch, startOutputWatch, touchSession };

package/src/server/usage-day.mjs

@@ -0,0 +1,176 @@
+// How much this deck was used on one UTC day: the distinct sessions, subagents
+// and projects its hooks heard from. The "active" report carries the totals of
+// the last finished day (reports.mjs).
+//
+// WHY A DAY AND NOT A SNAPSHOT. The counts used to be read off the live state at
+// the moment the "active" went out — and that moment is the first check-in of
+// the day, which runs at launch, before anybody has done anything. Production
+// on 2026-10-01: of 33 "active" reports carrying counts, the median session
+// count was 0, and 24 said zero sessions. A day's totals, sent the next day,
+// are the number the snapshot was trying to be.
+//
+// WHAT IS KEPT. In memory, the session ids, the subagent ids and the folders the
+// transcripts sit in, so a session heard from a hundred times counts once. They
+// never leave this module: what is saved between runs (prefs.json, beside the
+// install id) and what is sent are three counts and the day they belong to.
+//
+// A RESTART MID-DAY. The saved counts come back as a floor and the new run
+// counts on top of them, so a session that was running across the restart is
+// counted twice. That is the price of keeping no ids on disk, and a restart is
+// rare next to the day's sessions.
+//
+// Only what a hook said counts: a hook fires because somebody is running the
+// CLI. Replayed lines, a rollout read off disk and the deck's own synthetic
+// events are not use.
+
+/** The day as the reporter says it: the UTC date, "2026-10-01". */
+export function utcDay(date) {
+  return date.toISOString().slice(0, 10);
+}
+
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+
+/** A whole count of zero or more, else 0. */
+function whole(n) {
+  return Number.isInteger(n) && n >= 0 ? n : 0;
+}
+
+/** Saved totals, coerced: a day and three counts, or null for anything else. */
+function savedTotals(raw) {
+  if (!raw || typeof raw !== "object" || typeof raw.day !== "string" || !DAY.test(raw.day)) return null;
+  return { day: raw.day, sessions: whole(raw.sessions), subagents: whole(raw.subagents), projects: whole(raw.projects) };
+}
+
+/** What prefs.json keeps for this, coerced — deck-prefs.mjs normalises with it. */
+export function normaliseUsage(raw) {
+  const src = raw && typeof raw === "object" ? raw : {};
+  return {
+    current: savedTotals(src.current),
+    done: savedTotals(src.done),
+    sent: typeof src.sent === "string" && DAY.test(src.sent) ? src.sent : "",
+  };
+}
+
+/** The folder a transcript sits in, which is the project it belongs to:
+ *  `~/.claude/projects/<project>/<session>.jsonl`. */
+function folderOf(path) {
+  const cut = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return cut > 0 ? path.slice(0, cut) : path;
+}
+
+/**
+ * The tally. `now` is injectable so the suite can walk it across midnight.
+ */
+export function createUsageDay({ now = () => new Date() } = {}) {
+  /** The day being counted: saved counts from an earlier run as a floor, and
+   *  this run's distinct ids on top. */
+  let current = null;
+  /** The last finished day whose totals have not gone out yet. */
+  let done = null;
+  /** The last day whose totals did go out. */
+  let sent = "";
+  /** Moves on every change, so the reporter saves only when there is something new. */
+  let changes = 0;
+
+  function fresh(day, floor = null) {
+    return {
+      day,
+      floor: floor ?? { sessions: 0, subagents: 0, projects: 0 },
+      sessions: new Set(),
+      subagents: new Set(),
+      projects: new Set(),
+    };
+  }
+
+  function totals(c) {
+    return {
+      day: c.day,
+      sessions: c.floor.sessions + c.sessions.size,
+      subagents: c.floor.subagents + c.subagents.size,
+      projects: c.floor.projects + c.projects.size,
+    };
+  }
+
+  /** The day being counted, rolled over first if the clock has passed it. */
+  function today() {
+    const day = utcDay(now());
+    if (current?.day === day) return current;
+    if (current && current.day < day) done = totals(current);
+    current = fresh(day);
+    changes++;
+    return current;
+  }
+
+  function add(set, key) {
+    if (set.has(key)) return;
+    set.add(key);
+    changes++;
+  }
+
+  /** A live hook payload: its session, and the subagent it came from if any. */
+  function noteUse(raw) {
+    const sid = raw?.session_id;
+    if (!sid || typeof sid !== "string") return;
+    const c = today();
+    add(c.sessions, sid);
+    if (typeof raw.agent_id === "string" && raw.agent_id) add(c.subagents, `${sid}\u0000${raw.agent_id}`);
+  }
+
+  /** A transcript path a hook carried, already accepted as Claude's. */
+  function noteProject(path) {
+    if (!path || typeof path !== "string") return;
+    add(today().projects, folderOf(path));
+  }
+
+  /** The totals of the last finished day before `day`, if they have not gone
+   *  out yet; null when there is none. Rolls over first, so a deck that ran past
+   *  midnight with nothing said since still has yesterday finished. */
+  function finished(day) {
+    today();
+    const c = current && current.day < day ? totals(current) : done;
+    return c && c.day < day && c.day > sent ? c : null;
+  }
+
+  /** Those totals went out: never send them again. */
+  function markSent(day) {
+    if (day > sent) sent = day;
+    if (done && done.day <= sent) done = null;
+    changes++;
+  }
+
+  /** What survives a restart: counts and days, never an id or a path. */
+  function saved() {
+    return { current: current ? totals(current) : null, done, sent };
+  }
+
+  /**
+   * An earlier run's `saved()`, merged into this one. This run may already have
+   * heard from sessions — the prefs are read after the first hooks can land —
+   * so nothing it counted is dropped: the saved day becomes the floor of the
+   * same day, or the finished day of an earlier one.
+   */
+  function restore(raw) {
+    const s = normaliseUsage(raw);
+    if (s.sent > sent) sent = s.sent;
+    for (const t of [s.done, s.current]) {
+      if (!t) continue;
+      const c = today();
+      if (t.day === c.day) {
+        c.floor = { sessions: t.sessions, subagents: t.subagents, projects: t.projects };
+      } else if (t.day < c.day && (!done || t.day > done.day)) {
+        done = t;
+      }
+    }
+    if (done && done.day <= sent) done = null;
+    changes++;
+  }
+
+  function version() {
+    return changes;
+  }
+
+  return { noteUse, noteProject, finished, markSent, saved, restore, version };
+}
+
+/** The deck's own tally, which the event pipeline feeds and the reporter reads. */
+export const usageDay = createUsageDay();