ccdeck 3.38.2 → 3.38.3

package/dist/web/index.html

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

package/package.json

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

@@ -74,6 +74,12 @@
     "3.38.1",
     "3.38.2"
   ],
+  "3.38.3": [
+    {
+      "title": "🧾 Subagent costs count their whole reply",
+      "body": "A subagent's request was counted from the first moment of its reply, before most of it had been written, so much of its output was left out of the deck's token and cost counts, and a subagent turn in fast mode was priced at the standard rate. Each request is now counted from its finished reply. Days with subagents will read higher than before: that is the part that was missing, not a new charge. Projects counts its history again once after the update, so past days come out right too. Codex sessions on GPT-6 Sol, GPT-6.1 Sol and GPT-6 Luna now show a cost instead of not priced."
+    }
+  ],
   "3.37.1": [
     {
       "title": "🔁 Expired logins repair from your other machines",

package/src/server/account-projects.mjs

@@ -33,7 +33,8 @@ import { readSwapLog, accountAtTime, trackedSince, seedActive, markGap } from ".
 // and a session's card cannot disagree about which lines billed anything, nor
 // about the speed they were billed at — see transcript-scan.mjs.
 import {
-  billedSpeed, hasSpend, MAX_SPEEDS_PER_MODEL, repeatsRequestUsage, UNRECOGNISED_SPEED,
+  billedSpeed, hasSpend, MAX_SPEEDS_PER_MODEL, UNRECOGNISED_SPEED,
+  requestBilling, streamingRequestId, BILL_LINE, REBILL_REQUEST, SKIP_LINE,
 } from "./transcript-scan.mjs";
 
 /** The pseudo-account for messages the swap log cannot place — everything
@@ -41,7 +42,7 @@ import {
  *  a per-account total is never quietly inflated by work that is not that
  *  account's. A NUL keeps it from ever colliding with a real `email@@org` key. */
 export const UNATTRIBUTED = "\u0000unattributed";
-const STATE_VERSION = 4;
+const STATE_VERSION = 5;
 
 /** Where the tally and cursors live, beside cswap-auto's own state. */
 export function statePath(home = homedir()) {
@@ -104,6 +105,16 @@ function addInto(dst, src) {
   return dst;
 }
 
+/** Take `src`'s six counters back out of `dst`. */
+function takeFrom(dst, src) {
+  dst.i -= src.i; dst.o -= src.o; dst.cr -= src.cr;
+  dst.cc -= src.cc; dst.c1h -= src.c1h; dst.c5m -= src.c5m;
+}
+
+function isZero(c) {
+  return !c.i && !c.o && !c.cr && !c.cc && !c.c1h && !c.c5m;
+}
+
 /** The share of `counters` billed at `speed` (#754), created on first sight:
  *  `s[speed]`, a SUBSET of the counters it sits on, the way the 1h/5m split is
  *  of `cc`, so the totals read exactly as they did and the client prices the
@@ -112,11 +123,18 @@ function addInto(dst, src) {
  *  past the cap is kept as UNRECOGNISED_SPEED, which no rate table names, so it
  *  is counted and left unpriced rather than priced at the standard rate. */
 function speedShareOf(counters, speed) {
+  const key = speedShareKey(counters, speed);
+  return counters.s[key];
+}
+
+/** The key `speed`'s share is kept under in `counters`, the share created on
+ *  first sight — see speedShareOf. */
+function speedShareKey(counters, speed) {
   const shares = counters.s ??= {};
-  if (Object.hasOwn(shares, speed)) return shares[speed];
+  if (Object.hasOwn(shares, speed)) return speed;
   const key = Object.keys(shares).length < MAX_SPEEDS_PER_MODEL ? speed : UNRECOGNISED_SPEED;
   if (!Object.hasOwn(shares, key)) shares[key] = zero();
-  return shares[key];
+  return key;
 }
 
 function zero() { return { i: 0, o: 0, cr: 0, cc: 0, c1h: 0, c5m: 0 }; }
@@ -223,22 +241,28 @@ export function projectPath(cwd) {
  *
  * `timeline` is the sorted swap log; the account is whoever it says was active
  * at this line's timestamp, or UNATTRIBUTED when the timestamp precedes it.
- * `from` names the transcript's project directory — see folderOf.
+ * `from` names the transcript's project directory — see folderOf — and, as
+ * `requests` and `path`, where the request this file is still waiting on a
+ * final record for is kept between passes.
  */
 export function foldLine(tally, line, timeline, from) {
   if (!line || !line.includes('"usage"')) return;
   let obj = null;
   try { obj = JSON.parse(line); } catch { return; }
-  // Claude writes one assistant record for each content block in a request,
-  // and every block repeats the request's usage, so only block 0 is billable
-  // — see repeatsRequestUsage.
-  if (repeatsRequestUsage(obj)) return;
+  // A request is billed once, from its final record, which in a subagent's
+  // file follows a streaming snapshot — see requestBilling. A call that keeps
+  // no requests for the file never sees one replaced, and bills block 0.
+  const requests = from?.requests ?? null;
+  const streaming = requests?.[from.path] ?? null;
+  const billing = requestBilling(obj, streaming?.id ?? null);
+  if (billing === SKIP_LINE) return;
   const usage = obj?.message?.usage;
   if (!usage || typeof usage !== "object") return;
   const ts = Date.parse(obj?.timestamp);
   if (!Number.isFinite(ts)) return;
   const c = countersFrom(usage);
   if (!hasSpend(asUsageTotals(c))) return;   // a usage block that billed nothing
+  if (billing === REBILL_REQUEST) refund(tally, streaming);
   const model = typeof obj?.message?.model === "string" ? obj.message.model : "";
   const lineCwd = (typeof obj?.cwd === "string" && obj.cwd) ? obj.cwd : "";
   const cwd = projectPath(folderOf(lineCwd, from));   // a worktree counts under the repo it checks out
@@ -251,7 +275,41 @@ export function foldLine(tally, line, timeline, from) {
   // board prices it so (#754). Kept as a share rather than a model of its own,
   // so a row's tokens and its model read exactly as before.
   const speed = billedSpeed(obj);
-  if (speed) addInto(speedShareOf(counters, speed), c);
+  const share = speed ? speedShareKey(counters, speed) : null;
+  if (share) addInto(counters.s[share], c);
+  if (billing === REBILL_REQUEST) dropIfEmpty(tally, streaming);
+  if (billing === BILL_LINE || !requests) return;
+  // What a request still streaming was charged, and where, so its final
+  // record can take that back, in this pass or a later one.
+  const id = streamingRequestId(obj);
+  if (id === null) delete requests[from.path];
+  else requests[from.path] = { id, at: [key, cwd, day, model], s: share, c };
+}
+
+/** Take a streaming request's charge back out of the row it was charged to,
+ *  for its later record to charge in its place. A row pruned since has
+ *  nothing left to take back. */
+function refund(tally, { at: [key, cwd, day, model], s, c }) {
+  const counters = tally[key]?.[cwd]?.[day]?.[model];
+  if (!counters) return;
+  takeFrom(counters, c);
+  if (s && counters.s?.[s]) takeFrom(counters.s[s], c);
+}
+
+/** Remove what a refund left at zero — a speed share, or a whole row whose
+ *  request's final record landed on another day or account — so the report
+ *  never lists an empty row. */
+function dropIfEmpty(tally, { at: [key, cwd, day, model], s }) {
+  const days = tally[key]?.[cwd];
+  const counters = days?.[day]?.[model];
+  if (!counters) return;
+  if (s && counters.s?.[s] && isZero(counters.s[s])) delete counters.s[s];
+  if (counters.s && !Object.keys(counters.s).length) delete counters.s;
+  if (!isZero(counters)) return;
+  delete days[day][model];
+  if (!Object.keys(days[day]).length) delete days[day];
+  if (!Object.keys(days).length) delete tally[key][cwd];
+  if (!Object.keys(tally[key]).length) delete tally[key];
 }
 
 /** Read the bytes of `path` from `start` to `size`, folding each COMPLETE line,
@@ -423,7 +481,7 @@ export function createProjectRollup({
   setInterval: setIv = setInterval,
   clearInterval: clearIv = clearInterval,
 } = {}) {
-  let state = { version: STATE_VERSION, cursors: {}, tally: {}, folders: {} };
+  let state = { version: STATE_VERSION, cursors: {}, tally: {}, folders: {}, requests: {} };
   let timer = null;
   let running = false;
   let dirty = false;
@@ -437,14 +495,17 @@ export function createProjectRollup({
       if (disk && disk.version === STATE_VERSION && disk.tally && disk.cursors) {
         state = disk;
         state.folders ??= {};
-      } else if (disk && (disk.version === 1 || disk.version === 2 || disk.version === 3)) {
+        state.requests ??= {};
+      } else if (disk && [1, 2, 3, 4].includes(disk.version)) {
         // Version 1 counted every API content block; version 2 keyed each row
         // by the line's own cwd, a row per folder the agent cd'd into (#1278);
         // version 3 kept no speed, so every fast turn read at the standard
-        // rate. None of them can be re-keyed, since it no longer knows which
-        // transcript a count came from. Keep the heartbeat so a restart gap
-        // remains fenced, but rebuild the tally from transcripts.
-        state = { version: STATE_VERSION, cursors: {}, tally: {}, folders: {}, lastAlive: disk.lastAlive };
+        // rate; version 4 billed a subagent's request from its streaming
+        // snapshot, most of its output and its speed missing (#1883). None of
+        // them can be re-keyed, since it no longer knows which transcript a
+        // count came from. Keep the heartbeat so a restart gap remains fenced,
+        // but rebuild the tally from transcripts.
+        state = { version: STATE_VERSION, cursors: {}, tally: {}, folders: {}, requests: {}, lastAlive: disk.lastAlive };
         dirty = true;
       }
     } catch { /* first run: empty state */ }
@@ -474,9 +535,9 @@ export function createProjectRollup({
     // resync the cursor to the current end: the replaced content is lost, never
     // counted twice. Transcripts append and do not shrink in normal use, so this
     // is the rare, safe side to err on.
-    if (st.size < offset) { state.cursors[path] = st.size; dirty = true; return; }
+    if (st.size < offset) { state.cursors[path] = st.size; delete state.requests[path]; dirty = true; return; }
     if (st.size <= offset) return;
-    const from = { slug, folders: state.folders };
+    const from = { slug, folders: state.folders, requests: state.requests, path };
     let fh = null;
     try {
       fh = await open(path, "r");
@@ -504,9 +565,11 @@ export function createProjectRollup({
       const timeline = await readSwapLog(swapLog);
       const files = await listTranscripts(roots);
       for (const [path, slug] of files) await foldFile(path, slug, timeline);
-      // Forget cursors for files that are gone, and the folders of project
-      // directories with no transcript left, so neither map grows forever.
+      // Forget the cursors and streaming requests of files that are gone, and
+      // the folders of project directories with no transcript left, so none of
+      // the three maps grows forever.
       for (const p of Object.keys(state.cursors)) if (!files.has(p)) { delete state.cursors[p]; dirty = true; }
+      for (const p of Object.keys(state.requests)) if (!files.has(p)) { delete state.requests[p]; dirty = true; }
       const slugs = new Set(files.values());
       for (const s of Object.keys(state.folders)) if (!slugs.has(s)) { delete state.folders[s]; dirty = true; }
       // Heartbeat: record that the deck was alive now, so a later boot can see

package/src/server/lan-engine.mjs

@@ -41,7 +41,7 @@
 // anything.
 import {
   addTrusted, ANNOUNCE_MS, credentialAad, dropTrusted, identityFrom, open, peerWhy, plan, PRESENT_MS,
-  stillListed, transferChallenge, trustedPeer,
+  sharedWith, stillListed, transferChallenge, trustedPeer,
 } from "./lan-sync.mjs";
 import { mintInvite, readInvite } from "./lan-invite.mjs";
 import { createInviteOffer } from "./lan-invite-offer.mjs";
@@ -1028,13 +1028,25 @@ export function createEngine({
       had.met = had.met || row.met;
       if (row.name && !had.name) had.name = row.name;
     };
+    // WHAT IS TICKED HERE AND NOT OFFERED THAT DECK, so its dialog draws no
+    // lane going out for it: what an arrival ticked, when the accept switch
+    // paired it — see sharedWith in lan-sync.mjs. The page never sees `onward`
+    // or which pin a switch made, so the engine says the difference itself,
+    // and only where there is one, which on most decks is nowhere.
+    const notOfferedTo = id => {
+      const offered = sharedWith(cfg, id);
+      const held = cfg.shared.filter(key => !offered.includes(key));
+      return held.length ? { notOffered: held } : {};
+    };
     // WHAT THE DECK'S OWN DIALOG DRAWS, by identity: the card it sent,
-    // the logins it offered last, and when somebody here said yes. All
-    // three are keyed by the fingerprint that proved itself, so both
-    // halves of a merged row read the same answer.
+    // the logins it offered last, when somebody here said yes, and what
+    // this deck does not offer it. All four are keyed by the fingerprint
+    // that proved itself, so both halves of a merged row read the same
+    // answer.
     const card = id => ({
       ...heardOf(id),
       pairedAt: trustedPeer(cfg.trusted, id)?.at ?? null,
+      ...notOfferedTo(id),
     });
     for (const p of [...beacon.peers.values(), ...dials.rows()]) {
       if (!stillListed(p, now())) continue;

package/src/server/transcript-scan.mjs

@@ -230,13 +230,15 @@ const USAGE_TOTAL_FIELDS = [...USAGE_BLOCK_FIELDS, ...CACHE_SPLIT_FIELDS];
  *  into both, read once, so the split and the total it splits go on summing
  *  to each other. A request billed at a speed other than standard is charged
  *  to that speed's share of the bucket as well, which is a subset of the
- *  bucket and not an addition to it. */
-function chargeUsage(state, bucket, blob, fields, speedBucket) {
+ *  bucket and not an addition to it. What was charged is added to `charged`,
+ *  so a request's bill can be taken back when its final record replaces it. */
+function chargeUsage(state, bucket, blob, fields, speedBucket, charged) {
   for (const k of fields) {
     const n = grabUsageField(blob, k);
     state.usage[k] += n;
     if (bucket) bucket[k] += n;
     if (speedBucket) speedBucket[k] += n;
+    charged[k] += n;
   }
 }
 
@@ -327,6 +329,9 @@ function newTranscriptState() {
     // mirror of it. Costs no extra read: `message.model` and the `"usage"` block
     // are on the same line, and this pass already parses both.
     usageByModel: {},
+    // The request billed from a snapshot whose final record has not been read
+    // yet, and what it was charged — see requestBilling. Null between requests.
+    streamingRequest: null,
     ctx: newContextBreakdown(),
   };
 }
@@ -422,35 +427,92 @@ function foldModelLine(state, obj) {
 }
 
 /**
- * Does this record repeat the usage an earlier line of the same API request
- * already carried?
+ * Is this record a later content block of a reply an earlier line began?
  *
  * Claude Code writes one assistant line per content block of a response —
- * thinking, text, each tool call — and every one of them carries the whole
- * request's `usage`. Only the first, `apiBlockIndex` 0, bills it (#1641).
- * Measured across the forty most recent transcripts on one machine: 6,765 of
- * 14,138 assistant usage records were such repeats, identical to the block 0
- * before them, and summing them all came to 1.94x the request-by-request
- * total. This is the rule the Projects report (account-projects.mjs) and
- * ccusage count by, and the Projects report asks this function. A record
- * without the field was written before Claude Code marked its blocks, and is
- * counted as it always was.
- *
- * The same lines are one reply, so the context breakdown asks this too before
- * it counts an assistant message (#1650).
+ * thinking, text, each tool call — and marks each with `apiBlockIndex`, 0 for
+ * the first. They are one reply, so the context breakdown counts block 0 and
+ * not the rest (#1650). A record without the field was written before Claude
+ * Code marked its blocks, and is counted as it always was.
  */
-function repeatsRequestUsage(record) {
+function continuesRequest(record) {
   return record?.apiBlockIndex !== undefined && record.apiBlockIndex !== 0;
 }
 
+// How a record's usage enters the bill — see requestBilling.
+const BILL_LINE = "line";
+const BILL_REQUEST = "request";
+const REBILL_REQUEST = "rebill";
+const SKIP_LINE = "skip";
+
+/**
+ * How one record's usage is billed, given the request this file is still
+ * waiting on a final record for (`streamingId`, or null).
+ *
+ * Every content block's line carries a usage block, and summing them all
+ * counted a request once per block: 1.94x the request-by-request total across
+ * forty real transcripts (#1641). Which of those lines holds the request's
+ * usage depends on the file. In the main transcript every line restates the
+ * final usage. In a subagent's `subagents/agent-*.jsonl` Claude Code writes the
+ * first line while the response is still streaming — `stop_reason: null`, the
+ * output counted so far, no `usage.speed` — and the final record follows,
+ * often after the tool results of the call it streamed (#1883). Billing block 0
+ * charged one machine's 19,659 subagent requests 102K output tokens against
+ * the 22.9M their final records carry, and priced every fast-mode subagent
+ * turn at the standard rate, the snapshot naming no speed.
+ *
+ * So a request is billed from its final record, the first that carries a
+ * `stop_reason`. A snapshot is billed when it arrives, so a live card does not
+ * wait for the reply, and every later record of that request takes the bill's
+ * place rather than adding to it; a request whose final record never came (an
+ * interrupted agent) stays billed from its last snapshot. The scan remembers
+ * the request it is waiting on, so the two can arrive in different passes,
+ * which for a live subagent is the usual case.
+ *
+ *   BILL_LINE       a record from before Claude Code marked its blocks, billed
+ *                   line by line as it always was
+ *   BILL_REQUEST    the first record of a request
+ *   REBILL_REQUEST  a later record of the request still streaming: it replaces
+ *                   that request's bill
+ *   SKIP_LINE       a later block of a request already billed from its final
+ *                   record, which restates it
+ *
+ * The Projects report (account-projects.mjs) bills its own pass of the same
+ * lines by this rule.
+ */
+function requestBilling(record, streamingId) {
+  if (record?.apiBlockIndex === undefined) return BILL_LINE;
+  const id = requestIdOf(record);
+  if (id !== null && id === streamingId && isUsageRecord(record)) return REBILL_REQUEST;
+  return record.apiBlockIndex === 0 ? BILL_REQUEST : SKIP_LINE;
+}
+
+/** The request a record belongs to while its final record has yet to come —
+ *  the id requestBilling is next asked with — or null once it is final. */
+function streamingRequestId(record) {
+  return typeof record?.message?.stop_reason === "string" ? null : requestIdOf(record);
+}
+
+function requestIdOf(record) {
+  const id = record?.requestId ?? record?.message?.id;
+  return typeof id === "string" && id ? id : null;
+}
+
+function isUsageRecord(record) {
+  const usage = record?.message?.usage;
+  return !!usage && typeof usage === "object";
+}
+
 /** The usage blocks a line was billed for, charged to the file's totals and to
  *  their model's bucket. Runs after foldModelLine on the same line — see
  *  below for why the order is the attribution. `record` is the line parsed,
  *  or null when it names no model. */
 function foldUsageLine(state, line, record) {
-  // A later content block of a request already charged — see
-  // repeatsRequestUsage.
-  if (repeatsRequestUsage(record)) return;
+  // A request is billed once, from its final record — see requestBilling.
+  const streaming = state.streamingRequest;
+  const billing = requestBilling(record, streaming?.id ?? null);
+  if (billing === SKIP_LINE) return;
+  if (billing === REBILL_REQUEST) refundUsage(state, streaming);
   // Usage totals sum every block in the file, resets included — every block the
   // model was actually billed for, which is why the `toolUseResult` tail is cut
   // off first (see billedUsageText) — and are summed a second time into the
@@ -473,11 +535,28 @@ function foldUsageLine(state, line, record) {
   const billed = billedUsageText(line);
   const bucket = usageBucketFor(state, state.lastModel);
   const speedBucket = speedBucketFor(bucket, billedSpeed(record));
+  const charged = newUsageTotals();
   for (const m of billed.matchAll(USAGE_BLOCK_RE)) {
-    chargeUsage(state, bucket, m[1], USAGE_BLOCK_FIELDS, speedBucket);
+    chargeUsage(state, bucket, m[1], USAGE_BLOCK_FIELDS, speedBucket, charged);
   }
   for (const m of billed.replace(ITERATIONS_ARRAY_RE, "").matchAll(CACHE_CREATION_BLOCK_RE)) {
-    chargeUsage(state, bucket, m[1], CACHE_SPLIT_FIELDS, speedBucket);
+    chargeUsage(state, bucket, m[1], CACHE_SPLIT_FIELDS, speedBucket, charged);
+  }
+  if (billing === BILL_LINE) return;
+  // What this request was charged, and where, kept until its final record
+  // replaces it.
+  const id = streamingRequestId(record);
+  state.streamingRequest = id === null ? null : { id, bucket, speedBucket, charged };
+}
+
+/** Take back what a request was charged, from every counter it was charged
+ *  to, for its later record to charge in its place. */
+function refundUsage(state, { bucket, speedBucket, charged }) {
+  for (const k of USAGE_TOTAL_FIELDS) {
+    const n = charged[k];
+    state.usage[k] -= n;
+    if (bucket) bucket[k] -= n;
+    if (speedBucket) speedBucket[k] -= n;
   }
 }
 
@@ -496,8 +575,8 @@ function foldContextLine(state, line, record) {
   ctx.msgsUser += (ctxText.match(TYPE_USER_RE) ?? []).length;
   // One reply is one message, however many content blocks it was written in:
   // a later block's line is a reply block 0 has already counted — see
-  // repeatsRequestUsage. Its tool call is its own, and is counted below.
-  if (!repeatsRequestUsage(record)) ctx.msgsAssistant += (ctxText.match(TYPE_ASSISTANT_RE) ?? []).length;
+  // continuesRequest. Its tool call is its own, and is counted below.
+  if (!continuesRequest(record)) ctx.msgsAssistant += (ctxText.match(TYPE_ASSISTANT_RE) ?? []).length;
   ctx.toolUses += (ctxText.match(TYPE_TOOL_USE_RE) ?? []).length;
   ctx.toolResults += (ctxText.match(TYPE_TOOL_RESULT_RE) ?? []).length;
   ctx.systemReminders += (ctxText.match(SYSTEM_REMINDER_RE) ?? []).length;
@@ -655,12 +734,13 @@ function scanTranscript(path) {
 }
 
 // What session-enrichment.mjs calls, and the rules the Projects report
-// (account-projects.mjs) reads its own pass of the transcripts by: which lines
-// billed anything, and the speed each was billed at with the cap on how many
-// speeds one model keeps apart. Listed here rather than marked at each
-// declaration so that every declaration above reads exactly as it did where it
-// came from.
+// (account-projects.mjs) reads its own pass of the transcripts by: which record
+// of a request it is billed from, which lines billed anything, and the speed
+// each was billed at with the cap on how many speeds one model keeps apart.
+// Listed here rather than marked at each declaration so that every declaration
+// above reads exactly as it did where it came from.
 export {
-  scanTranscript, newUsageTotals, hasSpend, mergeUsageByModel, copyUsageBucket, repeatsRequestUsage,
+  scanTranscript, newUsageTotals, hasSpend, mergeUsageByModel, copyUsageBucket,
+  requestBilling, streamingRequestId, BILL_LINE, REBILL_REQUEST, SKIP_LINE,
   billedSpeed, MAX_SPEEDS_PER_MODEL, UNRECOGNISED_SPEED,
 };