ccdeck 3.38.3 → 3.38.5

package/src/server/thermal-metrics.mjs

@@ -111,10 +111,19 @@ import { run } from "./metrics-run.mjs";
 //            Reasoned from the documented layout, not yet run on a localised
 //            Windows.
 //
-//            A MODERN INTEL LAPTOP declares no zone at all: Intel DTT manages
-//            its sensors and publishes them only to an administrator. There the
-//            degrees come from LibreHardwareMonitor's local web server when the
-//            user already runs it — see hwmonitor.mjs.
+//            A ZONE IS NOT THE CPU, AND IT MAY NOT BE A SENSOR AT ALL. An ACPI
+//            zone measures whatever the firmware wired it to — the skin, the
+//            board, the embedded controller's idea of the hottest of those —
+//            and on a lot of laptops it measures nothing: Intel's reference
+//            firmware returns a constant 3010 (drawn as 28°C) when it has no
+//            source. So a zone is drawn only once it has been seen to change,
+//            and never under the name CPU. See zonesSeenAfter.
+//
+//            A MODERN INTEL LAPTOP declares no zone at all, or one that never
+//            moves: Intel DTT manages its sensors and publishes them only to an
+//            administrator. There the degrees come from LibreHardwareMonitor's
+//            local web server when the user already runs it — see
+//            hwmonitor.mjs.
 //
 // NEVER INVENT A READING. No sensor means no row, and no rows at all means the
 // section is not rendered: not 0°C, not a dash, not a grey empty bar. Same rule
@@ -599,31 +608,93 @@ export async function readThermal(platform = process.platform, since = null) {
     return darwinThermal({ gpuC, throttle, macmon });
   }
 
-  if (platform === "win32") {
-    // One child for both sources rather than two, because the cost here is the
-    // PowerShell start and not the queries: the counter is tried first because
-    // it needs no administrator, and MSAcpi only when the counter said nothing.
-    // Both are wrapped in their own try — "no thermal zone on this machine" is
-    // the ordinary answer and arrives as a throw from either.
-    const out = await run("powershell.exe", [
-      "-NoProfile", "-NonInteractive", "-Command", WIN_THERMAL_PS,
-    ], 6_000);
-    const answer = out ? parseWinThermal(out.trim()) : [];
-    if (answer.length) return { celsius: answer, throttle: null };
-
-    // Windows itself had nothing, which on a modern Intel laptop is every time:
-    // the firmware declares no ACPI thermal zone and the sensors sit behind
-    // Intel DTT, which an ordinary process may not read. If something on this
-    // machine has already gone and got them — LibreHardwareMonitor, with its
-    // web server on — they are a plain HTTP read away. Never installed, never
-    // asked for. See hwmonitor.mjs.
-    const { readHwMonitorTemps } = await import("./hwmonitor.mjs");
-    const t = await readHwMonitorTemps();
-    const rows = [];
-    if (t.cpu != null) rows.push({ label: "CPU", celsius: t.cpu, warnAt: WARN_C, critAt: CRIT_C });
-    if (t.gpu != null) rows.push({ label: "GPU", celsius: t.gpu, warnAt: WARN_C, critAt: CRIT_C });
-    return rows.length ? { celsius: rows, throttle: null } : null;
-  }
+  if (platform === "win32") return readWindowsThermal(since);
 
   return null;
 }
