@bli-cockpit/cli 0.2.74 → 0.2.76

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

@@ -66,6 +66,8 @@ export function parseOpsArgs(args) {
             "--skips",
             "--memory",
             "--memory-days",
+            // BLI-3798: the coverage half on its own, with the bucket table.
+            "--coverage",
             "--person",
             "--dry-run",
             "--json",
@@ -91,10 +93,19 @@ export function parseOpsArgs(args) {
         if (memoryDays !== undefined && !/^[0-9]{1,2}$/u.test(memoryDays)) {
             throw new Error("ops --memory-days takes a whole number of days, 1 to 30.");
         }
+        const coverageOnly = values.booleans.has("--coverage");
+        const job = optionalNonEmpty(values.flags.get("--job"));
+        if (coverageOnly && job !== undefined && job !== "collection-coverage") {
+            // Refused rather than silently preferring one: `--coverage --job
+            // daily-brief` is somebody asking two different questions in one
+            // command, and answering the wrong one is how a board loses trust.
+            throw new Error("ops --coverage IS --job collection-coverage. Pass one or the other, not a --job naming a different pipeline.");
+        }
         return {
             kind: "ops",
             action: "status",
-            job: optionalNonEmpty(values.flags.get("--job")),
+            job: coverageOnly ? "collection-coverage" : job,
+            coverage: coverageOnly,
             skips: values.booleans.has("--skips"),
             memory: values.booleans.has("--memory") || memoryDays !== undefined,
             ...(memoryDays === undefined ? {} : { memoryDays: Number(memoryDays) }),

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

@@ -295,7 +295,7 @@ export function localSubcommandHelp(command) {
         [
             "ops",
             [
-                "Usage: cockpit ops [status [--job <id>] [--skips] [--memory [--memory-days N]] | recompile --person <email|name|id> [--dry-run]] [--json]",
+                "Usage: cockpit ops [status [--job <id>] [--coverage] [--skips] [--memory [--memory-days N]] | recompile --person <email|name|id> [--dry-run]] [--json]",
                 "",
                 "  cockpit ops status",
                 "      One line per scheduled job: when it last produced something, and whether that",
@@ -306,6 +306,11 @@ export function localSubcommandHelp(command) {
                 "      week rather than a broken cron.",
                 "      --job <id> asks about one; --skips adds the open Slack and external-sync skips,",
                 "      grouped by reason. Exits 1 if anything is stale, empty or unreadable.",
+                "      --coverage is the collection-coverage row on its own, with the BUCKET table:",
+                "      which bucket the missing sessions are in (staged-not-committed with the upload",
+                "      ledger's own reason, still pending upload, deliberately withheld, or no row at",
+                "      all), whose machines they are on, which of their own days, and what to run for",
+                "      each. That table also prints on the ordinary board whenever anything is missing.",
                 "      Every machine's line also carries its BLI Memory column — whether the MCP",
                 "      servers and the recall/save hooks are registered for Claude Code and Codex,",
                 "      and whether Codex has been told to TRUST its hooks. That column never colours",

package/dist/commands/msg.js

@@ -61,7 +61,8 @@ async function listChannels(door) {
     }
     for (const channel of fetched.channels) {
         const label = channel.is_dm ? "dm" : channel.is_private ? "private" : "public";
-        writeLine(door.io.stdout, `${channel.id}  ${label.padEnd(7)}  ${channel.name ?? "(unnamed)"}`);
+        const workspace = channel.is_dm ? "-" : (channel.slack_workspace ?? "bli");
+        writeLine(door.io.stdout, `${channel.id}  ${label.padEnd(7)}  ${workspace.padEnd(10)}  ${channel.name ?? "(unnamed)"}`);
     }
     return 0;
 }

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

@@ -0,0 +1,62 @@
+/**
+ * `cockpit ops --coverage` — WHICH sessions never arrived (BLI-3798).
+ *
+ * The board's COVERAGE block already prints a line per person. What it never
+ * printed was the BUCKET table: the reasons were computed on the server, sat
+ * on `people[].days[].reasons` in every response, and were never rendered
+ * anywhere — so `42 sessions seen and never arrived` was the whole of what a
+ * person saw, ten QA ticks running, and reading further meant writing a script
+ * against production.
+ *
+ * Same rule as the rest of this file's family: every sentence in here was
+ * written on the SERVER (`lib/ops/coverage-rollup.ts` and
+ * `lib/ops/coverage-buckets.ts`) and is printed VERBATIM. This module decides
+ * order, indentation and column widths and nothing else. A terminal that
+ * composed its own fix sentence would eventually tell somebody to run a
+ * command the board does not believe in, and the one that is wrong is always
+ * the one somebody is reading.
+ *
+ * A CLI too old to know this section simply does not print it: the buckets
+ * ride the ordinary `coverage` section of the same response, so nothing here
+ * is load-bearing for delivery. What is load-bearing is that the SERVER also
+ * puts the dominant bucket in the `collection-coverage` row's `detail`, which
+ * every version prints when the row is `failing`.
+ */
+/**
+ * The bucket table, largest first, each with its people and its fix.
+ *
+ * Printed after the person lines, because "who" comes before "which bucket"
+ * when somebody is scanning — but the HEADLINE goes first, since it is the one
+ * line that answers the question the row has been failing to answer.
+ */
+export function renderCoverageBuckets(table, dim) {
+    if (!table) {
+        // Never a silent gap where a section was asked for: an older Tower that
+        // does not send the table says so, rather than looking like a clean fleet.
+        return [
+            "",
+            "BUCKETS  not sent by this Tower — it predates the coverage bucket table; the per-person lines above are all it knows",
+        ];
+    }
+    const buckets = table.buckets ?? [];
+    const lines = ["", `BUCKETS  ${table.headline ?? "(no headline)"}`];
+    if (buckets.length === 0) {
+        lines.push(dim("  nothing is unaccounted for, so there are no buckets to show"));
+        return lines;
+    }
+    for (const bucket of buckets) {
+        lines.push(`  ${String(bucket.count ?? 0).padStart(5)}  ${bucket.reason ?? "unlabelled"}`);
+        for (const person of bucket.people ?? []) {
+            const days = (person.days ?? []).join(", ");
+            lines.push(dim(`         ${String(person.count ?? 0).padStart(4)}  ${person.displayName ?? "(person)"}` +
+                (days ? `  ${days}` : "")));
+        }
+        // The fix is NOT dimmed. It is the only line on this board that tells
+        // somebody to do something, and a board whose one action is grey is a
+        // board that gets scrolled past — which is what ten ticks of `failing`
+        // with no named bucket already proved.
+        if (bucket.owner)
+            lines.push(`         fix: ${bucket.owner}`);
+    }
+    return lines;
+}

package/dist/commands/ops-render.js

@@ -12,7 +12,9 @@
  * artifact does and does not prove — because that is exactly the moment
  * somebody is about to conclude something from it.
  */
+import { renderCoverageBuckets, } from "./ops-render-coverage.js";
 export { renderMemoryHooks, renderMemoryUsage } from "./ops-render-memory.js";
+export { renderCoverageBuckets };
 /** The word a person reads. Short, fixed width, and never a bare colour. */
 export function verdictWord(verdict) {
     switch (verdict) {
@@ -64,7 +66,15 @@ export function intervalWord(row) {
         return `every ${Math.round(hours / 24)}d`;
     return `every ${Math.round(hours)}h`;
 }
-export function renderOpsStatus(payload, dim) {
+export function renderOpsStatus(payload, dim, 
+/**
+ * BLI-3798. `alwaysShowBuckets` is what `cockpit ops --coverage` passes: the
+ * board hides the table on a clean fleet (it would be nineteen rows of
+ * nothing), but somebody who asked for the coverage view specifically is
+ * owed the answer "nothing is unaccounted for" out loud rather than an
+ * absent section they have to interpret.
+ */
+options = {}) {
     const rows = payload.pipelines ?? [];
     const lines = [];
     const counts = new Map();
@@ -104,8 +114,16 @@ export function renderOpsStatus(payload, dim) {
     }
     if (payload.fleet)
         lines.push(...renderFleet(payload.fleet, dim));
-    if (payload.coverage)
+    if (payload.coverage) {
         lines.push(...renderCoverage(payload.coverage, dim));
+        // BLI-3798. The bucket table rides EVERY board, not only `--coverage`:
+        // ten QA ticks of `42 sessions seen and never arrived` is what happens
+        // when the reasons are only reachable behind a flag nobody knew about.
+        // Skipped entirely on a clean fleet, so it costs a healthy board nothing.
+        if (options.alwaysShowBuckets || (payload.coverage.counts?.gapSessions ?? 0) > 0) {
+            lines.push(...renderCoverageBuckets(payload.coverage.buckets, dim));
+        }
+    }
     const slack = payload.skips?.slack;
     const external = payload.skips?.external;
     if (slack || external) {

package/dist/commands/ops.js

@@ -16,6 +16,15 @@
  * the command, and it does not pass silently either: it prints as `n/a` with
  * the reason there is nothing to read.
  *
+ * `ops status --coverage` (BLI-3798) is the same door narrowed to the
+ * collection-coverage row, with the BUCKET table under it: which bucket the
+ * missing sessions are in, whose machines they are on, which of their own days,
+ * and one fix sentence per bucket. It exists because the board said
+ * `42 sessions seen and never arrived` for ten consecutive QA ticks while the
+ * reasons sat one field deeper in the same response, and reading them meant
+ * writing a script against production. The table also rides the ordinary board
+ * whenever anything is missing, so nobody has to know this flag exists.
+ *
  * `ops recompile` spends a real provider call, so it says what it is about to
  * do and reports the ceiling by name. A run that outlives Tower's own 800-second
  * budget produces no response at all, which is indistinguishable from a network
@@ -83,7 +92,9 @@ async function runOpsStatus(command, io, tower) {
     }
     else {
         const styled = colorEnabled(io);
-        for (const line of renderOpsStatus(payload, (text) => dim(text, styled))) {
+        for (const line of renderOpsStatus(payload, (text) => dim(text, styled), {
+            alwaysShowBuckets: command.coverage === true,
+        })) {
             writeLine(io.stdout, line);
         }
         if (memory?.section) {

package/dist/commands/public-root.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.74",
+  "version": "0.2.76",
   "private": false,
   "type": "module",
   "bin": {