@bli-cockpit/cli 0.2.43 → 0.2.45

package/dist/commands/brief.js

@@ -13,12 +13,16 @@
  * asked for, never who is asking — the same rule `cockpit jarvis --as` follows.
  */
 import { colorEnabled, dim, writeLine } from "./cli-io.js";
+import { renderBriefStatus } from "./ops-render.js";
 import { loadPairedSession, towerJsonRequest } from "../tower-client.js";
 const REQUEST_DEADLINE_MS = 30_000;
 export async function runBrief(command, io) {
     const session = await loadPairedSession("brief", command.homeDir);
     const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
     const startedAt = Date.now();
+    if (command.action === "status") {
+        return runBriefStatus(command, io, dashboardUrl, session.device_token, startedAt);
+    }
     const result = await towerJsonRequest({
         dashboardUrl,
         path: `/api/jarvis/brief${queryFor(command)}`,
@@ -63,6 +67,60 @@ export async function runBrief(command, io) {
     })}`);
     return 0;
 }
+/**
+ * `cockpit brief status` (BLI-3462) — why a brief was or was not delivered.
+ *
+ * The reason is the server's, from the closed set in
+ * `lib/jarvis/delivery-status.ts`, computed by the same code the Slack DM cron
+ * delivers with. This prints it and picks an exit code: `delivered` is 0,
+ * everything else is 1, because "your brief did not arrive" is a result a
+ * script should be able to act on — including the two that are perfectly
+ * normal (`not_monday`, `not_the_1st`), which exit 1 with their own sentence
+ * rather than pretending a delivery happened.
+ */
+async function runBriefStatus(command, io, dashboardUrl, deviceToken, startedAt) {
+    const params = new URLSearchParams();
+    if (command.subject)
+        params.set("who", command.subject);
+    if (command.render)
+        params.set("render", "1");
+    const query = params.toString();
+    const result = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/ops/brief-status${query ? `?${query}` : ""}`,
+        deviceToken,
+        fetch: io.fetch,
+        method: "GET",
+        label: "brief-status",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log: (line) => writeLine(io.stderr, line),
+    });
+    if (!result.ok) {
+        writeFailure(command, io, result.reason, result.detail);
+        return 1;
+    }
+    const payload = result.body;
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(payload));
+    }
+    else {
+        const styled = colorEnabled(io);
+        for (const line of renderBriefStatus(payload, (text) => dim(text, styled))) {
+            writeLine(io.stdout, line);
+        }
+    }
+    const reason = payload.status?.reason ?? "unknown";
+    writeLine(io.stderr, `[brief cli] status read ${JSON.stringify({
+        reason,
+        subject: command.subject ? "selected" : "caller",
+        owning_cadence: payload.status?.owningCadence ?? null,
+        has_slack_identity: payload.status?.slack?.hasIdentity ?? null,
+        rendered: Boolean(command.render),
+        read_error: payload.status?.readError ?? null,
+        elapsed_ms: Date.now() - startedAt,
+    })}`);
+    return reason === "delivered" ? 0 : 1;
+}
 function queryFor(command) {
     const params = new URLSearchParams();
     if (command.subject)

package/dist/commands/local-args.js

@@ -53,6 +53,10 @@ export function parseLocalArgs(argv) {
             return parseModelArgs(argv.slice(1));
         case "scout":
             return parseScoutArgs(argv.slice(1));
+        case "ops":
+            return parseOpsArgs(argv.slice(1));
+        case "slack":
+            return parseSlackArgs(argv.slice(1));
         case "settings":
             return parseSettingsArgs(argv.slice(1));
         case "team":
@@ -945,6 +949,143 @@ function parseScoutArgs(args) {
     }
     return { kind: "scout", action: rawAction, experimentRef, ...base };
 }
+/**
+ * `cockpit ops status [--job <id>] [--skips]` and
+ * `cockpit ops recompile --person <p> [--dry-run]` (BLI-3462).
+ *
+ * There is deliberately **no `--cadence`** on `recompile`. The compile path
+ * behind it (`writePageAgain` → `publishPage`) takes no cadence and writes a
+ * daily; accepting the flag and dropping it is the silent breakage BLI-2490
+ * forbids, and threading cadence through that path is its own change. Ask for a
+ * weekly or a monthly with the compile script, which does support it.
+ */
+function parseOpsArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--job",
+            "--skips",
+            "--person",
+            "--dry-run",
+            "--json",
+        ],
+        valueFlags: ["--home", "--dashboard-url", "--job", "--person"],
+    });
+    if (values.positionals.length > 1) {
+        throw new Error("ops accepts one action: status or recompile.");
+    }
+    const rawAction = values.positionals[0] ?? "status";
+    if (rawAction !== "status" && rawAction !== "recompile") {
+        throw new Error("ops action must be status or recompile.");
+    }
+    const base = {
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        json: values.booleans.has("--json"),
+    };
+    if (rawAction === "status") {
+        return {
+            kind: "ops",
+            action: "status",
+            job: optionalNonEmpty(values.flags.get("--job")),
+            skips: values.booleans.has("--skips"),
+            ...base,
+        };
+    }
+    const person = optionalNonEmpty(values.flags.get("--person"));
+    if (!person) {
+        throw new Error("ops recompile needs --person <email|name|id>. Nothing is recompiled by default, on purpose.");
+    }
+    return {
+        kind: "ops",
+        action: "recompile",
+        person,
+        dryRun: values.booleans.has("--dry-run"),
+        ...base,
+    };
+}
+/** The workspaces Cockpit collects. A typo is refused here rather than searched for. */
+export const SLACK_WORKSPACE_KEYS = ["bli", "blue_pearl"];
+/**
+ * `cockpit slack coverage [--workspace <key>] [--stale-only]` and
+ * `cockpit slack read [--person|--channel|--query|--since|--until|--limit]`
+ * (BLI-3462).
+ */
+function parseSlackArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--workspace",
+            "--stale-only",
+            "--person",
+            "--channel",
+            "--query",
+            "--since",
+            "--until",
+            "--limit",
+            "--json",
+        ],
+        valueFlags: [
+            "--home",
+            "--dashboard-url",
+            "--workspace",
+            "--person",
+            "--channel",
+            "--query",
+            "--since",
+            "--until",
+            "--limit",
+        ],
+    });
+    if (values.positionals.length > 1) {
+        throw new Error("slack accepts one action: coverage or read.");
+    }
+    const rawAction = values.positionals[0] ?? "coverage";
+    if (rawAction !== "coverage" && rawAction !== "read") {
+        throw new Error("slack action must be coverage or read.");
+    }
+    const base = {
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        json: values.booleans.has("--json"),
+    };
+    if (rawAction === "coverage") {
+        // `--workspace` here is a Slack workspace key, NOT the collection-root
+        // `--workspace <path>` every setup command takes. Named at the point of use
+        // so the two cannot be confused silently.
+        const workspace = optionalNonEmpty(values.flags.get("--workspace"));
+        if (workspace && !SLACK_WORKSPACE_KEYS.includes(workspace)) {
+            throw new Error(`slack --workspace must be one of ${SLACK_WORKSPACE_KEYS.join(", ")}; got ${workspace}.`);
+        }
+        return {
+            kind: "slack",
+            action: "coverage",
+            workspace,
+            staleOnly: values.booleans.has("--stale-only"),
+            ...base,
+        };
+    }
+    const person = optionalNonEmpty(values.flags.get("--person"));
+    const channel = optionalNonEmpty(values.flags.get("--channel"));
+    const query = optionalNonEmpty(values.flags.get("--query"));
+    if (!person && !channel && !query) {
+        throw new Error("slack read needs at least one of --person, --channel or --query. An unfiltered dump of every " +
+            "message is not something this command offers.");
+    }
+    return {
+        kind: "slack",
+        action: "read",
+        person,
+        channel,
+        query,
+        since: optionalNonEmpty(values.flags.get("--since")),
+        until: optionalNonEmpty(values.flags.get("--until")),
+        limit: optionalPositiveInteger(values.flags.get("--limit"), "--limit"),
+        ...base,
+    };
+}
 /** The narrowest width worth wrapping to; below it every line is one word. */
 export const WORKBOOK_MIN_WIDTH = 20;
 /**
@@ -1004,24 +1145,27 @@ function parseBriefArgs(args) {
             "--dashboard-url",
             "--for",
             "--as",
+            "--who",
             "--version",
             "--tldr",
             "--full",
             "--versions",
             "--claims",
+            "--render",
             "--reason",
             "--wait",
             "--no-wait",
             "--json",
         ],
-        valueFlags: ["--home", "--dashboard-url", "--for", "--as", "--version", "--reason"],
+        valueFlags: ["--home", "--dashboard-url", "--for", "--as", "--who", "--version", "--reason"],
     });
     // Bare `cockpit brief` reads the page, which is what somebody typing it almost
     // always wants — the same shape `cockpit notes` and `cockpit scout` have.
+    // `status` (BLI-3462) answers why a brief was or was not delivered.
     const first = values.positionals[0];
     const action = (first === undefined ? "read" : first);
-    if (!["read", "edit", "rewrite"].includes(action)) {
-        throw new Error(`Unknown brief command: ${first}. Try edit or rewrite, or nothing to read it.`);
+    if (!["read", "edit", "rewrite", "status"].includes(action)) {
+        throw new Error(`Unknown brief command: ${first}. Try edit, rewrite or status, or nothing to read it.`);
     }
     if (values.positionals.length > (first === undefined ? 0 : 1)) {
         throw new Error(`brief ${action} does not take "${values.positionals[1]}".`);
@@ -1050,17 +1194,26 @@ function parseBriefArgs(args) {
     }
     // `--as` is accepted as an alias so the two conversational commands read the
     // same way; `cockpit jarvis --as <person>` has meant this since BLI-3380.
+    // `--who` is the third spelling, and it exists because `cockpit brief status
+    // --who <person>` is the terminal echo of `jarvis:dm --who`.
     const forPerson = optionalNonEmpty(values.flags.get("--for"));
     const asPerson = optionalNonEmpty(values.flags.get("--as"));
-    if (forPerson && asPerson && forPerson !== asPerson) {
-        throw new Error("brief --for and --as must name the same person.");
+    const whoPerson = optionalNonEmpty(values.flags.get("--who"));
+    const named = [forPerson, asPerson, whoPerson].filter(Boolean);
+    if (new Set(named).size > 1) {
+        throw new Error("brief --for, --as and --who must name the same person.");
+    }
+    const render = values.booleans.has("--render");
+    if (render && action !== "status") {
+        throw new Error("brief --render belongs to `cockpit brief status`; the page is printed by default.");
     }
     return {
         kind: "brief",
         action,
+        render,
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        subject: forPerson ?? asPerson,
+        subject: forPerson ?? asPerson ?? whoPerson,
         version: optionalNonEmpty(values.flags.get("--version")),
         tldr,
         versions: values.booleans.has("--versions"),

package/dist/commands/local-help.js

@@ -24,6 +24,8 @@ export const rootCommandNames = new Set([
     "jarvis",
     "model",
     "scout",
+    "ops",
+    "slack",
     "settings",
     "team",
     "workbook",
@@ -57,10 +59,13 @@ export function localCommandHelp(command) {
         "  cockpit jarvis [question] [--prompt <question>] [--as <person>] [--thread <name>] [--model <key>] [--image <path>|--file <path>] [--no-stream] [--threads|--history [--limit <n>]] [--dashboard-url <url>] [--json]",
         "  cockpit model [show|set <provider:model>] [--json]",
         "  cockpit scout [start|dismiss|undo <experiment-id>] [--days <n>] [--dashboard-url <url>] [--json]",
+        "  cockpit ops [status [--job <id>] [--skips] | recompile --person <email|name|id> [--dry-run]] [--dashboard-url <url>] [--json]",
+        "  cockpit slack [coverage [--workspace bli|blue_pearl] [--stale-only] | read [--person <p>] [--channel <c>] [--query <text>] [--since <YYYY-MM-DD>] [--until <YYYY-MM-DD>] [--limit <n>]] [--json]",
         "  cockpit settings [personal [--chat-model <key>] [--brief-model <key>] | switches [set <key> <value>] | models [set --chat <key>] [--memory <id>] | env list|set --project <p> --file <f> --content-stdin|delete --id <uuid> [--yes]] [--json]",
         "  cockpit team [members | invite <email> --role <role> [--team-id <uuid>] | role <userId> --role <role> [--yes]] [--json]",
         "  cockpit workbook [<project> [<doc>]] [--section <id>] [--markdown] [--width <n>] [--dashboard-url <url>] [--json]",
         "  cockpit brief [edit|rewrite] [--for <person>] [--version <pageId>] [--tldr|--full] [--versions] [--claims] [--reason \"<why>\"] [--wait|--no-wait] [--dashboard-url <url>] [--json]",
+        "  cockpit brief status [--who <person>] [--render] [--dashboard-url <url>] [--json]",
         "  cockpit correct --claim <claimId> --text \"<what is wrong>\" [--for <person>] [--version <pageId>] [--supersedes <id>] [--dashboard-url <url>] [--json]",
         "  cockpit notes [list|show <id>|shelf|shelves|upload <paths...>|paste|share <id>|unshare <id>|move <id>] [--series <shelf>] [--kind <kind>] [--since <YYYY-MM-DD>] [--until <YYYY-MM-DD>] [--limit <n>] [--file <path>] [--name <n>] [--exclude \"<sentence>\"] [--to \"<shelf>\"|--clear-shelf] [--yes] [--dashboard-url <url>] [--json]",
         "  cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--yes] [--workspace <path>] [--json]",
@@ -305,6 +310,52 @@ function localSubcommandHelp(command) {
                 "Run `cockpit login` first if this machine is not paired.",
             ],
         ],
+        [
+            "ops",
+            [
+                "Usage: cockpit ops [status [--job <id>] [--skips] | recompile --person <email|name|id> [--dry-run]] [--json]",
+                "",
+                "  cockpit ops status",
+                "      One line per scheduled job: when it last produced something, and whether that",
+                "      is late FOR THAT JOB. A once-daily job quiet for 18 hours reads ok; a",
+                "      quarter-hourly one does not. Every line names the schedule it is judged against.",
+                "      A job that is not ok also prints what its artifact does and does not prove —",
+                "      several only write a row when there is something new, so quiet can mean a quiet",
+                "      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.",
+                "  cockpit ops recompile --person <email|name|id> [--dry-run]",
+                "      Writes that person's page again, now. Your own page is always yours to",
+                "      recompile; somebody else's is for the people who read across the team.",
+                "      --dry-run resolves the person and says which page is being served, compiling",
+                "      nothing. A compile only ever ADDS a version — nothing is overwritten.",
+                "      It can take minutes, and if Tower's 800-second budget runs out first you are",
+                "      told exactly that: the compile may still have finished. Check with",
+                "      `cockpit brief --for <person>`.",
+                "      There is no --cadence: the compile path behind this writes a daily, and a flag",
+                "      that was accepted and dropped would be worse than no flag.",
+            ],
+        ],
+        [
+            "slack",
+            [
+                "Usage: cockpit slack [coverage [--workspace bli|blue_pearl] [--stale-only] | read [filters]] [--json]",
+                "",
+                "  cockpit slack coverage",
+                "      What Cockpit's Slack bot can see: how many channels it is in, what each",
+                "      visibility state means, which cursors have not moved, and which ingest skips",
+                "      are open. No message text at all, so anybody signed in can run it.",
+                "      This is the command that tells an empty search apart from a coverage gap.",
+                "      --stale-only drops the per-state breakdown and shows just what is behind.",
+                "  cockpit slack read --person <p> | --channel <c> | --query <text>",
+                "      The messages themselves, through the same reader JARVIS uses. At least one",
+                "      filter is required. --since/--until are YYYY-MM-DD; --limit caps the rows.",
+                "      Reading Slack reads across the team, so this is for the people who do that",
+                "      job; being refused it never costs you `cockpit slack coverage`.",
+                "      An empty or partial answer prints Tower's own sentence about WHY, word for",
+                "      word — none of those reasons means nothing was said.",
+            ],
+        ],
         [
             "workbook",
             [
@@ -335,6 +386,15 @@ function localSubcommandHelp(command) {
                 "--claims prints the [claimId] beside every line, which is what `cockpit correct --claim` takes.",
                 "Reading it here counts as opening it, exactly as opening it in a browser does.",
                 "",
+                "  cockpit brief status [--who <person>] [--render]",
+                "      Why your brief did or did not arrive this morning — one reason, from the same",
+                "      chain the Slack DM cron itself follows: not_due, not_monday, not_the_1st,",
+                "      no_page, page_stale, no_slack_identity, engagement_write_failed, delivered.",
+                "      It shows your delivery window, which cadence owns this morning, whether a",
+                "      Slack identity is on record, and the delivered/opened/clicked receipts.",
+                "      --render adds the TLDR the DM would have carried.",
+                "      --who <person> asks about somebody else and is for the people who read across",
+                "      the team. Exits 0 only on `delivered`.",
                 "edit — opens the page in $VISUAL/$EDITOR as a document: one [claimId] line per sentence you may rewrite, everything else a # comment. Change the words after an id, save, close. Only the lines that really changed are sent, so an accidental save writes nothing.",
                 "  An id you delete or invent is refused by name BEFORE anything is sent: a missing line reads as no opinion at all, not as a sentence to remove, and Tower cannot tell those apart.",
                 "  --reason \"<why>\" rides on every row, exactly like a commit message. Optional; the before-and-after already teaches on its own.",

package/dist/commands/local.js

@@ -19,6 +19,10 @@
  *   jarvis.ts            terminal adapter for the shared JARVIS gateway
  *   scout.ts             `cockpit scout` — the board, and the three card verbs
  *                        (+ scout-render.ts, the pure layout half)
+ *   ops.ts               `cockpit ops` — the pipeline board and one recompile
+ *                        (+ ops-render.ts, the pure layout half, shared with
+ *                        `cockpit brief status`)
+ *   slack.ts             `cockpit slack` — bot coverage, and the messages
  *   workbook.ts          `cockpit workbook` — the project document library
  *                        (+ workbook-render.ts, the pure layout half)
  *   brief.ts             `cockpit brief` — the TODAY page in the terminal
@@ -50,6 +54,8 @@ import { runStatus } from "./status.js";
 import { runSessions } from "./sessions.js";
 import { runJarvis } from "./jarvis.js";
 import { runScout } from "./scout.js";
+import { runOps } from "./ops.js";
+import { runSlack } from "./slack.js";
 import { runModel, runSettings } from "./settings.js";
 import { runTeam } from "./team.js";
 import { asRecord, callTower, openTower } from "./tower-command.js";
@@ -131,6 +137,10 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runModel(command, io);
             case "scout":
                 return await runScout(command, io);
+            case "ops":
+                return await runOps(command, io);
+            case "slack":
+                return await runSlack(command, io);
             case "settings":
                 return await runSettings(command, io);
             case "team":

package/dist/commands/ops-render.js

@@ -0,0 +1,150 @@
+/**
+ * How the pipeline board reads in a terminal (BLI-3462). Pure layout: no io, no
+ * network, no clock of its own.
+ *
+ * The one rule this file exists to keep is the one the server keeps too: an age
+ * is never printed without the schedule it should be judged against. "40h ago"
+ * beside a once-daily job means something different from "40h ago" beside a
+ * quarter-hourly one, and a board that prints the first number without the
+ * second is how BLI-3276 became an outage report about a job that was fine.
+ *
+ * A verdict that is not `ok` also prints the job's own caveat — what its
+ * artifact does and does not prove — because that is exactly the moment
+ * somebody is about to conclude something from it.
+ */
+/** The word a person reads. Short, fixed width, and never a bare colour. */
+export function verdictWord(verdict) {
+    switch (verdict) {
+        case "healthy":
+            return "ok";
+        case "stale":
+            return "STALE";
+        case "never_produced":
+            return "EMPTY";
+        case "unreadable":
+            return "UNREAD";
+        case "no_artifact":
+            return "n/a";
+        default:
+            return verdict ?? "?";
+    }
+}
+/** `13h`, `2d 4h`, or `—` when nothing was ever written. */
+export function ageWord(ageHours) {
+    if (ageHours == null)
+        return "—";
+    if (ageHours < 1)
+        return `${Math.max(0, Math.round(ageHours * 60))}m`;
+    if (ageHours < 48)
+        return `${Math.round(ageHours)}h`;
+    const days = Math.floor(ageHours / 24);
+    return `${days}d ${Math.round(ageHours - days * 24)}h`;
+}
+/** "at most every 13h", the sentence an age has to be read against. */
+export function intervalWord(row) {
+    const hours = row.expectedIntervalHours;
+    if (hours == null)
+        return "schedule unknown";
+    if (hours < 1)
+        return `every ${Math.round(hours * 60)}m`;
+    if (hours >= 168)
+        return "weekly";
+    if (hours >= 24)
+        return `every ${Math.round(hours / 24)}d`;
+    return `every ${Math.round(hours)}h`;
+}
+export function renderOpsStatus(payload, dim) {
+    const rows = payload.pipelines ?? [];
+    const lines = [];
+    const counts = new Map();
+    for (const row of rows)
+        counts.set(row.verdict ?? "?", (counts.get(row.verdict ?? "?") ?? 0) + 1);
+    const summary = [...counts.entries()]
+        .sort((left, right) => right[1] - left[1])
+        .map(([verdict, count]) => `${count} ${verdictWord(verdict)}`)
+        .join(" · ");
+    lines.push(`PIPELINES  ${rows.length} job${rows.length === 1 ? "" : "s"}${summary ? ` · ${summary}` : ""}`);
+    lines.push("");
+    const idWidth = Math.max(4, ...rows.map((row) => (row.id ?? "").length));
+    for (const row of rows) {
+        const verdict = verdictWord(row.verdict).padEnd(6);
+        const id = (row.id ?? "?").padEnd(idWidth);
+        const age = ageWord(row.ageHours).padStart(7);
+        lines.push(`${verdict} ${id}  ${age}  ${dim(intervalWord(row))}`);
+        if (row.verdict !== "healthy") {
+            if (row.detail)
+                lines.push(dim(`       ${row.detail}`));
+            if (row.caveat)
+                lines.push(dim(`       note: ${row.caveat}`));
+            if (row.configFile)
+                lines.push(dim(`       scheduled by ${row.configFile} (${row.cron ?? "?"})`));
+        }
+    }
+    const slack = payload.skips?.slack;
+    const external = payload.skips?.external;
+    if (slack || external) {
+        lines.push("");
+        lines.push("OPEN SKIPS");
+        for (const ledger of [slack, external]) {
+            if (!ledger)
+                continue;
+            lines.push(...renderSkipLedger(ledger, dim));
+        }
+    }
+    return lines;
+}
+function renderSkipLedger(ledger, dim) {
+    const lines = [];
+    const name = ledger.relation ?? "skips";
+    if (ledger.error) {
+        lines.push(`  ${name}: could not be read (${ledger.error})`);
+        return lines;
+    }
+    const groups = ledger.groups ?? [];
+    if (groups.length === 0) {
+        // "none" is an answer only when it is a read that succeeded, which it is.
+        lines.push(`  ${name}: none ${dim(`(${ledger.openMeans ?? "open"})`)}`);
+        return lines;
+    }
+    const total = ledger.total ?? groups.reduce((sum, group) => sum + (group.count ?? 0), 0);
+    lines.push(`  ${name}: ${ledger.truncated ? `at least ${total}` : total} ${dim(`(${ledger.openMeans ?? "open"})`)}`);
+    for (const group of groups) {
+        lines.push(`    ${String(group.count ?? 0).padStart(5)}  ${group.reason ?? "unlabelled"}`);
+    }
+    return lines;
+}
+export function renderBriefStatus(payload, dim) {
+    const status = payload.status ?? {};
+    const lines = [];
+    lines.push(`${status.displayName ?? "This person"} — ${status.reason ?? "unknown"}`);
+    if (status.detail)
+        lines.push(status.detail);
+    lines.push("");
+    lines.push(dim(`window ${status.windowInstant ?? "?"} (${status.deliveryLocalTime ?? "?"} ${status.timeZone ?? "?"}), ` +
+        `${Math.round(status.hoursSinceWindow ?? 0)}h ago · ${status.owningCadence ?? "?"} owns this morning`));
+    if (status.page) {
+        lines.push(dim(`page ${status.page.pageId ?? "(no id)"} · ${status.page.cadence ?? "?"} · compiled ${status.page.compiledAt ?? "?"}`));
+        if (status.page.note && status.page.note !== status.page.cadence) {
+            lines.push(dim(`     ${status.page.note}`));
+        }
+    }
+    lines.push(dim(`slack ${status.slack?.workspace ?? "bli"}: ${status.slack?.hasIdentity ? "identity on record" : "no identity on record"}`));
+    for (const kind of ["delivered", "opened", "clicked"]) {
+        const receipt = status.receipts?.[kind];
+        lines.push(dim(`${kind.padEnd(10)} ${receipt?.occurredAt ?? "—"}`));
+    }
+    if (status.readError) {
+        lines.push(dim(`read error: ${status.readError} — the reason above is unreliable.`));
+    }
+    if (payload.render) {
+        lines.push("");
+        if (payload.render.reason === "ok" && payload.render.text) {
+            lines.push(payload.render.text);
+        }
+        else {
+            // Never an empty gap where the brief should be.
+            lines.push(dim(`(no text to show: ${payload.render.reason ?? "unknown"})`));
+        }
+    }
+    return lines;
+}