+
+/**
+ * The Windows rows, from the PowerShell child and, failing that, from a running
+ * LibreHardwareMonitor.
+ *
+ * `deps` is a seam for the reason sampleThermal's `deps.read` is: the suite
+ * must never start PowerShell, so `powershell` stands in for the child's output
+ * and `hwMonitor` for the read of the local web server.
+ */
+export async function readWindowsThermal(since = null, deps = {}) {
+  // One child for both sources rather than two, because the cost here is the
+  // PowerShell start and not the queries: the counter is tried first because
+  // it needs no administrator, and MSAcpi only when the counter said nothing.
+  // Both are wrapped in their own try — "no thermal zone on this machine" is
+  // the ordinary answer and arrives as a throw from either.
+  const powershell = deps.powershell ?? (() => run("powershell.exe", [
+    "-NoProfile", "-NonInteractive", "-Command", WIN_THERMAL_PS,
+  ], 6_000));
+  const hwMonitor = deps.hwMonitor
+    ?? (async () => (await import("./hwmonitor.mjs")).readHwMonitorTemps());
+
+  const out = await powershell();
+  const zones = out ? parseWinThermal(out.trim()) : [];
+  const zonesSeen = zonesSeenAfter(zones, since?.zonesSeen);
+  const memory = Object.keys(zonesSeen).length ? { zonesSeen } : {};
+  const moved = zones.filter(z => zonesSeen[z.label].moved);
+  if (moved.length) return { celsius: moved, throttle: null, ...memory };
+
+  // Windows had no zone that has moved, which on a modern Intel laptop is
+  // every time: the firmware declares no ACPI thermal zone, or declares one
+  // that returns a constant, and the sensors sit behind Intel DTT, which an
+  // ordinary process may not read. If something on this machine has already
+  // gone and got them — LibreHardwareMonitor, with its web server on — they
+  // are a plain HTTP read away. Never installed, never asked for. See
+  // hwmonitor.mjs.
+  const t = await hwMonitor();
+  const rows = [];
+  if (t.cpu != null) rows.push({ label: "CPU", celsius: t.cpu, warnAt: WARN_C, critAt: CRIT_C });
+  if (t.gpu != null) rows.push({ label: "GPU", celsius: t.gpu, warnAt: WARN_C, critAt: CRIT_C });
+  if (rows.length) return { celsius: rows, throttle: null, ...memory };
+
+  // A zone that has not moved yet is still a zone, so this is an answer with
+  // nothing to draw rather than null. Null would let the sampler give up after
+  // three readings, and a real zone that idled on one value for half a minute
+  // would then never be drawn. thermalSnapshot keeps it off the panel.
+  return zones.length ? { celsius: [], throttle: null, zonesSeen } : null;
+}
+
+/**
+ * Which Windows zones have been seen to change since the deck started, keyed by
+ * the zone's row label: the first value each one read, and whether it has
+ * since read anything else.
+ *
+ * A ZONE IS DRAWN ONLY ONCE IT HAS MOVED. Intel's client reference firmware,
+ * which most laptop BIOSes are built from, ends the package zone's `_TMP` with
+ * "Return a static value if no source is available. Return(3010)" — 27.85°C,
+ * drawn as 28 — and returns a static 3000 when legacy thermal management is
+ * off. Where the zone does have a source it is the embedded controller's "max
+ * platform temperature", never the die. Drawn as it came, a zone stuck on
+ * 3010 reads "Thermal zone 28 °C" on a laptop whose CPU is far hotter, which is
+ * a reading this module invents by passing it on.
+ *
+ * The test is Microsoft's own for a zone: "Each thermal zone must report
+ * actual temperature on the sensor (_TMP). The test runs a varying workload on
+ * the PC, and the temperature is expected to change." Movement rather than a
+ * list of known constants, because a constant is a firmware's choice and the
+ * next one may choose another — and because a firmware that adds 2730 rather
+ * than 2732 reads a real 28°C as 3010, which a list would hide.
+ *
+ * WHAT IT COSTS: a real zone that holds one value from the moment the deck
+ * starts is not drawn until it first changes. Once it has, it stays drawn for
+ * the life of the process however still it then sits — `moved` never goes back.
+ * Compared in whole degrees, because that is what the row shows: a zone whose
+ * row would never change is indistinguishable from a constant to whoever reads
+ * it.
+ */
+function zonesSeenAfter(zones, before = {}) {
+  const seen = { ...before };
+  for (const z of zones) {
+    const prior = seen[z.label];
+    seen[z.label] = prior
+      ? { first: prior.first, moved: prior.moved || z.celsius !== prior.first }
+      : { first: z.celsius, moved: false };
+  }
+  return seen;
+}

package/src/server/thermal-sampler.mjs

@@ -181,12 +181,16 @@ export function lastThermal() {
 }
 
 /** The thermal row /api/system answers: the last reading, with whether the
- *  machine has been held back since the deck started, or null without one. */
+ *  machine has been held back since the deck started, or null without one —
+ *  and null for a reading with nothing to draw, which is a Windows machine
+ *  whose zones have not moved yet (readWindowsThermal). The panel draws a
+ *  section for any object it is handed, and an empty one is not a reading. */
 export function thermalSnapshot() {
   if (!thermal) return null;
-  // The raw kernel count is the sampler's, for the next difference, and not a
-  // reading: the route answers what the panel draws.
-  const { throttleCount, ...shown } = thermal;
+  // The raw kernel count and the zones' first values are the sampler's, for
+  // the next reading, and not readings: the route answers what the panel draws.
+  const { throttleCount, zonesSeen, ...shown } = thermal;
+  if (!shown.celsius?.length && !shown.throttle) return null;
   return { ...shown, heldBack: heldBackSoFar() };
 }
 

