@bli-cockpit/cli 0.2.192 → 0.2.194

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

@@ -15,40 +15,29 @@
  */
 import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs, } from "./local-arg-values.js";
 /**
- * Every corpus. Kept here so an unknown kind is refused BEFORE a round trip,
- * and mirrors `SEARCH_KINDS` in the dashboard — nothing in the type system ties
- * the two lists together.
+ * What `--kind` names is the SERVER's to say (BLI-13027). This used to be a copy
+ * of the dashboard's kind list that refused anything it did not hold, so an
+ * installed CLI told a person that Scout did not exist the day Scout shipped.
+ * Now the CLI forwards the words, and the door answers `unknown_kind` with the
+ * list this account is offered. `cockpit search --categories` prints that list.
  */
-export const SEARCH_KINDS = [
-    "doc",
-    "msg",
-    "issue",
-    "note",
-    "mail",
-    "cal",
-    "memory",
-];
 export function parseSearchArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--dashboard-url", "--kind", "--limit", "--json"],
+        allowedFlags: ["--home", "--dashboard-url", "--kind", "--limit", "--json", "--categories"],
         valueFlags: ["--home", "--dashboard-url", "--kind", "--limit"],
     });
     const query = values.positionals.join(" ").trim();
-    if (query.length === 0) {
+    const categories = values.booleans.has("--categories");
+    if (query.length === 0 && !categories) {
         throw new Error('search needs something to search for, e.g. `cockpit search "storage ceiling"`.');
     }
     const kindFlag = optionalNonEmpty(values.flags.get("--kind"));
     let kinds;
     if (kindFlag) {
         kinds = [];
-        // BLI-12947: `ticket` is the new spelling of the `issue` kind (input only).
-        for (const raw of kindFlag.split(",").map((entry) => entry.trim()).filter(Boolean)) {
-            const part = raw === "ticket" ? "issue" : raw;
-            if (!SEARCH_KINDS.includes(part)) {
-                throw new Error(`search --kind must be one or more of ${SEARCH_KINDS.join(", ")} — not "${raw}".`);
-            }
-            if (!kinds.includes(part))
-                kinds.push(part);
+        for (const raw of kindFlag.split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean)) {
+            if (!kinds.includes(raw))
+                kinds.push(raw);
         }
         if (kinds.length === 0)
             kinds = undefined;
@@ -56,6 +45,7 @@ export function parseSearchArgs(args) {
     return {
         kind: "search",
         query,
+        ...(categories ? { categories: true } : {}),
         ...(kinds ? { kinds } : {}),
         limit: optionalPositiveInteger(values.flags.get("--limit"), "--limit"),
         homeDir: optionalNonEmpty(values.flags.get("--home")),

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

@@ -0,0 +1,31 @@
+import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs } from "./local-arg-values.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). */
+export function parseSpeedArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--page", "--runs", "--json", "--home", "--dashboard-url"],
+        valueFlags: ["--page", "--runs", "--home", "--dashboard-url"],
+    });
+    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}.`);
+    }
+    return {
+        kind: "speed",
+        pages: [...new Set(pages)],
+        runs,
+        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

@@ -33,11 +33,12 @@ export { SCOUT_MIN_PREFIX_LENGTH, parseScoutArgs, parseOpsArgs, SLACK_WORKSPACE_
 export { parseDocsArgs, parseMsgArgs, } from "./local-args-tower-docs-msg.js";
 export { ISSUE_STATES, parseIssueArgs, parseProjectArgs, } from "./local-args-tower-work.js";
 export { parseGithubArgs } from "./local-args-tower-github.js";
-export { SEARCH_KINDS, parseSearchArgs } from "./local-args-tower-search.js";
+export { parseSearchArgs } from "./local-args-tower-search.js";
 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

@@ -11,15 +11,6 @@
  * Every string moved verbatim. Help output is what an intern pastes back when
  * something breaks, so it is a user-visible contract like any other.
  */
-import { SEARCH_KINDS } from "./local-args-tower-search.js";
-/**
- * The corpora `cockpit search` can name, spelled the way `--kind` takes them.
- * Read off `SEARCH_KINDS` rather than typed out: the help string said five for
- * the two months `mail` and `cal` were searchable, so a person was told the
- * door was narrower than it is (BLI-4048).
- */
-const SEARCH_KIND_LIST = SEARCH_KINDS.join(",");
-const SEARCH_CORPORA_COUNT = SEARCH_KINDS.length;
 /** One entry per Tower noun, in the order `cockpit --help` lists them. */
 export const TOWER_COMMAND_HELP = [
     [
@@ -184,6 +175,24 @@ 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]",
+            "",
+            "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.",
+        ],
+    ],
     [
         "usage",
         [
@@ -207,10 +216,11 @@ export const TOWER_COMMAND_HELP = [
     [
         "search",
         [
-            `Usage: cockpit search "<words>" [--kind ${SEARCH_KIND_LIST}] [--limit <n>] [--json]`,
+            'Usage: cockpit search "<words>" [--kind <category,...>] [--limit <n>] [--json]',
+            "       cockpit search --categories [--json]",
             "",
-            `One bar over ${SEARCH_CORPORA_COUNT} corpora: documents, messages, issues, meeting notes, mail, calendar`,
-            "events and memory.",
+            "One bar over every corpus Tower holds: tickets, documents, meeting notes, messages, mail,",
+            "calendar events, memory, Scout and (where you may read it) Careers.",
             "It presses the SAME door the browser's search bar presses (GET /api/search), so what you",
             "read here is the same row, the same ranking and the same snippet a person sees in Tower.",
             "",
@@ -219,14 +229,16 @@ export const TOWER_COMMAND_HELP = [
             "Quoted phrases and -word work inside the query itself — the query goes to Postgres's",
             "websearch parser, which shrugs at anything a person can type instead of raising.",
             "",
-            `--kind narrows to one or more corpora, comma separated: ${SEARCH_KIND_LIST}.`,
-            `Omit it and all ${SEARCH_CORPORA_COUNT} are searched.`,
+            "--kind narrows to one or more categories, comma separated (ticket works for issue).",
+            "--categories prints the list Tower offers THIS account, in the order the browser's Command-K",
+            "chips use, so the names are never a guess; an unknown --kind is refused by the door with that list.",
+            "Omit --kind and every category is searched.",
             "--limit caps the number of results (default 20, maximum 50).",
             "--json writes the door's whole answer to stdout, hits, per-kind counts, failures and all.",
             "",
-            `Every result is scoped by what YOU may read: ${SEARCH_CORPORA_COUNT - 1} of the ${SEARCH_CORPORA_COUNT} corpora are`,
-            "searched on your own database session, so a document or a channel you cannot open is not in",
-            "the list; memory runs on the service role behind the memory doors' own gate.",
+            "Every result is scoped by what YOU may read: most corpora (and Careers always) are searched on",
+            "your own database session, so a document, a channel or an applicant you cannot open is not in",
+            "the list; memory and Scout run on the service role behind their own gates.",
             "",
             "A corpus that could not ANSWER gets its own line, separately from \"nothing matched\" —",
             "those are different facts and folding them together would let a broken search read as silence.",

package/dist/commands/local-help.js

@@ -8,7 +8,6 @@
  * user-visible contract like any other.
  */
 import { DEFAULT_DASHBOARD_URL } from "../local-state.js";
-import { SEARCH_KINDS } from "./local-args-tower-search.js";
 import { localSubcommandHelp } from "./local-help-commands.js";
 /**
  * The Tower PAGE names a person reads in the rail, each routed to the CLI noun
@@ -84,6 +83,7 @@ export const rootCommandNames = new Set([
     "rename",
     "setup",
     "usage",
+    "speed",
     "logs",
     "brain",
     ...SURFACE_ALIASES.keys(),
@@ -136,7 +136,8 @@ export function localCommandHelp(command) {
         "  cockpit cal [today|week|next|find \"<words>\"|calendars|add-ical|create --calendar <id> --title <t> --at <iso> --until <iso>|share <id> --org-visible|--private|sync <id> [--full]|detach <id>] [--tz <zone>] [--offset <n>] [--hours <n>] [--from <d> --to <d>] [--calendar <id>] [--limit <n>] [--all] [--dashboard-url <url>] [--json]",
         "  cockpit project [list] [--archived] [--dashboard-url <url>] [--json]",
         "  cockpit github <pr|merge|retitle|rerun> <owner/repo> <n> [--claim <state>] [--method squash|merge|rebase] [--title \"<text>\"] [--run <id>] [--confirm <code>] [--dashboard-url <url>] [--json]",
-        `  cockpit search "<words>" [--kind ${SEARCH_KINDS.join(",")}] [--limit <n>] [--dashboard-url <url>] [--json]`,
+        `  cockpit search "<words>" [--kind <category,...>] [--limit <n>] [--dashboard-url <url>] [--json]`,
+        "  cockpit search --categories [--dashboard-url <url>] [--json]",
         "  cockpit release [--dry-run] [--skip-checks] [--no-floor] [--tag <tag>] [--access <public|restricted>] [--otp <code>]",
         "  cockpit careers [list|show <id>|rescreen <id>|send-takehome <id>|decide <id> --decision <passed_on|archived|reopen>|followup <id> [--record-sent-at <iso>]|interview <id> <--at <iso>|--clear>|grade <id> [--now]|resume <id> [--out <path>]|takehome show <role>|takehome set <role> --body-file <path>|settings show|settings set --enabled <true|false> --followup-enabled <true|false> --followup-after-days <n> --takehome-window-hours <n>] [--role <slug>] [--min-score <n>] [--since <date>] [--stage <s>] [--force] [--json]",
         "  cockpit glossary list|add <wrong> --to <name>|remove <wrong> [--dashboard-url <url>] [--json]",
@@ -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.192");
+    writeLine(io?.stdout ?? process.stdout, "0.2.194");
     return 0;
   }
 

package/dist/commands/search.js

@@ -1,5 +1,5 @@
 /**
- * `cockpit search` — one bar over five corpora, in a terminal (BLI-3728).
+ * `cockpit search` — one bar over every corpus, in a terminal (BLI-3728).
  *
  * The SAME door the browser's search bar presses: `GET /api/search`, opted
  * into the collector device token in `route-caller-census.test.ts`. So a
@@ -42,10 +42,15 @@ const KIND_LABELS = {
     mail: "MAIL",
     cal: "CALENDAR",
     memory: "MEMORY",
+    scout: "SCOUT",
+    careers: "CAREERS",
 };
-const KIND_ORDER = ["doc", "msg", "issue", "note", "mail", "cal", "memory"];
+const KIND_ORDER = ["doc", "msg", "issue", "note", "mail", "cal", "memory", "scout", "careers"];
 export async function runSearch(command, io) {
     const door = await openAgentDoor("search", command, io);
+    // BLI-13027: the list the browser's Command-K chips are drawn from.
+    if (command.categories)
+        return await runCategories(door);
     const params = new URLSearchParams({ q: command.query });
     if (command.kinds && command.kinds.length > 0)
         params.set("kinds", command.kinds.join(","));
@@ -64,6 +69,28 @@ export async function runSearch(command, io) {
         return emitAgentDoor(door, body);
     return render(door, body);
 }
+async function runCategories(door) {
+    const answer = await askAgentDoor(door, {
+        path: "/api/search?categories=1",
+        method: "GET",
+        label: "search categories",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    if (door.json)
+        return emitAgentDoor(door, body);
+    const categories = body.categories ?? [];
+    writeLine(door.io.stdout, `${body.everything?.label ?? "Everything"} (searched when --kind is left out)`);
+    for (const entry of categories) {
+        const aliases = (entry.aliases ?? []).length > 0 ? `  (also: ${(entry.aliases ?? []).join(", ")})` : "";
+        writeLine(door.io.stdout, `  ${entry.kind}  ${entry.label}${aliases}`);
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${categories.length} categories. Name them with --kind, comma separated.`);
+    return 0;
+}
 function render(door, body) {
     const hits = body.hits ?? [];
     const failures = body.failures ?? {};
@@ -76,7 +103,10 @@ function render(door, body) {
             writeLine(door.io.stdout, "Nothing matched in the corpora that answered.");
         }
     }
-    for (const kind of KIND_ORDER) {
+    // Known kinds in the usual order, then any kind this CLI has never heard of
+    // (a newer door than this build): printed, not swallowed.
+    const unknownKinds = [...new Set(hits.map((hit) => hit.kind))].filter((kind) => !KIND_ORDER.includes(kind));
+    for (const kind of [...KIND_ORDER, ...unknownKinds]) {
         const group = hits.filter((hit) => hit.kind === kind);
         if (group.length === 0)
             continue;

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.js

@@ -0,0 +1,130 @@
+/**
+ * `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 { 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 = {}) {
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.192",
+  "version": "0.2.194",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.57",
-    "@bli-cockpit/mcp": "0.1.104",
+    "@bli-cockpit/mcp": "0.1.106",
     "@bli-cockpit/telemetry-core": "0.1.66"
   },
   "repository": {