package/dist/commands/ops.js

@@ -0,0 +1,147 @@
+/**
+ * `cockpit ops` — the pipeline board, and forcing one page to be written again,
+ * from a terminal (BLI-3462).
+ *
+ * `ops status` prints one row per scheduled job with the newest artifact it
+ * wrote and a verdict computed against THAT JOB'S own expected interval. The
+ * intervals, the verdicts and the caveats all come from the server
+ * (`lib/ops/pipeline-status.ts`); this file prints them and decides an exit
+ * code. A terminal that judged staleness with its own copy of the schedule
+ * would eventually disagree with the board, and the one that is wrong is always
+ * the one somebody is reading.
+ *
+ * **Exit codes are the whole point of running this in a script.** Zero when
+ * every job that CAN be answered for is healthy; 1 when anything is stale,
+ * empty or unreadable. `no_artifact` — a job that writes no row — does not fail
+ * the command, and it does not pass silently either: it prints as `n/a` with
+ * the reason there is nothing to read.
+ *
+ * `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
+ * failure by status code alone — so it is reported as
+ * `recompile_ceiling_exceeded`, with the effect stated as UNKNOWN rather than
+ * failed: the compile may well have finished after the connection was cut.
+ */
+import { colorEnabled, dim, writeLine } from "./cli-io.js";
+import { renderOpsStatus } from "./ops-render.js";
+import { asRecord, callTower, openTower, writeCommandFailure } from "./tower-command.js";
+/**
+ * A whole compile, plus a little. `maxDuration` on `/api/ops/recompile` is 800
+ * seconds; waiting slightly past it is what lets this command tell "Tower gave
+ * up" from "the network did", instead of hanging up first and blaming the
+ * wrong one.
+ */
+const RECOMPILE_DEADLINE_MS = 830_000;
+const TOWER_RECOMPILE_CEILING_SECONDS = 800;
+export async function runOps(command, io) {
+    const tower = await openTower("ops", command, io);
+    return command.action === "status"
+        ? runOpsStatus(command, io, tower)
+        : runOpsRecompile(command, io, tower);
+}
+async function runOpsStatus(command, io, tower) {
+    const params = new URLSearchParams();
+    if (command.job)
+        params.set("job", command.job);
+    if (command.skips)
+        params.set("skips", "1");
+    const query = params.toString();
+    const result = await callTower(tower, {
+        path: `/api/ops/status${query ? `?${query}` : ""}`,
+        label: "ops-status",
+    });
+    if (!result.ok) {
+        writeLine(io.stderr, `[ops cli] status not read ${JSON.stringify({
+            reason: result.reason,
+            http_status: result.httpStatus ?? null,
+        })}`);
+        return writeCommandFailure(io, command.json, result);
+    }
+    const payload = asRecord(result.body);
+    const rows = payload.pipelines ?? [];
+    const unhealthy = rows.filter((row) => row.verdict === "stale" || row.verdict === "never_produced" || row.verdict === "unreadable");
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(payload));
+    }
+    else {
+        const styled = colorEnabled(io);
+        for (const line of renderOpsStatus(payload, (text) => dim(text, styled))) {
+            writeLine(io.stdout, line);
+        }
+    }
+    // Both branches log — an all-green board that says nothing cannot answer
+    // "did anybody look today?".
+    writeLine(io.stderr, `[ops cli] status read ${JSON.stringify({
+        job: command.job ?? "all",
+        pipelines: rows.length,
+        unhealthy: unhealthy.length,
+        unhealthy_ids: unhealthy.map((row) => row.id ?? "?"),
+        with_skips: Boolean(command.skips),
+    })}`);
+    return unhealthy.length > 0 ? 1 : 0;
+}
+async function runOpsRecompile(command, io, tower) {
+    const person = command.person ?? "";
+    if (!command.json) {
+        writeLine(io.stderr, command.dryRun
+            ? `Checking who "${person}" is and what is being served for them. Nothing will be compiled.`
+            : `Writing ${person}'s page again. This spends a model call and can take several minutes.`);
+    }
+    const result = await callTower(tower, {
+        path: "/api/ops/recompile",
+        method: "POST",
+        body: { person, dryRun: command.dryRun === true },
+        label: "ops-recompile",
+        timeoutMs: RECOMPILE_DEADLINE_MS,
+    });
+    if (!result.ok) {
+        // The ceiling is its own outcome, and its effect is UNKNOWN, not failed.
+        const ceiling = result.reason === "turn_timed_out";
+        const failure = ceiling
+            ? {
+                reason: "recompile_ceiling_exceeded",
+                detail: `Tower's ${TOWER_RECOMPILE_CEILING_SECONDS}-second budget for one recompile ran out before it ` +
+                    "answered. That is not the same as the compile failing: it may have finished after the " +
+                    "connection was cut. Run `cockpit brief --for <person>` to see which page is being served now.",
+                ...(result.httpStatus === undefined ? {} : { httpStatus: result.httpStatus }),
+            }
+            : result;
+        writeLine(io.stderr, `[ops cli] recompile failed ${JSON.stringify({
+            reason: failure.reason,
+            http_status: result.httpStatus ?? null,
+            dry_run: command.dryRun === true,
+        })}`);
+        return writeCommandFailure(io, command.json, failure);
+    }
+    const body = asRecord(result.body);
+    const status = typeof body["status"] === "string" ? body["status"] : "compiled";
+    const displayName = typeof body["displayName"] === "string" ? body["displayName"] : person;
+    const pageId = typeof body["pageId"] === "string" ? body["pageId"] : null;
+    const isNowLive = body["isNowLive"] === true;
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(body));
+    }
+    else if (status === "dry_run") {
+        const latest = typeof body["latestPageId"] === "string" ? body["latestPageId"] : null;
+        writeLine(io.stdout, `${displayName} is on the roster.`);
+        writeLine(io.stdout, latest
+            ? `The page being served for them right now is ${latest}.`
+            : "Nothing has ever been written for them.");
+        writeLine(io.stdout, "Nothing was compiled — this was a dry run.");
+    }
+    else {
+        writeLine(io.stdout, `Wrote ${displayName}'s page again: ${pageId ?? "(no id returned)"}`);
+        writeLine(io.stdout, isNowLive
+            ? "It is the page being served now."
+            : "It is NOT the page being served: a scheduled compile is stamped for a later delivery window, " +
+                "so that one still wins. Nothing was lost — this is a new version alongside it.");
+    }
+    writeLine(io.stderr, `[ops cli] recompile done ${JSON.stringify({
+        status,
+        page_id: pageId,
+        is_now_live: status === "compiled" ? isNowLive : null,
+        dry_run: command.dryRun === true,
+    })}`);
+    return 0;
+}

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.43");
+    writeLine(io?.stdout ?? process.stdout, "0.2.45");
     return 0;
   }
 

