@bli-cockpit/cli 0.2.194 → 0.2.195

package/dist/commands/agent-setup-observed.js

@@ -0,0 +1,131 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export const TRANSCRIPT_FILES = 12;
+export const TRANSCRIPT_WINDOW_MS = 30 * 86_400_000;
+const CHUNK_BYTES = 200_000;
+const MAX_STATTED = 3000;
+const SEMVER = /^\d+\.\d+\.\d+(?:[-+][a-z0-9.-]+)?$/i;
+/** Newer of two semver-looking strings by numeric core; a non-version never wins. */
+export function newerVersion(a, b) {
+    if (!b || !SEMVER.test(b))
+        return a;
+    if (!a || !SEMVER.test(a))
+        return b;
+    const pa = a.split(/[.-]/).slice(0, 3).map(Number), pb = b.split(/[.-]/).slice(0, 3).map(Number);
+    for (let i = 0; i < 3; i++)
+        if (pa[i] !== pb[i])
+            return pb[i] > pa[i] ? b : a;
+    return a;
+}
+/** The most frequent key, ties to the one seen first. */
+function top(counts) {
+    let best = null, n = 0;
+    for (const [key, count] of counts)
+        if (count > n) {
+            best = key;
+            n = count;
+        }
+    return best;
+}
+/** Fold sampled transcript text into one client reading. Pure, so tests feed it fixtures. */
+export function observeTranscripts(tool, samples) {
+    const models = new Map(), efforts = new Map();
+    let version = null;
+    const bump = (map, value) => {
+        if (typeof value === "string" && value && !value.startsWith("<"))
+            map.set(value, (map.get(value) ?? 0) + 1);
+    };
+    for (const sample of samples)
+        for (const line of sample.split("\n")) {
+            if (!line.startsWith("{"))
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            } // a chunk edge can cut a line
+            const payload = entry.payload && typeof entry.payload === "object" ? entry.payload : {};
+            if (tool === "claude") {
+                if (typeof entry.version === "string")
+                    version = newerVersion(version, entry.version);
+                const message = entry.message && typeof entry.message === "object" ? entry.message : {};
+                if (entry.type === "assistant")
+                    bump(models, message.model);
+            }
+            else if (entry.type === "session_meta") {
+                if (typeof payload.cli_version === "string")
+                    version = newerVersion(version, payload.cli_version);
+            }
+            else if (entry.type === "turn_context") {
+                bump(models, payload.model);
+                bump(efforts, payload.effort);
+            }
+        }
+    return { version, model: top(models), effort: top(efforts), files: samples.length };
+}
+async function sampleFile(file) {
+    let handle;
+    try {
+        handle = await fs.open(file, "r");
+        const { size } = await handle.stat();
+        const read = async (position, length) => {
+            const buffer = Buffer.alloc(length);
+            const { bytesRead } = await handle.read(buffer, 0, length, position);
+            return buffer.subarray(0, bytesRead).toString("utf8");
+        };
+        if (size <= CHUNK_BYTES * 2)
+            return await read(0, size);
+        return `${await read(0, CHUNK_BYTES)}\n${await read(size - CHUNK_BYTES, CHUNK_BYTES)}`;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+const entries = (directory) => fs.readdir(directory).catch(() => []);
+async function newestClaudeFiles(home, now) {
+    const root = path.join(home, ".claude", "projects");
+    const found = [];
+    let statted = 0;
+    for (const project of await entries(root)) {
+        for (const name of await entries(path.join(root, project))) {
+            if (!name.endsWith(".jsonl") || statted++ >= MAX_STATTED)
+                continue;
+            const file = path.join(root, project, name);
+            const stat = await fs.stat(file).catch(() => null);
+            if (stat && now - stat.mtimeMs <= TRANSCRIPT_WINDOW_MS)
+                found.push({ file, mtime: stat.mtimeMs });
+        }
+    }
+    return found.sort((a, b) => b.mtime - a.mtime).slice(0, TRANSCRIPT_FILES).map(entry => entry.file);
+}
+async function newestCodexFiles(home) {
+    const root = path.join(home, ".codex", "sessions");
+    const files = [];
+    const newestFirst = async (directory) => (await entries(directory)).sort().reverse();
+    for (const year of await newestFirst(root))
+        for (const month of await newestFirst(path.join(root, year)))
+            for (const day of await newestFirst(path.join(root, year, month))) {
+                for (const name of await newestFirst(path.join(root, year, month, day)))
+                    if (name.endsWith(".jsonl") && files.length < TRANSCRIPT_FILES)
+                        files.push(path.join(root, year, month, day, name));
+                if (files.length >= TRANSCRIPT_FILES)
+                    return files;
+            }
+    return files;
+}
+/** Text samples of the newest transcripts of one tool in the last 30 days. Never throws. */
+export async function readTranscriptSamples(tool, home, now = Date.now()) {
+    try {
+        const files = tool === "claude" ? await newestClaudeFiles(home, now) : await newestCodexFiles(home);
+        const samples = await Promise.all(files.map(sampleFile));
+        return samples.filter((sample) => sample !== null);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/commands/agent-setup.js

@@ -5,22 +5,45 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { AgentSetupSchema, SetupNameSchema } from "@bli-cockpit/telemetry-core";
 import { LOCAL_COLLECTOR_VERSION } from "../local-state.js";
+import { newerVersion, observeTranscripts, readTranscriptSamples } from "./agent-setup-observed.js";
+/** `--version` of a cold Claude start under launchd routinely took over 750 ms (BLI-13055). */
+export const VERSION_CHECK_TIMEOUT_MS = 5000;
 const exec = promisify(execFile);
 const files = {
     read: file => fs.readFile(file, "utf8"), list: directory => fs.readdir(directory),
     version: async (tool, platform) => {
         try {
-            const { stdout } = await exec(platform === "win32" ? `${tool}.exe` : tool, ["--version"], { timeout: 750, maxBuffer: 4096, windowsHide: true });
+            const { stdout } = await exec(platform === "win32" ? `${tool}.exe` : tool, ["--version"], { timeout: VERSION_CHECK_TIMEOUT_MS, maxBuffer: 4096, windowsHide: true });
             return /(?:^|\s)(\d+\.\d+\.\d+(?:[-+][a-z0-9.-]+)?)(?:\s|$)/i.exec(stdout)?.[1] ?? null;
         }
         catch {
             return null;
         }
     },
+    transcripts: (tool, home) => readTranscriptSamples(tool, home),
 };
 const safeName = (value) => SetupNameSchema.safeParse(value).success ? value : null;
 const names = (values) => [...new Set(values.flatMap(value => safeName(value) ? [value] : []))].sort().slice(0, 500);
 const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+/**
+ * Claude Code's default effort per model, from its own docs
+ * (https://code.claude.com/docs/en/model-config#adjust-effort-level, read
+ * 2026-10-08): `high` on every model that supports effort, except Opus 5.5,
+ * Sonnet 5.5 and Haiku 5.5 (`medium`) and Opus 4.7 (`xhigh`). A model this
+ * table does not know gets null, shown as "default" without a value.
+ */
+export function claudeDefaultEffort(model) {
+    if (!model)
+        return null;
+    if (/^claude-(opus|sonnet|haiku)-5-5/i.test(model))
+        return "medium";
+    if (/^claude-opus-4-7/i.test(model))
+        return "xhigh";
+    if (/^claude-(opus|sonnet)-(?:4-[68]|5)(?!-\d)/i.test(model))
+        return "high";
+    return null;
+}
+const claudeFamily = (model) => /opus|sonnet|haiku/i.exec(model ?? "")?.[0].toLowerCase() ?? null;
 /** Bounded, explicit locations only. Never recurse through a home or read env files. */
 export async function collectAgentSetup(home, platform = process.platform, io = files, now = new Date()) {
     const paths = platform === "win32" ? path.win32 : path.posix;
@@ -53,25 +76,58 @@ export async function collectAgentSetup(home, platform = process.platform, io =
             return null;
         }
     };
-    const installedVersion = async (tool) => {
-        const version = await io.version?.(tool, platform).catch(() => null);
-        if (safeName(version))
-            return version;
-        // npm shims on native Windows cannot be execFile'd without a shell. Read
-        // their installed package metadata instead, never the update-available cache.
-        const packageName = tool === "claude" ? "@anthropic-ai/claude-code" : "@openai/codex";
-        const packageFile = platform === "win32" ? join("AppData", "Roaming", "npm", "node_modules", ...packageName.split("/"), "package.json") :
-            paths.join(paths.dirname(process.execPath), "..", "lib", "node_modules", ...packageName.split("/"), "package.json");
-        const text = await read(packageFile);
-        try {
-            return safeName(object(JSON.parse(text ?? "null")).version);
+    const packageName = (tool) => tool === "claude" ? "@anthropic-ai/claude-code" : "@openai/codex";
+    const versionFromPackage = async (tool) => {
+        const parts = packageName(tool).split("/");
+        // Where npm puts a global package: Windows keeps it under AppData, macOS
+        // under the prefix of the node that installed it (Homebrew, /usr/local,
+        // a user prefix) or Claude Code's own ~/.claude/local install.
+        const roots = platform === "win32"
+            ? [join("AppData", "Roaming", "npm", "node_modules")]
+            : [paths.join(paths.dirname(process.execPath), "..", "lib", "node_modules"), "/opt/homebrew/lib/node_modules", "/usr/local/lib/node_modules", join(".npm-global", "lib", "node_modules")];
+        if (tool === "claude")
+            roots.push(join(".claude", "local", "node_modules"));
+        for (const root of roots) {
+            const text = await read(paths.join(root, ...parts, "package.json"));
+            try {
+                const version = safeName(object(JSON.parse(text ?? "null")).version);
+                if (version)
+                    return version;
+            }
+            catch { /* unreadable metadata: try the next root */ }
         }
-        catch {
-            return null;
+        if (tool === "claude") {
+            // Claude Code's native installer keeps one directory per version.
+            const native = platform === "win32" ? join("AppData", "Local", "claude", "versions") : join(".local", "share", "claude", "versions");
+            try {
+                return (await io.list(native)).reduce((newest, name) => newerVersion(newest, name.replace(/\.exe$/i, "")), null);
+            }
+            catch {
+                return null;
+            }
         }
+        return null;
+    };
+    const resolveVersion = async (tool, observing) => {
+        const viaCli = await io.version?.(tool, platform).catch(() => null);
+        if (safeName(viaCli))
+            return { value: viaCli, source: "cli" };
+        // npm shims on native Windows cannot be execFile'd without a shell. Read
+        // their installed package metadata instead, never the update-available cache.
+        const viaPackage = await versionFromPackage(tool);
+        if (viaPackage)
+            return { value: viaPackage, source: "package" };
+        const viaTranscript = safeName((await observing).version);
+        return viaTranscript ? { value: viaTranscript, source: "transcript" } : { value: null, source: "none" };
+    };
+    // Everything slow starts together: both `--version` checks (up to 5 s each) and
+    // both transcript samples run side by side, so the whole step costs one wait.
+    const observe = async (tool) => {
+        const samples = await io.transcripts?.(tool, home).catch(() => []) ?? [];
+        return observeTranscripts(tool, samples);
     };
-    const claudeVersion = await installedVersion("claude");
-    const codexVersion = await installedVersion("codex");
+    const claudeObserving = observe("claude"), codexObserving = observe("codex");
+    const [claudeVersion, codexVersion, claudeObserved, codexObserved] = await Promise.all([resolveVersion("claude", claudeObserving), resolveVersion("codex", codexObserving), claudeObserving, codexObserving]);
     const codexHooks = await json(".codex", "hooks.json");
     const claudePlugins = await json(".claude", "plugins", "installed_plugins.json");
     const pluginSkills = [], pluginAgents = [];
@@ -134,19 +190,33 @@ export async function collectAgentSetup(home, platform = process.platform, io =
             return { name, exists: error.code === "ENOENT" ? false : null, sha256: null, bytes: null };
         }
     }));
+    // Model: what the person set, else what their sessions actually ran most.
+    const claudeSetModel = safeName(claudeSettings?.model), codexSetModel = scalar("model");
+    const claudeModel = claudeSetModel ?? claudeObserved.model;
+    // The default effort belongs to the model that really runs. A set alias such
+    // as "opus" has no version, so the observed full id of that family refines it.
+    const claudeDefaultFor = claudeSetModel && claudeFamily(claudeSetModel) !== claudeFamily(claudeObserved.model) ? claudeSetModel : claudeObserved.model ?? claudeSetModel;
+    const claudeSetEffort = safeName(claudeSettings?.effortLevel), codexSetEffort = scalar("model_reasoning_effort");
+    const claudeDefault = claudeSetEffort ? null : claudeDefaultEffort(claudeDefaultFor);
     const result = AgentSetupSchema.parse({
         checked_at: now.toISOString(), os: platform === "darwin" || platform === "win32" ? platform : "other", cli_version: LOCAL_COLLECTOR_VERSION,
-        claude: { version: claudeVersion, model: safeName(claudeSettings?.model), effort: safeName(claudeSettings?.effortLevel),
+        claude: { version: claudeVersion.value, version_source: claudeVersion.source,
+            model: claudeModel, model_basis: claudeSetModel ? "set" : claudeModel ? "used" : "none",
+            effort: claudeSetEffort ?? claudeDefault, effort_basis: claudeSetEffort ? "set" : "default",
             skills: claudeSkills === null || pluginInventoryUnknown ? null : names([...claudeSkills, ...pluginSkills]), agents: claudeAgents === null || pluginInventoryUnknown ? null : names([...claudeAgents, ...pluginAgents]),
             plugins: claudePlugins === null ? null : names(Object.keys(object(claudePlugins.plugins))),
             hooks: claudeSettings === null ? null : names(Object.keys(object(claudeSettings.hooks))), mcp: claudeMcp },
-        codex: { version: codexVersion, model: scalar("model"), effort: scalar("model_reasoning_effort"),
+        codex: { version: codexVersion.value, version_source: codexVersion.source,
+            model: codexSetModel ?? codexObserved.model, model_basis: codexSetModel ? "set" : codexObserved.model ? "used" : "none",
+            effort: codexSetEffort ?? codexObserved.effort, effort_basis: codexSetEffort ? "set" : codexObserved.effort ? "observed" : "default",
             skills: codexSkills === null || sharedSkills === null || systemSkills === null ? null : names([...(codexSkills ?? []), ...(sharedSkills ?? []), ...(systemSkills ?? [])]),
             agents: toml === null ? null : names([...toml.matchAll(/^\s*\[agents\.([a-z0-9_-]+)\]\s*$/gim)].map(match => match[1])),
             plugins: toml === null ? null : names([...toml.matchAll(/^\s*\[plugins\."([a-z0-9_@.+-]+)"\]\s*$/gim)].map(match => match[1])),
             hooks: codexHooks === null && !/^notify\s*=/m.test(rootToml) ? null : names([...(codexHooks === null ? [] : Object.keys(object(codexHooks.hooks))), ...(/^notify\s*=/m.test(rootToml) ? ["notify"] : [])]), mcp: codexMcp }, instructions,
     });
-    const unknownFields = [result.claude, result.codex].reduce((count, tool) => count + Object.values(tool).filter(value => value === null).length, 0);
+    const evidence = (tool) => ({ version_source: result[tool].version_source, model_basis: result[tool].model_basis, effort_basis: result[tool].effort_basis });
+    console.error("[setup] versions read", JSON.stringify({ reason: "version_resolved", claude: evidence("claude"), codex: evidence("codex"), transcript_files: { claude: claudeObserved.files, codex: codexObserved.files } }));
+    const unknownFields = [result.claude, result.codex].reduce((count, tool) => count + ["skills", "plugins", "agents", "hooks", "mcp"].filter(key => tool[key] === null).length, 0);
     console.error("[setup] inventory read", JSON.stringify({ reason: unknownFields ? "inventory_partial" : "inventory_observed", unknown_fields: unknownFields, os: result.os, mcp_count: (result.claude.mcp?.length ?? 0) + (result.codex.mcp?.length ?? 0) }));
     return result;
 }

package/dist/commands/local-args-tower-setup.js

@@ -5,7 +5,7 @@ export function parseSetupArgs(args) {
         throw new Error("setup takes --person or --compare, not a subcommand.");
     const compare = optionalNonEmpty(values.flags.get("--compare"));
     if (compare && (compare.split(",").length !== 2 || compare.split(",").some(value => !value.trim())))
-        throw new Error("--compare takes two emails separated by a comma.");
+        throw new Error("--compare takes two people (first names or emails) separated by a comma.");
     const since = optionalNonEmpty(values.flags.get("--since"));
     if (since && since !== "7d" && since !== "30d" && (!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z)?$/.test(since) || !Number.isFinite(Date.parse(since)) || new Date(since).toISOString().slice(0, 10) !== since.slice(0, 10) || Date.parse(since) >= Date.now()))
         throw new Error("--since takes 7d, 30d, or an ISO date before now.");

package/dist/commands/local-args-tower-speed.js

@@ -1,12 +1,17 @@
 import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs } from "./local-arg-values.js";
+import { parseSeenWindow } from "./speed-seen.js";
 import { SPEED_PAGE_NAMES } from "./speed-pages.js";
 /** The most runs one page gets; a speed check is a handful of reads, not a load test. */
 export const SPEED_MAX_RUNS = 50;
-/** `cockpit speed [--page <name>]... [--runs <n>] [--json]` (BLI-13033). */
+/**
+ * `cockpit speed [--page <name>]... [--runs <n>] [--json]` (BLI-13033), and
+ * `cockpit speed --seen [--since <n>m|h|d] [--everyone] [--page <name>]... [--json]`
+ * for real-visit timings (BLI-13054).
+ */
 export function parseSpeedArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--page", "--runs", "--json", "--home", "--dashboard-url"],
-        valueFlags: ["--page", "--runs", "--home", "--dashboard-url"],
+        allowedFlags: ["--page", "--runs", "--json", "--home", "--dashboard-url", "--seen", "--since", "--everyone"],
+        valueFlags: ["--page", "--runs", "--home", "--dashboard-url", "--since"],
     });
     if (values.positionals.length) {
         throw new Error("speed takes --page <name>, not a subcommand. Pages: " + SPEED_PAGE_NAMES.join(", ") + ".");
@@ -20,10 +25,26 @@ export function parseSpeedArgs(args) {
     if (runs !== undefined && runs > SPEED_MAX_RUNS) {
         throw new Error(`--runs takes at most ${SPEED_MAX_RUNS}.`);
     }
+    const seen = values.booleans.has("--seen");
+    const sinceText = optionalNonEmpty(values.flags.get("--since"));
+    const everyone = values.booleans.has("--everyone");
+    if (!seen && (sinceText !== undefined || everyone)) {
+        throw new Error("--since and --everyone belong to `cockpit speed --seen`.");
+    }
+    if (seen && runs !== undefined)
+        throw new Error("--runs times the data doors; `--seen` reads real visits and takes no --runs.");
+    let since;
+    if (sinceText !== undefined) {
+        const window = parseSeenWindow(sinceText);
+        if (window === null)
+            throw new Error("--since takes <n>m, <n>h or <n>d, at most 30d (for example 24h).");
+        since = window;
+    }
     return {
         kind: "speed",
         pages: [...new Set(pages)],
         runs,
+        ...(seen ? { seen: true, ...(since ? { since } : {}), ...(everyone ? { everyone: true } : {}) } : {}),
         json: values.booleans.has("--json"),
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),

package/dist/commands/local-help-commands-tower.js

@@ -179,6 +179,7 @@ export const TOWER_COMMAND_HELP = [
         "speed",
         [
             "Usage: cockpit speed [--page <name>]... [--runs <n>] [--dashboard-url <url>] [--json]",
+            "       cockpit speed --seen [--since <n>m|h|d] [--everyone] [--page <name>]... [--dashboard-url <url>] [--json]",
             "",
             "Times every Tower rail page's data door from this terminal, with this machine's device token.",
             "Per page: the first run is reported as cold, the rest as warm; p50 and p95 are over the warm runs",
@@ -191,6 +192,12 @@ export const TOWER_COMMAND_HELP = [
             "It times the DATA DOOR the page opens on, not the page's HTML or paint, and it never uses the local read cache.",
             "Exits 1 when any page failed; a page that is not permitted does not fail the run.",
             "The same measurement is the speed_read MCP tool.",
+            "",
+            "--seen reads what REAL visits saw instead: per page the visit count, p50 and p95 first-useful milliseconds (the moment",
+            "real content showed, from the last-known screen or the fresh one), the share painted from the snapshot, and median HTML",
+            "and script transfer. The browser sends one metadata-only beacon per page view; nothing is measured from this machine.",
+            "--since <n>m|h|d is the window (default 24h, at most 30d). --everyone reads every person's visits (super_admin only).",
+            "A member sees their own visits. --page limits the table to those pages. The same read is the speed_seen MCP tool.",
         ],
     ],
     [

package/dist/commands/local-help-commands.js

@@ -27,7 +27,7 @@ export function localSubcommandHelp(command) {
         // BLI-3709: the Tower nouns live next door, split along the same seam the
         // argument parsers already use — see `local-help-commands-tower.ts`.
         ...TOWER_COMMAND_HELP,
-        ["setup", ["Usage: cockpit setup [--since <7d|30d|date>] [--details] [--person <email>] [--compare <email,email>] [--json]", "Read agent setups beside windowed outcomes (default 30 days), or compare two exact emails."]],
+        ["setup", ["Usage: cockpit setup [--since <7d|30d|date>] [--details] [--person <name|email>] [--compare <name,name>] [--json]", "Read agent setups beside windowed outcomes (default 30 days), or compare two people by first name or email."]],
         [
             "onboard",
             [

package/dist/commands/local-help.js

@@ -144,7 +144,7 @@ export function localCommandHelp(command) {
         "  cockpit rename [list|resolve <id> --scope <page|everywhere|undo>] [--dashboard-url <url>] [--json]",
         "  cockpit logs <collector|dashboard|railway|railway:<service>|-> [--since 15m|1h|2d|<iso>] [--raw <template-id> [--limit <n>]] [--all-levels] [--table <file>] [--json]",
         "  cockpit brain status [--project <id>] [--show open|running|needs_human|fixed|not_actionable|cleared] [--dashboard-url <url>] [--json]",
-        "  cockpit setup [--since <7d|30d|date>] [--details] [--person <email>] [--compare <email,email>] [--json]",
+        "  cockpit setup [--since <7d|30d|date>] [--details] [--person <name|email>] [--compare <name,name>] [--json]",
         "  cockpit usage sessions [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--since <window>] [--json]",
         "  cockpit usage sessions --session <id> [--from-window <n>] [--json]",
         "  --by-topic groups work types; --by-subject groups open subjects from session summaries.",

package/dist/commands/public-root.js

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

package/dist/commands/session-sync.js

@@ -41,6 +41,7 @@ import { readLocalWorkContextForRepo } from "../local-state.js";
 import os from "node:os";
 import { getCollectorRuntimePaths } from "../local-state.js";
 import { buildAgentSessionReport, buildAgentSessionSummary, } from "./agent-session-report.js";
+import { collectSessionCommits, withSessionCommits } from "../session-commits.js";
 import { planSyncFromLocalState } from "./session-sync-plan.js";
 import { scanAndAttributeBothSources } from "./session-sync-scan.js";
 import { syncEveryTargetWorktree } from "./session-sync-upload.js";
@@ -100,14 +101,19 @@ export async function runAttributedWorktreeSync(options) {
             ticketByWorktree.set(worktree.worktree_fingerprint, ticket);
     }
     console.error("[session-sync] bindings read", JSON.stringify({ bound_worktrees: ticketByWorktree.size, reason: "active_work_context" }));
-    const sessions = buildAgentSessionReport({
+    // BLI-13028: which commits each session's working tree created while it ran.
+    const commitsBySession = await collectSessionCommits([
+        ...scan.codexAttribution.results.map((result) => ({ key: `codex:${result.codex_session_id}`, result })),
+        ...scan.claudeAttribution.results.map((result) => ({ key: `claude_code:${result.claude_session_id}`, result })),
+    ]);
+    const sessions = withSessionCommits(buildAgentSessionReport({
         ticketByWorktree,
         codexResults: scan.codexAttribution.results,
         claudeResults: scan.claudeAttribution.results,
         outcomes: worktreePass.outcomes,
         now,
         claudePriorDurablePointers: worktreePass.claudePriorDurablePointers,
-    });
+    }), commitsBySession);
     // 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.

package/dist/commands/setup.js

@@ -24,12 +24,15 @@ export async function runSetup(command, io) {
             writeLine(io.stdout, "  No setup received.");
         for (const machine of person.machines) {
             if (!machine.setup) {
-                writeLine(io.stdout, "  Setup is unknown.");
+                writeLine(io.stdout, "  No readable setup from this machine yet.");
                 continue;
             }
             writeLine(io.stdout, `  ${machine.setup.os} · TOWER CLI ${machine.setup.cli_version}${machine.stale ? " · stale setup" : ""}`);
-            for (const tool of ["claude", "codex"])
-                writeLine(io.stdout, `  ${tool}: ${machine.setup[tool].model ?? "unknown model"}, ${machine.setup[tool].effort ?? "unknown effort"}`);
+            // The server words every model, effort and version (BLI-13055); an older server sends only the raw receipt.
+            for (const tool of ["claude", "codex"]) {
+                const words = machine.setup_labels?.[tool];
+                writeLine(io.stdout, words ? `  ${tool}: model ${words.model}, effort ${words.effort}, version ${words.version}` : `  ${tool}: model ${machine.setup[tool].model ?? "not reported by this machine yet"}, effort ${machine.setup[tool].effort ?? "default"}`);
+            }
         }
     }
     for (const pair of body.comparison ?? []) {

package/dist/commands/speed-seen.js

@@ -0,0 +1,119 @@
+/**
+ * `cockpit speed --seen [--since 24h] [--everyone]` (BLI-13054) — what real
+ * visits experienced on each Tower page, from the page-view beacons the browser
+ * sends (`apps/dashboard/src/lib/speed/first-useful.ts`).
+ *
+ * `cockpit speed` times a page's DATA DOOR from this terminal. It cannot see a
+ * page painted instantly from its last-known screen, or one that no longer
+ * waits to fetch after it loads. A visit's number is the moment real content
+ * first appeared, on that person's own network. Per page: visits, p50 and p95
+ * first-useful milliseconds, the share painted from the snapshot, and the
+ * median HTML and script transfer where the browser knew them.
+ *
+ * The door (`GET /api/speed/seen`) does the counting in the database, on the
+ * caller's own row policies: a person sees their own visits; `--everyone` needs
+ * a super_admin and is refused for anyone else. stdout is `--json`'s alone;
+ * every log line goes to stderr, metadata only (counts, a window, a reason).
+ */
+import { writeLine } from "./cli-io.js";
+import { loadPairedSession, towerFailureDetail, towerJsonRequest } from "../tower-client.js";
+export const SEEN_DEFAULT_SINCE = "24h";
+const SEEN_MAX_DAYS = 30;
+const UNIT_MS = { m: 60_000, h: 3_600_000, d: 86_400_000 };
+const REQUEST_DEADLINE_MS = 60_000;
+/** `90m`, `24h`, `7d`, at most 30 days (rows are pruned after that); null otherwise. */
+export function parseSeenWindow(text) {
+    const match = /^(\d{1,4})([mhd])$/.exec(text.trim().toLowerCase());
+    if (!match)
+        return null;
+    const ms = Number(match[1]) * UNIT_MS[match[2]];
+    return ms > 0 && ms <= SEEN_MAX_DAYS * UNIT_MS.d ? `${match[1]}${match[2]}` : null;
+}
+const ms = (value) => (value === null ? "-" : `${Math.round(value)} ms`);
+const percent = (share) => `${Math.round(share * 100)}%`;
+function size(bytes) {
+    if (bytes === null)
+        return "-";
+    if (bytes < 1024)
+        return `${bytes} B`;
+    return bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+/** Slowest median first, like `cockpit speed`; ties by page name. */
+export function rankSeen(pages) {
+    return [...pages].sort((a, b) => b.p50_ms - a.p50_ms || a.page.localeCompare(b.page));
+}
+/** The table a person reads. Already ranked: this lays out, it does not sort. */
+export function renderSeenTable(ranked, since, everyone) {
+    const head = ["#", "PAGE", "VISITS", "P50", "P95", "SNAPSHOT", "SNAP P50", "NET P50", "HTML", "JS"];
+    const rows = ranked.map((page, index) => [
+        String(index + 1),
+        page.page,
+        String(page.visits),
+        ms(page.p50_ms),
+        ms(page.p95_ms),
+        percent(page.snapshot_share),
+        ms(page.snapshot_p50_ms),
+        ms(page.network_p50_ms),
+        size(page.html_bytes_p50),
+        size(page.js_bytes_p50),
+    ]);
+    const widths = head.map((title, column) => Math.max(title.length, ...rows.map((row) => (row[column] ?? "").length)));
+    const line = (cells) => cells.map((cell, column) => (column === 1 ? cell.padEnd(widths[column] ?? 0) : cell.padStart(widths[column] ?? 0))).join("  ").trimEnd();
+    const who = everyone ? "everyone's visits" : "your visits";
+    if (ranked.length === 0) {
+        return [`No page views recorded in the last ${since} (${who}). Open Tower in a browser, then ask again.`];
+    }
+    return [
+        line(head),
+        ...rows.map(line),
+        "",
+        `${who}, last ${since}. Times are from the moment real content first showed (the last-known screen or the fresh one) `
+            + "to the press on the link (soft) or the start of the load (hard). P50/P95 are nearest-rank. SNAPSHOT is the share "
+            + "painted from the last-known screen. HTML and JS are median transfer sizes where the browser reported them (a cached copy reports none).",
+    ];
+}
+export async function runSpeedSeen(command, io) {
+    const log = (line) => writeLine(io.stderr, line);
+    const session = await loadPairedSession("speed", command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const since = command.since ?? SEEN_DEFAULT_SINCE;
+    const everyone = command.everyone === true;
+    const query = new URLSearchParams({ since });
+    if (everyone)
+        query.set("everyone", "1");
+    const answer = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/speed/seen?${query.toString()}`,
+        method: "GET",
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        label: "speed-seen",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log: (line) => {
+            if (!line.startsWith("[tower client] responded"))
+                log(line);
+        },
+    });
+    if (!answer.ok) {
+        const reason = towerFailureDetail(answer.reason, answer.detail);
+        log(`[speed cli] seen refused ${JSON.stringify({ since, everyone, reason: answer.reason, http_status: answer.httpStatus ?? null })}`);
+        if (command.json)
+            writeLine(io.stdout, JSON.stringify({ ok: false, reason: answer.reason, message: reason }));
+        else
+            writeLine(io.stderr, `cockpit speed --seen: ${reason}`);
+        return 1;
+    }
+    const body = (answer.body ?? {});
+    const wanted = command.pages;
+    const pages = rankSeen((body.pages ?? []).filter((page) => wanted.length === 0 || wanted.includes(page.page)));
+    const visits = pages.reduce((sum, page) => sum + page.visits, 0);
+    log(`[speed cli] seen read ${JSON.stringify({ since, everyone, pages: pages.length, visits })}`);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, since, everyone, dashboard_url: dashboardUrl, pages }));
+    }
+    else {
+        for (const line of renderSeenTable(pages, since, everyone))
+            writeLine(io.stdout, line);
+    }
+    return 0;
+}

package/dist/commands/speed.js

@@ -21,11 +21,15 @@
 import { resolveContainerTag } from "@bli-cockpit/memory-mcp/dist/container-tag.js";
 import { writeLine } from "./cli-io.js";
 import { classifyStatus, rankPages, renderSpeedTable, summarizeSamples, } from "./speed-math.js";
+import { runSpeedSeen } from "./speed-seen.js";
 import { speedPages } from "./speed-pages.js";
 import { loadPairedSession, towerFailureDetail, towerRequest } from "../tower-client.js";
 export const DEFAULT_SPEED_RUNS = 5;
 const REQUEST_DEADLINE_MS = 60_000;
 export async function runSpeed(command, io, deps = {}) {
+    // BLI-13054: `--seen` reads real visits (speed-seen.ts) instead of timing the data doors.
+    if (command.seen)
+        return runSpeedSeen(command, io);
     const now = deps.now ?? (() => performance.now());
     const log = (line) => writeLine(io.stderr, line);
     const session = await loadPairedSession("speed", command.homeDir);

package/dist/session-commits.js

@@ -0,0 +1,122 @@
+/**
+ * Which commits a session made (BLI-13028).
+ *
+ * The Setup page asks "did this session's work ship in a merged pull request?".
+ * A session's branch answers that for only a minority of sessions (most sit on
+ * `main`), but the commits a session made always can: git remembers, in the
+ * working tree's own reflog, every commit created there and when. So the
+ * collector reads that reflog once per working tree and hands each session the
+ * commits created between its first and last transcript timestamps.
+ *
+ * Why the reflog and not `git log`: the reflog is per working tree, so a
+ * session in one worktree is never credited with a commit another worktree made
+ * at the same moment (a log of the shared history would be). It also holds the
+ * new SHAs a rebase writes, which are the ones the pull request ends up with.
+ *
+ * Metadata only: full commit SHAs, never messages, authors or diffs. One git
+ * call per working tree per sync, not per session, because a first run
+ * revisits thousands of sessions and a Windows `git` start costs ~100 ms.
+ * `execFile` with an argument array runs the same on macOS and native Windows
+ * (no shell, no quoting).
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { describeError } from "./health-detail.js";
+const execFileAsync = promisify(execFile);
+/** Newest reflog entries read per working tree. A busy tree makes a few hundred a day. */
+const REFLOG_ENTRY_LIMIT = 20_000;
+/** A commit made just after the last transcript line still belongs to the session that asked for it. */
+export const SESSION_COMMIT_GRACE_MS = 120_000;
+/** Same cap the wire schema enforces. */
+export const SESSION_COMMIT_SHA_LIMIT = 100;
+/** Reflog subjects that mean "this working tree just created this commit". */
+const COMMIT_CREATING_SUBJECT = /^(commit\b|cherry-pick\b|revert\b|rebase(?: -i)? \((?:pick|reword|squash|fixup|continue|edit)\))/;
+const FULL_SHA = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+export const runGitForCommits = async (args, cwd) => {
+    const { stdout } = await execFileAsync("git", args, {
+        cwd,
+        timeout: 20_000,
+        maxBuffer: 16 * 1024 * 1024,
+        windowsHide: true,
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+    });
+    return stdout;
+};
+/** Every commit-creating reflog entry of one working tree, or the reason it could not be read. */
+export async function readCreatedCommits(repoRoot, git = runGitForCommits) {
+    let raw;
+    try {
+        raw = await git(["log", "-g", "--date=unix", `-n${REFLOG_ENTRY_LIMIT}`, "--format=%H%x1f%gd%x1f%gs", "HEAD"], repoRoot);
+    }
+    catch (error) {
+        console.error("[session-commits] reflog unreadable", JSON.stringify({ reason: "git_reflog_failed", ...describeError(error) }));
+        return { failure: "git_reflog_failed" };
+    }
+    return { commits: parseCreatedCommits(raw) };
+}
+export function parseCreatedCommits(raw) {
+    const commits = [];
+    for (const line of raw.split(/\r?\n/)) {
+        const [sha, selector, subject] = line.split("\x1f");
+        if (!sha || !FULL_SHA.test(sha) || !subject || !COMMIT_CREATING_SUBJECT.test(subject))
+            continue;
+        const at = Number(/@\{(\d+)\}$/.exec(selector ?? "")?.[1]);
+        if (Number.isFinite(at))
+            commits.push({ sha, at });
+    }
+    return commits;
+}
+/** The commits created in `[startMs, endMs + grace]`, newest first, capped. */
+export function commitsInSpan(commits, startMs, endMs) {
+    const seen = new Set();
+    for (const commit of commits) {
+        const atMs = commit.at * 1000;
+        if (atMs >= startMs && atMs <= endMs + SESSION_COMMIT_GRACE_MS)
+            seen.add(commit.sha);
+    }
+    return [...seen].slice(0, SESSION_COMMIT_SHA_LIMIT);
+}
+/**
+ * Commit SHAs per session, keyed `${source}:${session_id}`. A session with no
+ * working tree, or no transcript timestamps, gets no entry: "unknown", not
+ * "made no commits". A session whose tree was read and made none gets `[]`.
+ */
+export async function collectSessionCommits(results, git = runGitForCommits) {
+    const ledgers = new Map();
+    const bySession = new Map();
+    const counts = { sessions_with_commits: 0, sessions_without_commits: 0, sessions_unknown: 0, trees_read: 0, trees_failed: 0 };
+    for (const { key, result } of results) {
+        const start = Date.parse(result.session_facts?.first_timestamp ?? "");
+        const end = Date.parse(result.session_facts?.last_timestamp ?? "");
+        if (!result.worktree || !Number.isFinite(start) || !Number.isFinite(end)) {
+            counts.sessions_unknown += 1;
+            continue;
+        }
+        const root = result.worktree.repo_root;
+        if (!ledgers.has(root))
+            ledgers.set(root, readCreatedCommits(root, git));
+        const ledger = await ledgers.get(root);
+        if ("failure" in ledger) {
+            counts.sessions_unknown += 1;
+            continue;
+        }
+        const shas = commitsInSpan(ledger.commits, start, end);
+        bySession.set(key, [...new Set([...(bySession.get(key) ?? []), ...shas])].slice(0, SESSION_COMMIT_SHA_LIMIT));
+        counts[shas.length > 0 ? "sessions_with_commits" : "sessions_without_commits"] += 1;
+    }
+    for (const ledger of ledgers.values())
+        counts["failure" in (await ledger) ? "trees_failed" : "trees_read"] += 1;
+    console.error("[session-commits] commits recorded per session", JSON.stringify({ reason: "session_commits_collected", ...counts }));
+    return bySession;
+}
+/** The wire field, only when the collector actually looked. */
+export function commitShasField(shas) {
+    return shas ? { commit_shas: shas } : {};
+}
+/** Stamp each report row with the commits recorded for its session. */
+export function withSessionCommits(rows, commitsBySession) {
+    return rows.map((row) => ({
+        ...row,
+        ...commitShasField(commitsBySession.get(`${row.source}:${row.codex_session_id}`)),
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.194",
+  "version": "0.2.195",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,9 +27,9 @@
     "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-surface-doors.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-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.57",
-    "@bli-cockpit/mcp": "0.1.106",
-    "@bli-cockpit/telemetry-core": "0.1.66"
+    "@bli-cockpit/memory-mcp": "0.1.58",
+    "@bli-cockpit/mcp": "0.1.107",
+    "@bli-cockpit/telemetry-core": "0.1.67"
   },
   "repository": {
     "type": "git",