package/src/server/transcript-scan.mjs

@@ -233,13 +233,36 @@ const USAGE_TOTAL_FIELDS = [...USAGE_BLOCK_FIELDS, ...CACHE_SPLIT_FIELDS];
  *  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;
-  }
+  for (const k of fields) chargeTokens(state, bucket, speedBucket, charged, k, grabUsageField(blob, k));
+}
+
+/** Charge a request's record from its parsed `message.usage`, the same way.
+ *
+ *  Not off the text, as chargeUsage reads a line: USAGE_BLOCK_RE's `[^}]+`
+ *  stops at the first `}`, and a subagent's streaming snapshot writes its
+ *  `cache_creation` sub-object before `output_tokens` (all 49,046 snapshots on
+ *  one machine), so the output a snapshot had streamed read as 0 until the
+ *  final record came, and stayed 0 for a request that never finished. A
+ *  request's record names its model, so the line is parsed already; the
+ *  Projects report reads the same object (countersFrom in account-projects.mjs). */
+function chargeRequestUsage(state, bucket, usage, speedBucket, charged) {
+  const split = usage?.cache_creation;
+  for (const k of USAGE_BLOCK_FIELDS) chargeTokens(state, bucket, speedBucket, charged, k, tokenCount(usage?.[k]));
+  for (const k of CACHE_SPLIT_FIELDS) chargeTokens(state, bucket, speedBucket, charged, k, tokenCount(split?.[k]));
+}
+
+/** Add `n` tokens of counter `k` to every place one charge goes. */
+function chargeTokens(state, bucket, speedBucket, charged, k, n) {
+  state.usage[k] += n;
+  if (bucket) bucket[k] += n;
+  if (speedBucket) speedBucket[k] += n;
+  charged[k] += n;
+}
+
+/** A usage counter as a token count: a whole number of tokens, or 0 for
+ *  anything else, as USAGE_FIELD_RE reads one off the text. */
+function tokenCount(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.trunc(v) : 0;
 }
 
 /** Add one bucket's counters, and its speed shares, into `dst`. */
@@ -329,9 +352,10 @@ 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,
+    // What this file has read of its requests: the newest request record, and
+    // the request billed from a snapshot whose final record has not been read
+    // yet, with what it was charged — see requestBilling.
+    requests: newRequestLedger(),
     ctx: newContextBreakdown(),
   };
 }
@@ -469,24 +493,82 @@ const SKIP_LINE = "skip";
  * the request it is waiting on, so the two can arrive in different passes,
  * which for a live subagent is the usual case.
  *
+ * A resumed subagent writes its history into its file again before the new
+ * turn: the same records, with the same `uuid`, `requestId` and `timestamp`,
+ * usually byte for byte. Billed as they came, every request in that history was
+ * charged once more per replay — on one machine 98 requests in two files, 821
+ * times over. A restated record is told apart by its timestamp, which is older
+ * than the newest request record the file has already read: nothing Claude
+ * Code writes fresh is, none of 162,790 request records on that machine. Telling
+ * them apart by request id would need every id a file has billed, kept for as
+ * long as the file can grow and persisted with the Projects tally; the newest
+ * timestamp is one number. See restatesEarlierRecord.
+ *
+ * A file that starts in the middle of a request — a fork's file opens with its
+ * parent's turn, a resumed agent's with the one it stopped in — has no block 0
+ * for it, and that request is not billed here. It is not this file's: on that
+ * machine 36 of 38 such openings were requests the parent's or the earlier
+ * agent's transcript bills in full, block 0 and final record. The other two
+ * were workflow agents whose transcript continued in a second file mid-request,
+ * the snapshot billed at the end of the first and the final record opening the
+ * second; billing that record here would need to know what the other file
+ * charged for it.
+ *
  *   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
+ *                   record, which restates it, or a record restated by a replay
  *
- * The Projects report (account-projects.mjs) bills its own pass of the same
- * lines by this rule.
+ * `ledger` is what the file has read of its requests so far (newRequestLedger),
+ * or null for none; noteRequestRecord adds each record to it. The Projects
+ * report (account-projects.mjs) bills its own pass of the same lines by this
+ * rule.
  */