package/dist/commands/slack.js

@@ -0,0 +1,198 @@
+/**
+ * `cockpit slack` — what Cockpit's Slack bot can see, and what it collected
+ * (BLI-3462).
+ *
+ * Two subcommands with two different audiences, and the split is the point:
+ *
+ * - `coverage` is collection health — channel names, how many the bot is in,
+ *   which cursors are stale, which skips are open. No message text at all, so
+ *   any signed-in person can run it. An intern who cannot tell "nobody said
+ *   that" from "the bot is not in that channel" files a bug we already know
+ *   about.
+ * - `read` relays what people actually said, including in private channels the
+ *   bot sits in, so the server gates it on the same principal check JARVIS's
+ *   own `readSlack` tool answers to. A refusal here is the system working, and
+ *   it says which of the two commands is open to everyone.
+ *
+ * **The server's `summary` and `note` are printed verbatim.** They are the
+ * sentences that keep an empty result honest — `stale_ingest`,
+ * `bot_not_in_channel`, `channel_never_ingested` all look identical to "nothing
+ * was said" unless named, and a terminal that reworded them would eventually be
+ * the surface that got it wrong.
+ */
+import { colorEnabled, dim, writeLine } from "./cli-io.js";
+import { asRecord, callTower, openTower, writeCommandFailure } from "./tower-command.js";
+export async function runSlack(command, io) {
+    const tower = await openTower("slack", command, io);
+    return command.action === "coverage"
+        ? runCoverageAction(command, io, tower)
+        : runReadAction(command, io, tower);
+}
+async function runCoverageAction(command, io, tower) {
+    const query = command.workspace ? `?workspace=${encodeURIComponent(command.workspace)}` : "";
+    const result = await callTower(tower, {
+        path: `/api/ops/slack/coverage${query}`,
+        label: "slack-coverage",
+    });
+    if (!result.ok) {
+        writeLine(io.stderr, `[slack cli] coverage not read ${JSON.stringify({
+            reason: result.reason,
+            http_status: result.httpStatus ?? null,
+        })}`);
+        return writeCommandFailure(io, command.json, result);
+    }
+    const body = asRecord(result.body);
+    const coverage = asRecord(body["coverage"]);
+    const workspaces = Array.isArray(coverage["workspaces"])
+        ? coverage["workspaces"]
+        : [];
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(body));
+    }
+    else {
+        const styled = colorEnabled(io);
+        for (const line of coverageLines(coverage, workspaces, command.staleOnly === true, (text) => dim(text, styled))) {
+            writeLine(io.stdout, line);
+        }
+    }
+    const staleTotal = workspaces.reduce((sum, row) => sum + numberOf(row["staleChannelsTotal"]), 0);
+    writeLine(io.stderr, `[slack cli] coverage read ${JSON.stringify({
+        workspace: command.workspace ?? "all",
+        workspaces: workspaces.length,
+        covered: workspaces.reduce((sum, row) => sum + numberOf(row["covered"]), 0),
+        stale: staleTotal,
+        open_skips: workspaces.reduce((sum, row) => sum + numberOf(row["openSkipsTotal"]), 0),
+        stale_only: command.staleOnly === true,
+    })}`);
+    // A stale cursor is a finding, not a failure of this command: exit 0 so a
+    // person reading coverage is not told their own read broke.
+    return 0;
+}
+function coverageLines(coverage, workspaces, staleOnly, paint) {
+    const lines = [];
+    const staleAfter = numberOf(coverage["staleAfterHours"]);
+    for (const workspace of workspaces) {
+        const key = String(workspace["workspace"] ?? "?");
+        const known = numberOf(workspace["channelsKnown"]);
+        const covered = numberOf(workspace["covered"]);
+        lines.push(`${key.toUpperCase()}  ${covered} of ${known} channels readable`);
+        if (!staleOnly) {
+            const byVisibility = Array.isArray(workspace["byVisibility"])
+                ? workspace["byVisibility"]
+                : [];
+            for (const entry of byVisibility) {
+                lines.push(paint(`  ${String(numberOf(entry["count"])).padStart(4)}  ${String(entry["state"] ?? "?")} — ${String(entry["meaning"] ?? "?")}`));
+            }
+            lines.push(paint(`  newest cursor: ${String(workspace["newestCursorIso"] ?? "never")}`));
+        }
+        const stale = Array.isArray(workspace["staleChannels"])
+            ? workspace["staleChannels"]
+            : [];
+        const staleTotal = numberOf(workspace["staleChannelsTotal"]);
+        if (staleTotal === 0) {
+            lines.push(paint(`  no channel is over ${staleAfter}h since its last sync`));
+        }
+        else {
+            lines.push(`  ${staleTotal} channel${staleTotal === 1 ? "" : "s"} over ${staleAfter}h since last sync:`);
+            for (const entry of stale) {
+                lines.push(paint(`    ${String(entry["name"] ?? "?")}  last ${String(entry["lastSyncedAt"] ?? "never")}`));
+            }
+            if (stale.length < staleTotal)
+                lines.push(paint(`    …and ${staleTotal - stale.length} more`));
+        }
+        const skips = Array.isArray(workspace["openSkips"])
+            ? workspace["openSkips"]
+            : [];
+        if (skips.length > 0) {
+            lines.push(`  open ingest skips:`);
+            for (const skip of skips) {
+                lines.push(paint(`    ${String(numberOf(skip["count"])).padStart(4)}  ${String(skip["reason"] ?? "?")}`));
+            }
+        }
+        lines.push("");
+    }
+    const orphanChannels = numberOf(coverage["orphanChannels"]);
+    if (orphanChannels > 0) {
+        lines.push(paint(`${orphanChannels} channel(s) belong to no known workspace and are not counted above.`));
+    }
+    if (typeof coverage["note"] === "string")
+        lines.push(paint(coverage["note"]));
+    return lines;
+}
+async function runReadAction(command, io, tower) {
+    const body = {};
+    if (command.person)
+        body["person"] = command.person;
+    if (command.channel)
+        body["channel"] = command.channel;
+    if (command.query)
+        body["query"] = command.query;
+    if (command.since)
+        body["since"] = command.since;
+    if (command.until)
+        body["until"] = command.until;
+    if (command.limit !== undefined)
+        body["limit"] = command.limit;
+    const result = await callTower(tower, {
+        path: "/api/ops/slack/read",
+        method: "POST",
+        body,
+        label: "slack-read",
+    });
+    if (!result.ok) {
+        writeLine(io.stderr, `[slack cli] read refused ${JSON.stringify({
+            reason: result.reason,
+            http_status: result.httpStatus ?? null,
+        })}`);
+        if (!command.json && result.httpStatus === 403) {
+            writeLine(io.stderr, result.detail);
+            writeLine(io.stderr, "`cockpit slack coverage` is open to everyone and answers what the bot can see.");
+            return 1;
+        }
+        return writeCommandFailure(io, command.json, result);
+    }
+    const payload = asRecord(result.body);
+    const read = asRecord(payload["result"]);
+    const messages = Array.isArray(read["messages"])
+        ? read["messages"]
+        : [];
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(payload));
+    }
+    else {
+        const styled = colorEnabled(io);
+        // The server's own summary, first and verbatim: it is the sentence that
+        // keeps an empty answer from reading as "nobody said anything".
+        if (typeof read["summary"] === "string")
+            writeLine(io.stdout, read["summary"]);
+        if (messages.length > 0)
+            writeLine(io.stdout, "");
+        for (const message of messages) {
+            writeLine(io.stdout, `#${String(message["channel"] ?? "?")}  ${String(message["author"] ?? "?")}  ${String(message["messageTs"] ?? "?")}`);
+            writeLine(io.stdout, `  ${String(message["text"] ?? "")}`);
+            if (typeof message["permalink"] === "string") {
+                writeLine(io.stdout, dim(`  ${message["permalink"]}`, styled));
+            }
+        }
+        if (typeof read["note"] === "string" && read["note"]) {
+            writeLine(io.stdout, "");
+            writeLine(io.stdout, dim(read["note"], styled));
+        }
+    }
+    const coverage = asRecord(read["coverage"]);
+    writeLine(io.stderr, `[slack cli] read ${JSON.stringify({
+        status: read["status"] ?? null,
+        reason: read["reason"] ?? null,
+        returned: messages.length,
+        channels_searched: numberOf(coverage["channelsSearched"]),
+        stale_channels: numberOf(coverage["staleChannelsTotal"]),
+        // Presence only — a search term is the person's own words.
+        has_person: Boolean(command.person),
+        has_channel: Boolean(command.channel),
+        has_query: Boolean(command.query),
+    })}`);
+    return 0;
+}
+function numberOf(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}

package/dist/commands/tower-command.js

@@ -19,7 +19,12 @@
  */
 import { readPipedText, writeLine } from "./cli-io.js";
 import { loadPairedSession, towerFailureDetail, towerJsonRequest, } from "../tower-client.js";
-/** Client-side ceiling. These routes are small reads and writes, not turns. */
+/**
+ * Client-side ceiling. These routes are small reads and writes, not turns —
+ * except `/api/ops/recompile`, which runs a whole compile and passes its own
+ * `timeoutMs` (BLI-3462). A caller that needs longer says so; nothing here
+ * silently waits forever.
+ */
 const REQUEST_DEADLINE_MS = 30_000;
 export async function openTower(commandName, command, io) {
     const session = await loadPairedSession(commandName, command.homeDir);
@@ -38,7 +43,7 @@ export async function callTower(context, options) {
         fetch: context.fetch,
         method: options.method ?? "GET",
         ...(options.body === undefined ? {} : { body: options.body }),
-        timeoutMs: REQUEST_DEADLINE_MS,
+        timeoutMs: options.timeoutMs ?? REQUEST_DEADLINE_MS,
         label: options.label,
         log: context.log,
     });

package/package.json

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