@bli-cockpit/cli 0.2.193 → 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

@@ -0,0 +1,52 @@
+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), 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", "--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(", ") + ".");
+    }
+    const pages = (values.flagValues.get("--page") ?? []).map((name) => name.trim().toLowerCase());
+    const unknown = pages.filter((name) => !SPEED_PAGE_NAMES.includes(name));
+    if (unknown.length) {
+        throw new Error(`Unknown speed page: ${unknown.join(", ")}. Pages: ${SPEED_PAGE_NAMES.join(", ")}.`);
+    }
+    const runs = optionalPositiveInteger(values.flags.get("--runs"), "--runs");
+    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-args-tower.js

@@ -38,6 +38,7 @@ export { parseModelsArgs } from "./local-args-tower-models.js";
 export { parseMailArgs } from "./local-args-tower-mail.js";
 export { parseCalArgs } from "./local-args-tower-cal.js";
 export { parseSetupArgs } from "./local-args-tower-setup.js";
+export { parseSpeedArgs } from "./local-args-tower-speed.js";
 export { parseUsageArgs } from "./local-args-tower-usage.js";
 export { parseLogsArgs } from "./local-args-tower-logs.js";
 export { parseBrainArgs } from "./local-args-tower-brain.js";

package/dist/commands/local-args.js

@@ -19,7 +19,7 @@ import { parseGlossaryArgs } from "./glossary.js";
 import { parseRootsArgs } from "./roots.js";
 import { SURFACE_ALIASES } from "./local-help.js";
 import { parseAgentRulesArgs, parseAnalyzeArgs, parseAutostartArgs, parseBackfillArgs, parseCleanArgs, parseDoctorArgs, parseInstallArgs, parseLoginArgs, parseMemoryArgs, parseLogoutArgs, parseOnboardArgs, parseReleaseArgs, parseServeArgs, parseSessionsArgs, parseSourcesArgs, parseStartArgs, parseStatusArgs, parseSyncArgs, parseUpdateArgs, } from "./local-args-collector.js";
-import { parseBriefArgs, parseCorrectArgs, parseDocsArgs, parseIssueArgs, parseJarvisArgs, parseMailArgs, parseCalArgs, parseModelArgs, parseMsgArgs, parseNotesArgs, parseOpsArgs, parseProjectArgs, parseModelsArgs, parseScoutArgs, parseGithubArgs, parseSearchArgs, parseSettingsArgs, parseSlackArgs, parseTeamArgs, parseWorkbookArgs, parseUsageArgs, parseSetupArgs, parseLogsArgs, parseBrainArgs, parseCareersArgs, parseRenameArgs, } from "./local-args-tower.js";
+import { parseBriefArgs, parseCorrectArgs, parseDocsArgs, parseIssueArgs, parseJarvisArgs, parseMailArgs, parseCalArgs, parseModelArgs, parseMsgArgs, parseNotesArgs, parseOpsArgs, parseProjectArgs, parseModelsArgs, parseScoutArgs, parseGithubArgs, parseSearchArgs, parseSettingsArgs, parseSlackArgs, parseTeamArgs, parseWorkbookArgs, parseUsageArgs, parseSetupArgs, parseSpeedArgs, parseLogsArgs, parseBrainArgs, parseCareersArgs, parseRenameArgs, } from "./local-args-tower.js";
 // `normalizeUrl` has always been part of this module's surface — `local.ts` and
 // `local-auth.ts` import it from here — so it stays exported from this address
 // even though it now lives next door. The same goes for the four names the
@@ -138,6 +138,8 @@ export function parseLocalArgs(argv) {
             return parseSetupArgs(argv.slice(1));
         case "usage":
             return parseUsageArgs(argv.slice(1));
+        case "speed":
+            return parseSpeedArgs(argv.slice(1));
         case "logs":
             return parseLogsArgs(argv.slice(1));
         case "brain":

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

@@ -175,6 +175,31 @@ export const TOWER_COMMAND_HELP = [
             "--json writes one machine-readable object to stdout; every reason and receipt line stays on stderr.",
         ],
     ],