-function requestBilling(record, streamingId) {
+function requestBilling(record, ledger) {
   if (record?.apiBlockIndex === undefined) return BILL_LINE;
+  if (restatesEarlierRecord(record, ledger)) return SKIP_LINE;
   const id = requestIdOf(record);
-  if (id !== null && id === streamingId && isUsageRecord(record)) return REBILL_REQUEST;
+  if (id !== null && id === ledger?.streaming?.id && isUsageRecord(record)) return REBILL_REQUEST;
   return record.apiBlockIndex === 0 ? BILL_REQUEST : SKIP_LINE;
 }
 
+/** What one file has read of its requests, for requestBilling: when the newest
+ *  request record was written and which request it was, and the request still
+ *  streaming — `{ id, … }` with whatever its caller needs to take its charge
+ *  back — or null. Plain data, so the Projects report can persist it. */
+function newRequestLedger() {
+  return { newestAt: null, newestId: null, streaming: null };
+}
+
+/** Is `record` a copy of one the file has already read, written again by a
+ *  resumed subagent restating its history? The copy keeps its original
+ *  timestamp, so it is older than the newest request record read — or, written
+ *  at that same moment, it is block 0 of the very request that record belongs
+ *  to, which a request has only one of. A later block at that moment is not a
+ *  copy: Claude Code writes two blocks of one request within a millisecond
+ *  often enough (38 times on that machine). A record without a timestamp is
+ *  never taken for a copy. */
+function restatesEarlierRecord(record, ledger) {
+  const at = Date.parse(record.timestamp);
+  const newest = ledger?.newestAt ?? null;
+  if (newest === null || !Number.isFinite(at)) return false;
+  if (at !== newest) return at < newest;
+  const id = requestIdOf(record);
+  return record.apiBlockIndex === 0 && id !== null && id === ledger.newestId;
+}
+
+/** Add a request record to the file's ledger, once it has been billed by
+ *  requestBilling — skipped or not, it is a record the file has read. */
+function noteRequestRecord(ledger, record) {
+  const at = Date.parse(record.timestamp);
+  if (!Number.isFinite(at) || (ledger.newestAt !== null && at < ledger.newestAt)) return;
+  ledger.newestAt = at;
+  ledger.newestId = requestIdOf(record);
+}
+
 /** 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) {
@@ -509,10 +591,11 @@ function isUsageRecord(record) {
  *  or null when it names no model. */
 function foldUsageLine(state, line, record) {
   // A request is billed once, from its final record — see requestBilling.
-  const streaming = state.streamingRequest;
-  const billing = requestBilling(record, streaming?.id ?? null);
+  const ledger = state.requests;
+  const billing = requestBilling(record, ledger);
+  if (billing !== BILL_LINE) noteRequestRecord(ledger, record);
   if (billing === SKIP_LINE) return;
-  if (billing === REBILL_REQUEST) refundUsage(state, streaming);
+  if (billing === REBILL_REQUEST) refundUsage(state, ledger.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
@@ -532,21 +615,24 @@ function foldUsageLine(state, line, record) {
   // text: a split that read a wider stretch of the line than the total it splits
   // would re-introduce #685's double count on one side of the arithmetic only,
   // and the two would stop summing to each other.
-  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, charged);
-  }
-  for (const m of billed.replace(ITERATIONS_ARRAY_RE, "").matchAll(CACHE_CREATION_BLOCK_RE)) {
-    chargeUsage(state, bucket, m[1], CACHE_SPLIT_FIELDS, speedBucket, charged);
+  if (billing === BILL_LINE) {
+    const billed = billedUsageText(line);
+    for (const m of billed.matchAll(USAGE_BLOCK_RE)) {
+      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, charged);
+    }
+    return;
   }
-  if (billing === BILL_LINE) return;
+  chargeRequestUsage(state, bucket, record.message?.usage, speedBucket, charged);
   // 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 };
+  ledger.streaming = id === null ? null : { id, bucket, speedBucket, charged };
 }
 
 /** Take back what a request was charged, from every counter it was charged
@@ -741,6 +827,6 @@ function scanTranscript(path) {
 // above reads exactly as it did where it came from.
 export {
   scanTranscript, newUsageTotals, hasSpend, mergeUsageByModel, copyUsageBucket,
-  requestBilling, streamingRequestId, BILL_LINE, REBILL_REQUEST, SKIP_LINE,
-  billedSpeed, MAX_SPEEDS_PER_MODEL, UNRECOGNISED_SPEED,
+  requestBilling, newRequestLedger, noteRequestRecord, streamingRequestId,
+  BILL_LINE, REBILL_REQUEST, SKIP_LINE, billedSpeed, MAX_SPEEDS_PER_MODEL, UNRECOGNISED_SPEED,
 };