@bli-cockpit/cli 0.2.113 → 0.2.115

package/dist/adapters/claude-attribution-score.js

@@ -1,3 +1,4 @@
+import { finalizeSessionFacts, newSessionFactsAccumulator, observeSessionFactsContent, observeSessionFactsFile, } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
@@ -11,9 +12,15 @@ import { CLAUDE_SESSION_MAX_FILE_BYTES, } from "./claude-attribution-types.js";
  * Turns one discovered session into an attribution verdict: read (or, for an
  * oversized main, stream) its signals, score them against the known
  * worktrees, and validate its sidecars against the winning worktree.
+ *
+ * The same pass counts the session's deterministic facts (BLI-4341) so the
+ * upload carries its own token totals. Only files that belong to this session
+ * are counted: a sidecar rejected for a cwd mismatch is another worktree's
+ * work and must not inflate this session's numbers.
  */
 export async function attributeOneSession(session, worktrees, collectionRoots) {
     const fileName = path.basename(session.mainFile);
+    const factsAcc = newSessionFactsAccumulator("claude_code");
     const base = {
         file_path: session.mainFile,
         file_name: fileName,
@@ -29,6 +36,7 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
         oversized_lines_skipped: 0,
         sidecars_capped: session.sidecarsCapped,
         sidecar_files: [],
+        session_facts: null,
     };
     if (session.mainByteSize === 0) {
         return skippedResult(base, "empty_file");
@@ -40,7 +48,7 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
         // bytes themselves are not uploaded until the collection ceiling changes.
         let streamed;
         try {
-            streamed = await streamMainSignals(session.mainFile);
+            streamed = await streamMainSignals(session.mainFile, factsAcc);
         }
         catch (error) {
             // A read race on one oversized main must not abort the whole scan; honor
@@ -55,6 +63,10 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
             return skippedResult(base, "file_read_failed");
         }
         signals = streamed.signals;
+        observeSessionFactsFile(factsAcc, {
+            bytes: streamed.byteSize,
+            lines: streamed.signals.line_count,
+        });
         base.content_hash_sha256 = streamed.contentHash;
         base.byte_size = streamed.byteSize;
         base.main_file_oversized = true;
@@ -80,7 +92,11 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
         if (content.trim() === "") {
             return skippedResult(base, "empty_file");
         }
-        signals = extractClaudeSessionSignals(content);
+        signals = extractClaudeSessionSignals(content, factsAcc);
+        observeSessionFactsFile(factsAcc, {
+            bytes: raw.byteLength,
+            lines: signals.line_count,
+        });
     }
     const metaSessionId = sanitizeSessionId(signals.session_ids[0]);
     if (metaSessionId) {
@@ -116,7 +132,7 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
     if (isSchemaDriftSuspected(signals))
         extraSignals.push("schema_drift_suspected");
     const sidecarFiles = isRawEvidenceUploadableAttributionState(outcome.state, outcome.worktree !== null) && outcome.worktree
-        ? await collectSidecarDiagnostics(session.sidecars, outcome.worktree)
+        ? await collectSidecarDiagnostics(session.sidecars, outcome.worktree, factsAcc)
         : session.sidecars.map((sidecar) => ({
             local_path: sidecar.local_path,
             file_name: sidecar.file_name,
@@ -126,6 +142,7 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
         }));
     return {
         ...base,
+        session_facts: finalizeSessionFacts(factsAcc),
         state: outcome.state,
         reason: outcome.reason,
         signals: [...outcome.signals, ...extraSignals],
@@ -143,7 +160,7 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
  * oversized sidecar is recorded with a reason and the session stays
  * harvestable.
  */
-async function collectSidecarDiagnostics(sidecars, worktree) {
+async function collectSidecarDiagnostics(sidecars, worktree, facts) {
     const out = [];
     for (const sidecar of sidecars) {
         const entry = {
@@ -181,6 +198,9 @@ async function collectSidecarDiagnostics(sidecars, worktree) {
             out.push({ ...entry, skipped_reason: "sidecar_cwd_mismatch" });
             continue;
         }
+        // Accepted: this subagent's turns are part of this session, so its tokens
+        // are too. Counted only now, after the cwd check has cleared it.
+        observeSessionFactsContent(facts, content);
         out.push({
             ...entry,
             byte_size: raw.byteLength,

package/dist/adapters/claude-attribution-signals.js

@@ -1,3 +1,4 @@
+import { observeSessionFactsRecord, } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import { createReadStream } from "node:fs";
 import { StringDecoder } from "node:string_decoder";
@@ -7,15 +8,18 @@ import { CONTENT_RECORD_TYPES, MAX_LINE_BUFFER_BYTES, SCHEMA_DRIFT_MIN_HIT_RATE,
  * `cwd`, `gitBranch`, `sessionId`, and `prRepository` (pr-link records).
  * Structurally identical to the Codex extractor, with the allowlist enforced
  * by construction — no generic record walk that could surface message bodies.
+ *
+ * Pass a session-facts accumulator to have the SAME parse feed the upload-time
+ * deterministic count (BLI-4341); without one the pass is unchanged.
  */
-export function extractClaudeSessionSignals(content) {
-    const accumulator = createSignalAccumulator();
+export function extractClaudeSessionSignals(content, facts) {
+    const accumulator = createSignalAccumulator(facts);
     for (const line of content.split("\n")) {
         accumulator.processLine(line);
     }
     return accumulator.finalize();
 }
-function createSignalAccumulator() {
+function createSignalAccumulator(facts) {
     const sessionIds = new Set();
     const cwds = new Set();
     const branches = new Set();
@@ -41,9 +45,12 @@ function createSignalAccumulator() {
                 parseErrorCount += 1;
                 return;
             }
-            if (!record || typeof record !== "object")
+            if (!record || typeof record !== "object" || Array.isArray(record))
                 return;
             const entry = record;
+            // Counting is not reading: the facts module returns totals, never text.
+            if (facts)
+                observeSessionFactsRecord(facts, entry);
             const type = typeof entry["type"] === "string" ? entry["type"] : "";
             const cwd = stringOrNull(entry["cwd"]);
             const sessionId = stringOrNull(entry["sessionId"]);
@@ -96,8 +103,8 @@ export function isSchemaDriftSuspected(signals) {
         return true;
     return signals.envelope_field_hit_rate < SCHEMA_DRIFT_MIN_HIT_RATE;
 }
-export async function streamMainSignals(filePath) {
-    const accumulator = createSignalAccumulator();
+export async function streamMainSignals(filePath, facts) {
+    const accumulator = createSignalAccumulator(facts);
     const hash = crypto.createHash("sha256");
     let oversizedLinesSkipped = 0;
     let byteSize = 0;

package/dist/adapters/claude-attribution-types.js

@@ -1,4 +1,4 @@
-import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core";
+import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, } from "@bli-cockpit/telemetry-core";
 /**
  * The shapes and tuning constants `claude-attribution.ts` and its siblings
  * (discovery, score, signals) all agree on. Kept in one module so none of

package/dist/adapters/codex-attribution.js

@@ -173,6 +173,7 @@ async function attributeOneSession(file, worktrees, collectionRoots) {
         session_file_mtime_ms: file.mtimeMs,
         byte_size: file.byteSize,
         content_hash_sha256: null,
+        session_facts: null,
     };
     let read;
     try {
@@ -191,6 +192,7 @@ async function attributeOneSession(file, worktrees, collectionRoots) {
     }
     base.content_hash_sha256 = read.contentHashSha256;
     base.byte_size = read.byteSize;
+    base.session_facts = read.facts;
     const signals = read.signals;
     const metaSessionId = sanitizeSessionId(signals.session_ids[0]);
     if (metaSessionId) {

package/dist/adapters/codex-session-signals.js

@@ -11,7 +11,13 @@
  * disk (sessions run to hundreds of megabytes, so the file is never held in
  * memory and its sha256 is taken on the way past), and
  * `extractCodexSessionSignals` takes content already in hand.
+ *
+ * The same streaming pass also counts the session's deterministic facts
+ * (BLI-4341): token totals per model, turn and tool counts, timestamps, size.
+ * The bytes are already in hand and already parsed, so counting them here
+ * costs one function call per record and saves the server a download.
  */
+import { finalizeSessionFacts, newSessionFactsAccumulator, observeSessionFactsFile, observeSessionFactsRecord, } from "@bli-cockpit/telemetry-core";
 import { createReadStream } from "node:fs";
 import crypto from "node:crypto";
 import { StringDecoder } from "node:string_decoder";
@@ -63,8 +69,10 @@ export async function readCodexMetadataSignals(filePath) {
         lineBuffer += rest;
     if (lineBuffer.trim())
         absorbCodexSessionLine(state, lineBuffer);
+    observeSessionFactsFile(state.facts, { bytes: byteSize, lines: state.lineCount });
     return {
         signals: codexSignalsFromState(state),
+        facts: finalizeSessionFacts(state.facts),
         contentHashSha256: hash.digest("hex"),
         byteSize,
     };
@@ -86,6 +94,7 @@ function makeSignalExtractionState() {
         repositoryUrls: new Set(),
         lineCount: 0,
         parseErrorCount: 0,
+        facts: newSessionFactsAccumulator("codex"),
     };
 }
 function absorbCodexSessionLine(state, line) {
@@ -105,8 +114,11 @@ function absorbCodexSessionLine(state, line) {
         state.parseErrorCount += 1;
         return;
     }
-    if (!record || typeof record !== "object")
+    if (!record || typeof record !== "object" || Array.isArray(record))
         return;
+    // Every record feeds the facts count; only the two metadata types below feed
+    // attribution.
+    observeSessionFactsRecord(state.facts, record);
     const type = record.type;
     if (type !== "session_meta" && type !== "turn_context")
         return;

package/dist/commands/agent-session-report.js

@@ -43,6 +43,7 @@ function normalizeCodexResult(result) {
         worktree: result.worktree,
         cwd_basename: result.cwd_basename,
         cwd_hash: result.cwd_hash,
+        session_facts: result.session_facts,
     };
 }
 function normalizeClaudeResult(result) {
@@ -61,6 +62,7 @@ function normalizeClaudeResult(result) {
         worktree: result.worktree,
         cwd_basename: result.cwd_basename,
         cwd_hash: result.cwd_hash,
+        session_facts: result.session_facts,
     };
 }
 /**
@@ -154,6 +156,10 @@ function sessionReportEntry(result, context) {
             : {}),
         session_file_byte_size: result.byte_size,
         session_file_mtime: result.session_file_mtime,
+        // Every session arrives counted (BLI-4341). Absent only when the file
+        // could not be read at all, which is the one case the server's extraction
+        // pass still has to cover.
+        ...(result.session_facts ? { session_facts: result.session_facts } : {}),
         ...(result.worktree
             ? {
                 repo_fingerprint: result.worktree.repo_fingerprint,

package/dist/commands/ops-render-ladder.js

@@ -15,9 +15,22 @@ export function renderLadder(ladder, dim) {
     }
     if (reasons.length > 8)
         lines.push(dim(`  ${reasons.length - 8} more reasons not shown`));
+    // BLI-4343: deferred is its OWN count. A row waiting on a corpus pass is
+    // pending and not stuck, and the two look identical without this line.
+    if ((ladder.deferred ?? 0) > 0) {
+        const soonest = ladder.soonest_defer_until;
+        const when = typeof soonest === "string" ? `, soonest retry ${soonest}` : "";
+        lines.push(dim(`  ${ladder.deferred} row(s) deferred, waiting on another pass${when}`));
+    }
     if ((ladder.stale_leases ?? 0) > 0) {
         lines.push(dim(`  ${ladder.stale_leases} stale lease(s) waiting to be taken over`));
     }
+    // BLI-4352: work no rung status can show. A session whose four rungs all
+    // succeeded can still be carrying the old token-weight session label, and
+    // the re-label run is steered by this number.
+    if ((ladder.labels_v1_remaining ?? 0) > 0) {
+        lines.push(dim(`  ${ladder.labels_v1_remaining} session label(s) still on the old provenance`));
+    }
     if (ladder.oldest_pending_session_id) {
         lines.push(dim(`  oldest pending session ${ladder.oldest_pending_session_id}`));
     }

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.113");
+    writeLine(io?.stdout ?? process.stdout, "0.2.115");
     return 0;
   }
 

package/dist/commands/session-sync.js

@@ -108,6 +108,16 @@ export async function runAttributedWorktreeSync(options) {
         now,
         claudePriorDurablePointers: worktreePass.claudePriorDurablePointers,
     });
+    // BLI-4341: every session should arrive counted. Say how many did, and say
+    // it on the success path too: a silent drop from "all" to "some" is exactly
+    // the kind of decay nobody notices.
+    const sessionsCounted = sessions.filter((session) => session.session_facts).length;
+    console.error("[session-sync] session facts counted at upload", JSON.stringify({
+        reason: sessionsCounted === sessions.length ? "counted_at_upload" : "some_sessions_unreadable",
+        sessions: sessions.length,
+        counted: sessionsCounted,
+        tokens_total: sessions.reduce((total, session) => total + (session.session_facts?.total_tokens ?? 0), 0),
+    }));
     const delivery = await reportSessionsAndAdvanceCursors({
         run: options,
         paths,

package/dist/commands/usage.js

@@ -43,7 +43,7 @@ export async function runUsage(command, io) {
         if (!email)
             return failAgentDoor(door, "[usage]", "caller_email_unavailable", "The paired session has no email. Sign in again or pass --person <email>.");
         body.people = (body.people ?? []).filter((person) => person.email?.toLowerCase() === email.toLowerCase());
-        body.coverage = { sessions_labelled: body.people.reduce((total, person) => total + (person.sessions_labelled ?? 0), 0), sessions_extracted: body.people.reduce((total, person) => total + person.sessions_extracted, 0), sessions_observed: body.people.reduce((total, person) => total + person.sessions_observed, 0) };
+        body.coverage = { sessions_labelled: body.people.reduce((total, person) => total + (person.sessions_labelled ?? 0), 0), sessions_extracted: body.people.reduce((total, person) => total + person.sessions_extracted, 0), sessions_observed: body.people.reduce((total, person) => total + person.sessions_observed, 0), sessions_counted_at_upload: body.people.reduce((total, person) => total + (person.sessions_counted_at_upload ?? 0), 0), sessions_counted_by_server: body.people.reduce((total, person) => total + (person.sessions_counted_by_server ?? 0), 0), sessions_counted_by_ladder: body.people.reduce((total, person) => total + (person.sessions_counted_by_ladder ?? 0), 0) };
     }
     if (command.byRepo && body.people?.some((person) => !Array.isArray(person.repos))) {
         return failAgentDoor(door, "[usage]", "repo_grouping_unavailable", "The dashboard returned person totals without project rows. Deploy the dashboard project split before using --by-repo.");
@@ -104,6 +104,11 @@ export async function runUsage(command, io) {
     writeLine(io.stdout, "");
     writeLine(io.stdout, body.api_list_price_equivalent_label ?? "API list-price equivalent (not actual spend)");
     writeLine(io.stdout, `${body.coverage?.sessions_extracted ?? 0} of ${body.coverage?.sessions_observed ?? 0} sessions extracted`);
+    // BLI-4341: a session should arrive counted. This line is how a person sees
+    // whether that is happening, or whether something else is doing the work.
+    // BLI-4351 added the third counter: the ladder, counting out of Storage the
+    // sessions that arrived before the collector counted anything.
+    writeLine(io.stdout, `${body.coverage?.sessions_counted_at_upload ?? 0} of ${body.coverage?.sessions_observed ?? 0} sessions counted at upload, ${body.coverage?.sessions_counted_by_server ?? 0} by server backfill, ${body.coverage?.sessions_counted_by_ladder ?? 0} by the ladder`);
     if (command.bySubject)
         writeLine(io.stdout, `${(body.people ?? []).reduce((n, person) => n + (person.sessions_summarized ?? 0), 0)} of ${body.coverage?.sessions_observed ?? 0} sessions summarized`);
     if (command.byTopic)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.113",
+  "version": "0.2.115",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,8 +27,8 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.31",
-    "@bli-cockpit/mcp": "0.1.41",
-    "@bli-cockpit/telemetry-core": "0.1.47"
+    "@bli-cockpit/memory-mcp": "0.1.32",
+    "@bli-cockpit/mcp": "0.1.43",
+    "@bli-cockpit/telemetry-core": "0.1.48"
   }
 }