+    [
+        "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",
+            "(nearest rank). Also the HTTP status, the response size and the door's own Server-Timing total.",
+            "Slowest first. A page your account may not open (Careers for a member) reads \"not permitted\", not as a failure.",
+            "--page <name> limits the run to one page; repeat it for several. Names: today, meeting-notes, careers, scout,",
+            "messages, mail, docs, memory, tickets, setup, usage, calendar, workbook, settings.",
+            "--runs <n> sets the requests per page (default 5, at most 50).",
+            "--json writes one object to stdout ({ ok, runs, pages: [...] }); every log line stays on stderr.",
+            "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.",
+        ],
+    ],
     [
         "usage",
         [

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

@@ -83,6 +83,7 @@ export const rootCommandNames = new Set([
     "rename",
     "setup",
     "usage",
+    "speed",
     "logs",
     "brain",
     ...SURFACE_ALIASES.keys(),
@@ -143,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.",
@@ -153,6 +154,7 @@ export function localCommandHelp(command) {
         "  cockpit calendar [same verbs and flags as cockpit cal]",
         "  cockpit messages [same verbs and flags as cockpit msg]",
         "  cockpit meeting-notes [same verbs and flags as cockpit notes]",
+        "  cockpit speed [--page <name>]... [--runs <n>] [--dashboard-url <url>] [--json]",
         "  cockpit usage people [--by-repo | --by-topic | --by-subject | --by-task] [--min-confidence high|medium|low] [--person <email|me>] [--all] [--detail] [--since <n>d|<n>h|<iso>] [--until <iso>] [--include-automated] [--dashboard-url <url>] [--json]",
         "",
         `Default dashboard: ${DEFAULT_DASHBOARD_URL}. Omit --dashboard-url for normal production use; pass it only for staging/custom dashboards or to force a different pairing.`,

package/dist/commands/local.js

@@ -52,6 +52,7 @@ import { runCareers } from "./careers.js";
 import { runRename } from "./rename-scope.js";
 import { runSetup } from "./setup.js";
 import { runUsage } from "./usage.js";
+import { runSpeed } from "./speed.js";
 import { runLogs } from "./logs.js";
 import { runBrain } from "./brain.js";
 import { parseLocalArgs } from "./local-args.js";
@@ -249,6 +250,7 @@ export async function runLocalCockpitCli(argv, io = { ...defaultIo(), runDoctorA
                 return await runRename(command, io);
             case "setup": return await runSetup(command, io);
             case "usage": return await runUsage(command, io);
+            case "speed": return await runSpeed(command, io);
             case "logs": return await runLogs(command, io);
             case "brain": return await runBrain(command, io);
         }

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.193");
+    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-math.js

@@ -0,0 +1,135 @@
+/**
+ * The arithmetic and the layout behind `cockpit speed` (BLI-13033). Pure: no
+ * clock, no network, so the timing math, the ranking and the "not permitted"
+ * rule are all tested with plain numbers.
+ */
+/** 401 is a bad token (a failure to fix); 403 is a page this caller may not open. */
+export function classifyStatus(status) {
+    if (status === 403)
+        return "not_permitted";
+    if (status !== null && status >= 200 && status < 300)
+        return "ok";
+    return "failed";
+}
+/** Nearest-rank percentile over unsorted values. 0 < p <= 100. Null on no values. */
+export function percentile(values, p) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const rank = Math.max(1, Math.ceil((p / 100) * sorted.length));
+    return sorted[Math.min(rank, sorted.length) - 1] ?? null;
+}
+/** `total;dur=123.4` out of a Server-Timing header. */
+export function serverTotalMs(header) {
+    if (!header)
+        return null;
+    for (const part of header.split(",")) {
+        const [name, ...params] = part.trim().split(";");
+        if (name?.trim() !== "total")
+            continue;
+        for (const param of params) {
+            const [key, value] = param.trim().split("=");
+            if (key === "dur" && value !== undefined && Number.isFinite(Number(value)))
+                return Number(value);
+        }
+    }
+    return null;
+}
+const round1 = (value) => (value === null ? null : Math.round(value * 10) / 10);
+export function summarizeSamples(page, samples) {
+    const base = { page: page.name, label: page.label, door: page.path, ...(page.note ? { note: page.note } : {}) };
+    const last = samples[samples.length - 1];
+    const good = samples.filter((sample) => classifyStatus(sample.status) === "ok");
+    const denied = samples.find((sample) => classifyStatus(sample.status) === "not_permitted");
+    if (good.length === 0) {
+        const first = samples[0];
+        const outcome = denied ? "not_permitted" : "failed";
+        return {
+            ...base,
+            outcome,
+            cold_ms: null,
+            p50_ms: null,
+            p95_ms: null,
+            runs: samples.length,
+            failed_runs: denied ? 0 : samples.length,
+            http_status: (denied ?? first)?.status ?? null,
+            bytes: null,
+            server_timing: null,
+            server_total_ms: null,
+            reason: denied
+                ? "not permitted for this account"
+                : (first?.failure ?? (first?.status === null || first === undefined ? "no_response" : `http_${first.status}`)),
+        };
+    }
+    const cold = samples[0] && classifyStatus(samples[0].status) === "ok" ? samples[0] : null;
+    const warm = good.filter((sample) => sample !== cold);
+    const timed = (warm.length > 0 ? warm : good).map((sample) => sample.ms);
+    const lastGood = good[good.length - 1] ?? last;
+    return {
+        ...base,
+        outcome: "ok",
+        cold_ms: round1(cold ? cold.ms : null),
+        p50_ms: round1(percentile(timed, 50)),
+        p95_ms: round1(percentile(timed, 95)),
+        runs: samples.length,
+        failed_runs: samples.length - good.length,
+        http_status: lastGood?.status ?? null,
+        bytes: lastGood?.bytes ?? null,
+        server_timing: lastGood?.serverTiming ?? null,
+        server_total_ms: serverTotalMs(lastGood?.serverTiming ?? null),
+    };
+}
+/**
+ * Slowest first by median. Pages that answered come first, then pages that
+ * failed (a failure is something to fix, so it sits above the pages that were
+ * simply not open to this account), then pages not permitted.
+ */
+export function rankPages(pages) {
+    const tier = (page) => (page.outcome === "ok" ? 0 : page.outcome === "failed" ? 1 : 2);
+    return [...pages].sort((a, b) => {
+        if (tier(a) !== tier(b))
+            return tier(a) - tier(b);
+        return (b.p50_ms ?? 0) - (a.p50_ms ?? 0) || a.page.localeCompare(b.page);
+    });
+}
+function pad(value, width, right = false) {
+    return right ? value.padStart(width) : value.padEnd(width);
+}
+function ms(value) {
+    return value === null ? "-" : `${Math.round(value)} ms`;
+}
+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`;
+}
+/** The ranked table a person reads. Already ranked: this lays out, it does not sort. */
+export function renderSpeedTable(ranked, runs) {
+    const rows = ranked.map((page, index) => {
+        if (page.outcome === "ok") {
+            return [
+                String(index + 1),
+                page.page,
+                ms(page.cold_ms),
+                ms(page.p50_ms),
+                ms(page.p95_ms),
+                String(page.http_status ?? "-"),
+                size(page.bytes),
+                page.server_total_ms === null ? "-" : ms(page.server_total_ms),
+            ];
+        }
+        const word = page.outcome === "not_permitted" ? "not permitted" : `FAILED (${page.reason ?? "unknown"})`;
+        return [String(index + 1), page.page, word, "", "", String(page.http_status ?? "-"), "-", "-"];
+    });
+    const head = ["#", "PAGE", "COLD", "P50", "P95", "HTTP", "BYTES", "SERVER"];
+    const widths = head.map((title, column) => Math.max(title.length, ...rows.map((row) => (row[column] ?? "").length)));
+    const line = (cells) => cells.map((cell, column) => pad(cell, widths[column] ?? 0, column >= 2 && column !== 5)).join("  ").trimEnd();
+    return [
+        line(head),
+        ...rows.map(line),
+        "",
+        `${runs} run${runs === 1 ? "" : "s"} per page: the first is cold, p50 and p95 are over the warm runs${runs === 1 ? " (only the cold run was made)" : ""}. SERVER is the door's own Server-Timing total.`,
+    ];
+}

package/dist/commands/speed-pages.js

@@ -0,0 +1,38 @@
+/**
+ * Which door each rail page opens on (BLI-13033).
+ *
+ * `cockpit speed` times the DATA DOOR of every rail page: the API read the
+ * page's first useful content comes from, or (where the page reads the
+ * database straight from the server) the nearest door that reads the same
+ * rows. It does not time the page's HTML, hydration or paint, so a number here
+ * is the floor of what a person waits, never more than that.
+ *
+ * Order is the rail's order (`ck-rail.tsx` `NAV_ITEMS`). The MCP twin
+ * (`packages/bli-cockpit-mcp/src/speed-tools.ts`) carries its own copy, and a
+ * test in that package fails when the two lists drift.
+ */
+/** The pages in rail order. `memoryContainer` is the tag `cockpit memory profile` would use here. */
+export function speedPages(memoryContainer) {
+    return [
+        { name: "today", label: "Today (JARVIS home)", path: "/api/jarvis/brief" },
+        { name: "meeting-notes", label: "Meeting notes", path: "/api/notes/library" },
+        { name: "careers", label: "Careers", path: "/api/careers/applications" },
+        { name: "scout", label: "Scout", path: "/api/cockpit/scout" },
+        { name: "messages", label: "Messages", path: "/api/msg/channels" },
+        { name: "mail", label: "Mail", path: "/api/mail/inbox" },
+        { name: "docs", label: "Docs", path: "/api/docs/tree" },
+        {
+            name: "memory",
+            label: "Memory",
+            path: `/api/memory/profile?container=${encodeURIComponent(memoryContainer)}`,
+            note: "the page reads agent_memories on the server; the profile door is the nearest read",
+        },
+        { name: "tickets", label: "Tickets", path: "/api/work/issues" },
+        { name: "setup", label: "Setup", path: "/api/setup" },
+        { name: "usage", label: "Usage", path: "/api/usage/people?since=30d" },
+        { name: "calendar", label: "Calendar", path: "/api/cal/week" },
+        { name: "workbook", label: "Workbook", path: "/api/cockpit/workbook" },
+        { name: "settings", label: "Settings", path: "/api/settings/personal" },
+    ];
+}
+export const SPEED_PAGE_NAMES = speedPages("x").map((page) => page.name);

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

@@ -0,0 +1,134 @@
+/**
+ * `cockpit speed` (BLI-13033) — how long each Tower rail page's data door takes,
+ * measured from this terminal with this machine's own device token.
+ *
+ * For every page: one request per run, the first reported as cold and the rest
+ * as warm, then p50, p95, the HTTP status, the response size and the door's
+ * own `Server-Timing` header. A page this account may not open (Careers for a
+ * member) reads "not permitted", which is an answer, not a failure.
+ *
+ * What a number is: wall-clock from sending the request to the last byte of the
+ * body, on THIS machine, so it includes the network between here and Tower. It
+ * is the data door, not the page's HTML or paint (`speed-pages.ts` says which
+ * door stands for which page). Reads only, and never the local read cache or
+ * the warm-connection route: a speed number that a cache answered would be a
+ * lie about Tower.
+ *
+ * stdout is `--json`'s alone; every log line goes to stderr, metadata only (a
+ * page name, a status, a millisecond count). The device token is attached by
+ * the shared Tower client and never printed.
+ */
+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);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const runs = command.runs ?? DEFAULT_SPEED_RUNS;
+    const everyPage = speedPages(resolveContainerTag({ cwd: process.cwd() }).containerTag);
+    const chosen = command.pages.length > 0
+        ? everyPage.filter((page) => command.pages.includes(page.name))
+        : everyPage;
+    const results = [];
+    for (const page of chosen) {
+        const samples = [];
+        for (let run = 0; run < runs; run += 1) {
+            const sample = await timeOneRead(page, { dashboardUrl, deviceToken: session.device_token, io, now, log });
+            samples.push(sample);
+            // A page this account may not open answers the same way every time.
+            if (classifyStatus(sample.status) === "not_permitted")
+                break;
+        }
+        const summary = summarizeSamples(page, samples);
+        results.push(summary);
+        log(`[speed cli] page measured ${JSON.stringify({
+            page: summary.page,
+            outcome: summary.outcome,
+            http_status: summary.http_status,
+            runs: samples.length,
+            failed_runs: summary.failed_runs,
+            p50_ms: summary.p50_ms,
+            ...(summary.reason ? { reason: summary.reason } : {}),
+        })}`);
+    }
+    const ranked = rankPages(results);
+    const failed = ranked.filter((page) => page.outcome === "failed").length;
+    const notPermitted = ranked.filter((page) => page.outcome === "not_permitted").length;
+    log(`[speed cli] done ${JSON.stringify({
+        pages: ranked.length,
+        measured: ranked.length - failed - notPermitted,
+        failed,
+        not_permitted: notPermitted,
+        runs,
+    })}`);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: failed === 0,
+            measured_at: new Date().toISOString(),
+            dashboard_url: dashboardUrl,
+            runs,
+            pages: ranked,
+        }));
+    }
+    else {
+        for (const line of renderSpeedTable(ranked, runs))
+            writeLine(io.stdout, line);
+    }
+    return failed === 0 ? 0 : 1;
+}
+async function timeOneRead(page, context) {
+    const startedAt = context.now();
+    const answer = await towerRequest({
+        dashboardUrl: context.dashboardUrl,
+        path: page.path,
+        method: "GET",
+        deviceToken: context.deviceToken,
+        fetch: context.io.fetch,
+        label: `speed-${page.name}`,
+        timeoutMs: REQUEST_DEADLINE_MS,
+        // The client's per-request success trace would print 70 lines here; the
+        // failure lines stay.
+        log: (line) => {
+            if (!line.startsWith("[tower client] responded"))
+                context.log(line);
+        },
+    });
+    if (!answer.ok) {
+        return {
+            status: null,
+            ms: context.now() - startedAt,
+            bytes: 0,
+            serverTiming: null,
+            failure: `${answer.reason}: ${towerFailureDetail(answer.reason, answer.detail)}`.slice(0, 120),
+        };
+    }
+    let bytes = 0;
+    try {
+        bytes = (await answer.response.arrayBuffer()).byteLength;
+    }
+    catch {
+        return {
+            status: answer.response.status,
+            ms: context.now() - startedAt,
+            bytes: 0,
+            serverTiming: null,
+            failure: "body_read_failed",
+        };
+    }
+    return {
+        status: answer.response.status,
+        ms: context.now() - startedAt,
+        bytes,
+        serverTiming: answer.response.headers.get("server-timing"),
+    };
+}

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.193",
+  "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.105",
-    "@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",