@bli-cockpit/cli 0.2.237 → 0.2.238

package/dist/commands/manager-render-home.js

@@ -0,0 +1,208 @@
+/**
+ * How `cockpit manager home` prints a client's Home, and the Today line `list --timeline` prints (BLI-5698).
+ *
+ * The words are the door's own (a headline, a bullet, a title); this file lays them out in the order the
+ * Home tab reads: how fresh the data is, "Where we are" with the live counts beside it, what needs attention
+ * by owner, what is coming up, what the newest read that changed anything did, and the review count. Never the brief: it is the
+ * AI's working notes, kept inside the manager server. "Today" is Vancouver's day, as the manager server counts it.
+ */
+import { dim } from "./cli-io.js";
+/** The manager's day (`TOWER_MANAGER_TIMEZONE`): a task due today is not overdue at 5 pm Pacific. */
+export const MANAGER_TIMEZONE = "America/Vancouver";
+const HEALTH = { on_track: "On track", at_risk: "At risk", blocked: "Blocked" };
+const FRESHNESS = {
+    reading: "being read now",
+    never_read: "never read yet",
+    failed: "the latest read failed",
+    stale: "may be out of date (no good read in the last 36 hours)",
+    fresh: "fresh",
+};
+const MISSING = {
+    never_checked: "Not written yet: the next read writes it.",
+    check_failed: "Not written yet: the last check failed; the next read tries again.",
+    nothing_to_summarise: "Nothing to summarise yet: Tower has no open actions or timeline for this client.",
+};
+const CHANGE = { added: "added", changed: "changed", proposal: "proposed", closed: "closed" };
+const plural = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
+/** `YYYY-MM-DD` of Vancouver's day for an instant. */
+export function managerDay(at) {
+    return new Intl.DateTimeFormat("en-CA", { timeZone: MANAGER_TIMEZONE, year: "numeric", month: "2-digit", day: "2-digit" }).format(at);
+}
+/** "Oct 16" for an instant, on Vancouver's calendar. */
+function shortDate(at) {
+    const date = new Date(at);
+    if (Number.isNaN(date.getTime()))
+        return at;
+    return new Intl.DateTimeFormat("en-US", { timeZone: MANAGER_TIMEZONE, month: "short", day: "numeric" }).format(date);
+}
+/** "3 h ago", "2 d ago", "just now": how old an instant is. */
+export function ageText(at, now) {
+    const ms = now.getTime() - new Date(at).getTime();
+    if (!Number.isFinite(ms))
+        return "at an unknown time";
+    const minutes = Math.floor(Math.max(0, ms) / 60_000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours} h ago`;
+    return `${Math.floor(hours / 24)} d ago`;
+}
+const when = (at, now) => `${shortDate(at)} (${ageText(at, now)})`;
+/** `── Today · Wed Oct 15 ──`, for the `YYYY-MM-DD` day given. */
+export function todayLine(day) {
+    const [year, month, date] = day.split("-").map(Number);
+    const noon = new Date(Date.UTC(year, month - 1, date, 12));
+    const words = new Intl.DateTimeFormat("en-US", { timeZone: "UTC", weekday: "short", month: "short", day: "numeric" }).format(noon).replace(",", "");
+    return `── Today · ${words} ──`;
+}
+/**
+ * The timeline's rows with the Today line in place. The server sends undated, then future (latest first),
+ * then today and the past: the line goes before the first item dated today or earlier, or last when none is.
+ */
+export function withTodayLine(rows, dates, today) {
+    const at = dates.findIndex((date) => typeof date === "string" && date.slice(0, 10) <= today);
+    const line = [todayLine(today)];
+    return at === -1 ? [...rows, line] : [...rows.slice(0, at), line, ...rows.slice(at)];
+}
+/** Who wrote the card and when: "written by AI", "computed from counts", or "edited by" a person. */
+function authorLine(summary, now) {
+    const at = when(summary.writtenAt, now);
+    if (summary.source === "model")
+        return `Written by AI, ${at}.`;
+    if (summary.source === "computed")
+        return `Computed from counts, ${at} (the model could not write it).`;
+    // Never a user id in a person's terminal: the door fills the name, or says "a teammate".
+    return `Edited by ${summary.editedByName ?? "a teammate"}, ${at}.`;
+}
+const CAP_WORDS = {
+    max_depth: "depth cap",
+    max_pages: "page cap",
+    max_listings: "a page too long to search for child pages",
+    read_failed: "a page Notion did not return",
+};
+/**
+ * What the last read could not see, one sentence each, worded as the page's client bar words them
+ * (`readWarnings`, `manager-client-bar.tsx`), and the pages left for the next read unless one is
+ * reading or queued now. Empty when it saw and read everything, or the server is older.
+ */
+export function coverageLines(client) {
+    const walk = client.lastRead?.walk;
+    const idle = !client.running && !client.queued;
+    const incomplete = client.incompletePages ?? 0;
+    const waiting = client.pagesWaiting ?? 0;
+    return [
+        walk && !walk.complete ? `Walk incomplete (${walk.cap ? CAP_WORDS[walk.cap] : "stopped early"}): archiving skipped.` : null,
+        walk && walk.pageReadFailed > 0 ? `${plural(walk.pageReadFailed, "page")} could not be read this time; the next sync tries again.` : null,
+        walk && walk.unreadableSkipped > 0 ? `${plural(walk.unreadableSkipped, "page")} not shared with the Tower integration.` : null,
+        walk && walk.otherClientRoots > 0 ? `Stopped at ${walk.otherClientRoots} other ${walk.otherClientRoots === 1 ? "client's tree" : "clients' trees"}.` : null,
+        walk && walk.otherClientSkipped > 0 ? `${plural(walk.otherClientSkipped, "page")} held by another client.` : null,
+        incomplete > 0 ? `Notion handed over ${plural(incomplete, "page")} only in part.` : null,
+        idle && waiting > 0 ? `${plural(waiting, "page")} still waiting for the next read.` : null,
+    ].filter((line) => line !== null);
+}
+function freshnessLines(home, now) {
+    const read = home.client.lastRead;
+    const synced = home.client.lastSyncedAt;
+    // A failed latest read names its reason, and the data shown is as old as the last good read (availability over completeness).
+    const failed = read && home.freshness.state === "failed"
+        ? `failed ${when(read.finishedAt ?? read.startedAt, now)}${read.reason ? `: ${read.reason}` : ""}; ${synced ? `last good read ${when(synced, now)}` : "no good read yet"}`
+        : null;
+    const lastRead = failed ?? (read ? `last read ${when(read.finishedAt ?? read.startedAt, now)}${read.finishedAt ? "" : ", still running"}` : synced ? `last synced ${when(synced, now)}` : "never read");
+    const notion = home.freshness.notionLastEditedAt ? `Notion last changed ${when(home.freshness.notionLastEditedAt, now)}` : "no Notion page yet";
+    // What the read could not see sits under the Data line, so "fresh" never hides it.
+    return [`Data: ${FRESHNESS[home.freshness.state] ?? home.freshness.state}. ${lastRead[0].toUpperCase()}${lastRead.slice(1)}; ${notion}.`, ...coverageLines(home.client).map((line) => `  ${line}`)];
+}
+function summaryLines(home, now, color) {
+    const c = home.counts;
+    // The page's numbers beside the card: due this week is what needs attention beyond the overdue ones, and "to review" is
+    // the review queue's size (`review.total`), not `counts.toReview` (which also counts the first read's items).
+    const dueThisWeek = Math.max(0, home.needsAttention.total - c.overdue);
+    const counts = `  Live: ${plural(c.openActions, "open action")} (${c.overdue} overdue, ${dueThisWeek} due this week), ${plural(c.timeline, "timeline item")}, ${home.review.total} to review.`;
+    const summary = home.summary;
+    if (!summary)
+        return [`Where we are: ${MISSING[home.summaryMissingReason ?? "never_checked"]}`, counts];
+    const lines = [`Where we are: ${HEALTH[summary.health] ?? summary.health} — ${summary.headline}`];
+    for (const bullet of summary.bullets)
+        lines.push(`  ${bullet.date ?? "(no date)"}  ${bullet.text}`);
+    if (summary.next)
+        lines.push(`  Next: ${summary.next}`);
+    if (summary.blocker)
+        lines.push(`  Blocker: ${summary.blocker}`);
+    lines.push(`  ${authorLine(summary, now)}`);
+    if (summary.inputsChanged)
+        lines.push("  Inputs changed since: the client's data changed or an action went overdue (for an AI-written card, also a meeting or milestone came within a week or passed) after this was written; the next check writes it again.");
+    lines.push(counts, dim(`  version ${summary.updatedAt} (what \`summary --version\` takes)`, color));
+    return lines;
+}
+function attentionLines(home, color) {
+    const attention = home.needsAttention;
+    const head = `Needs attention: ${plural(attention.total, "open action")} overdue or due within 7 days.${attention.truncated ? ` Showing ${attention.items.length} of ${attention.total}.` : ""}`;
+    const lines = [head];
+    const byId = new Map(attention.items.map((item) => [item.id, item]));
+    for (const group of attention.byOwner) {
+        lines.push(`  ${group.owner ?? "No owner"}`);
+        for (const id of group.actionIds) {
+            const item = byId.get(id);
+            if (item)
+                lines.push(`    ${item.dueAt ? `due ${item.dueAt}` : "no due date"}${item.overdue ? " (overdue)" : ""}  ${item.title}  ${dim(`id ${item.id}`, color)}`);
+        }
+    }
+    if (attention.undated > 0)
+        lines.push(`  ${plural(attention.undated, "open action")} ${attention.undated === 1 ? "has" : "have"} no due date (\`list <client>\` shows them).`);
+    return lines;
+}
+function comingUpLines(home) {
+    const coming = home.comingUp;
+    const lines = [`Coming up: ${`${coming.total} ${coming.total === 1 ? "meeting or milestone" : "meetings or milestones"}`} dated today or later.${coming.truncated ? ` Showing ${coming.items.length} of ${coming.total}.` : ""}`];
+    for (const item of coming.items)
+        lines.push(`  ${item.occurredAt ?? "(no date)"}  ${item.kind ?? "item"}  ${item.title}`);
+    if (coming.undated > 0)
+        lines.push(`  ${coming.undated} more ${coming.undated === 1 ? "has" : "have"} no date ("Needs a date").`);
+    return lines;
+}
+function changedLines(home, now) {
+    const changed = home.whatChanged;
+    if (!changed.read)
+        return ["What changed: no read has changed anything yet."];
+    const counts = Object.keys(CHANGE).map((kind) => `${changed.counts[kind] ?? 0} ${CHANGE[kind]}`).join(", ");
+    const total = Object.values(changed.counts).reduce((sum, n) => sum + (n ?? 0), 0);
+    const lines = [`What changed in the newest read that changed anything (${when(changed.read.finishedAt ?? changed.read.startedAt, now)}): ${counts}.${changed.truncated ? ` Showing ${changed.items.length} of ${total}.` : ""}`];
+    for (const item of changed.items)
+        lines.push(`  ${CHANGE[item.change] ?? item.change}  ${item.table}  ${item.title}`);
+    return lines;
+}
+/** The whole Home, top to bottom, for a person. `clientRef` is how they named the client, for the commands it suggests. */
+export function homeLines(home, clientRef, color, now = new Date()) {
+    const ref = /\s/.test(clientRef) ? `"${clientRef}"` : clientRef;
+    const review = home.review.total;
+    return [
+        `${home.client.name}: Home (today ${home.today})`,
+        ...freshnessLines(home, now),
+        "",
+        ...summaryLines(home, now, color),
+        "",
+        ...attentionLines(home, color),
+        "",
+        ...comingUpLines(home),
+        "",
+        ...changedLines(home, now),
+        "",
+        review === 0 ? "Review: no sync change waits for review." : `Review: ${plural(review, "sync change")} ${review === 1 ? "waits" : "wait"} for review: \`cockpit manager queue ${ref}\`.`,
+    ];
+}
+/** What a summary edit printed: the card as written. */
+export function summaryWrittenLines(summary, color, now = new Date()) {
+    const lines = [`Saved "Where we are": ${HEALTH[summary.health] ?? summary.health} — ${summary.headline}`];
+    for (const bullet of summary.bullets)
+        lines.push(`  ${bullet.date ?? "(no date)"}  ${bullet.text}`);
+    if (summary.next)
+        lines.push(`  Next: ${summary.next}`);
+    if (summary.blocker)
+        lines.push(`  Blocker: ${summary.blocker}`);
+    lines.push(`  ${authorLine(summary, now)} It stands until the client's data changes or an action goes overdue; the next check after that writes it again.`);
+    lines.push(dim(`  version ${summary.updatedAt}`, color));
+    return lines;
+}

package/dist/commands/manager-render.js

@@ -7,6 +7,7 @@
  * change nobody read. Readable, not exhaustive: `--json` is the whole answer and never comes through here.
  */
 import { dim } from "./cli-io.js";
+import { managerDay, withTodayLine } from "./manager-render-home.js";
 const QUEUE_REASON = {
     added: "added by a sync, not looked at yet",
     changed: "changed by a sync since you last saw it",
@@ -56,7 +57,8 @@ export function itemRowLines(item, timeline, color) {
         : [ownersText(item, false), whenText(item, false), item.status ?? "open"];
     return [`${item.title}  [${review}]`, `  ${facts.join(" | ")}`, dim(`  id ${item.id}  version ${item.updatedAt}`, color)];
 }
-export function listLines(list, timeline, color) {
+/** A list for a person; a timeline list carries the Today line between upcoming and past (Vancouver's day). */
+export function listLines(list, timeline, color, now = new Date()) {
     const noun = timeline ? "timeline item" : "action";
     const shown = list.items.length;
     const head = shown < list.total ? `Showing ${shown} of ${list.total} ${noun}s.` : `${list.total} ${noun}${list.total === 1 ? "" : "s"}.`;
@@ -65,8 +67,10 @@ export function listLines(list, timeline, color) {
     const lines = [`${head}${cut}`, `The client has ${c.openActions} open ${c.openActions === 1 ? "action" : "actions"} (${c.overdue} overdue) and ${c.toReview} ${c.toReview === 1 ? "item" : "items"} to review.`];
     if (shown === 0)
         lines.push(`No ${noun}s match.`);
-    for (const item of list.items)
-        lines.push("", ...itemRowLines(item, timeline, color));
+    const rows = list.items.map((item) => itemRowLines(item, timeline, color));
+    const placed = timeline && shown > 0 ? withTodayLine(rows, list.items.map((item) => item.occurredAt), managerDay(now)) : rows;
+    for (const row of placed)
+        lines.push("", ...row);
     return lines;
 }
 export function queueLines(queue, color) {

package/dist/commands/manager-requests.js

@@ -10,6 +10,22 @@ export function planManagerRequest(command, clientId, newRequestId) {
             return { method: "GET", path: `${BASE}/clients`, logFields: (a) => ({ clients: arrayLength(a, "clients") }) };
         case "client":
             return { method: "GET", path: `${BASE}/clients/${enc(clientId ?? "")}`, logFields: () => ({}) };
+        case "home":
+            return { method: "GET", path: `${BASE}/clients/${enc(clientId ?? "")}/home`, logFields: homeLog };
+        case "summary": {
+            const fields = { expectedUpdatedAt: command.version ?? null };
+            if (command.health !== undefined)
+                fields["health"] = command.health;
+            if (command.headline !== undefined)
+                fields["headline"] = command.headline;
+            if (command.bullets !== undefined)
+                fields["bullets"] = command.bullets;
+            if (command.next !== undefined)
+                fields["next"] = command.next;
+            if (command.blocker !== undefined)
+                fields["blocker"] = command.blocker;
+            return { method: "PATCH", path: `${BASE}/clients/${enc(clientId ?? "")}/summary`, body: fields, logFields: (a) => ({ fields: Object.keys(fields).filter((key) => key !== "expectedUpdatedAt"), source: stringField(a, "source"), bullets: arrayLength(a, "bullets") }) };
+        }
         case "run":
             return { method: "GET", path: `${BASE}/runs/${enc(command.runId ?? "")}`, logFields: () => ({}) };
         case "list":
@@ -90,6 +106,23 @@ function itemLog(table) {
         return { table, item_id: item?.id ?? null, review_status: item?.reviewStatus ?? null };
     };
 }
+/** Home's log line: which parts it holds and their sizes, never their words. */
+function homeLog(answer) {
+    const home = answer && typeof answer === "object" ? answer : {};
+    const part = (key) => (home[key] && typeof home[key] === "object" ? home[key] : undefined);
+    return {
+        summary_source: stringField(part("summary"), "source"),
+        summary_missing: typeof home["summaryMissingReason"] === "string" ? home["summaryMissingReason"] : null,
+        freshness: stringField(part("freshness"), "state"),
+        needs_attention: numberField(part("needsAttention"), "total"),
+        coming_up: numberField(part("comingUp"), "total"),
+        review: numberField(part("review"), "total"),
+    };
+}
+function stringField(answer, key) {
+    const value = answer && typeof answer === "object" ? answer[key] : undefined;
+    return typeof value === "string" ? value : null;
+}
 function arrayLength(answer, key) {
     const value = answer && typeof answer === "object" ? answer[key] : undefined;
     return Array.isArray(value) ? value.length : null;

package/dist/commands/manager.js

@@ -5,7 +5,7 @@
  * them, adds and edits them, ticks them off, links an action to the meeting it came from, and
  * decides the AI's suggestions, the same things the manager page does.
  *
- * Sixteen verbs, each one `/api/manager` door on this machine's device token, the same door the MCP
+ * Eighteen verbs (`home` and `summary`, BLI-5698: a client's Home and its "Where we are" card), each one `/api/manager` door on this machine's device token, the same door the MCP
  * twins (`manager_*`) use; the door passes Railway's answer through unchanged. Every write on an
  * existing item carries `--version`, the item's `updatedAt` as `list`/`show` print it: a stale one is
  * refused with the door's own sentence and nothing is written. `approve`, `dismiss` and `proposal`
@@ -17,6 +17,7 @@ import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./age
 import { colorEnabled, writeLine } from "./cli-io.js";
 import { localCommandHelp } from "./local-help.js";
 import { clientDetailLines, clientLines, itemDetailLines, itemRowLines, runLines, listLines, queueLines, } from "./manager-render.js";
+import { homeLines, summaryWrittenLines } from "./manager-render-home.js";
 import { planManagerRequest } from "./manager-requests.js";
 const TAG = "[manager cli]";
 /**
@@ -28,7 +29,7 @@ export const MANAGER_DEADLINE_MS = 65_000;
 const staleHint = (id, timeline) => `Run \`cockpit manager show ${id}${timeline ? " --timeline" : ""}\` for the current version and try again.`;
 /** Refusals that mean "the item is not as you last saw it": reading it again is the way forward. */
 /** The verbs that change an existing item. */
-const WRITES = new Set(["edit", "done", "reopen", "link", "approve", "dismiss", "proposal", "archive", "unarchive"]);
+const WRITES = new Set(["summary", "edit", "done", "reopen", "link", "approve", "dismiss", "proposal", "archive", "unarchive"]);
 const RESEEN_REFUSALS = new Set(["item_changed", "item_busy", "proposal_decided", "no_proposal"]);
 export async function runManager(command, io) {
     if (command.help) {
@@ -103,6 +104,8 @@ function renderAnswer(command, body, color) {
     switch (command.action) {
         case "clients": return clientLines(body.clients, color);
         case "client": return clientDetailLines(body, color);
+        case "home": return homeLines(body, command.client ?? "<client>", color);
+        case "summary": return summaryWrittenLines(body, color);
         case "run": return runLines(body);
         case "list": return listLines(body, timeline, color);
         case "queue": return queueLines(body, color);
@@ -161,12 +164,17 @@ async function resolveClient(door, ref) {
 /** What to do next after a refusal that is not "read it again", so every refusal ends with a way forward. */
 function nextStep(reason, refusal, command) {
     const id = command?.id ?? "<id>";
+    if (refusal?.startsWith("summary_") && command)
+        return summaryHint(refusal, command);
     const flag = command?.timeline ? " --timeline" : "";
     if (reason === "not_found" && command?.id) {
         return command.timeline
             ? " Check the id with `cockpit manager list <client> --timeline`; for an action, drop --timeline."
             : ` Check the id with \`cockpit manager list <client>\`; for a timeline item, add --timeline${command.action === "done" || command.action === "reopen" || command.action === "link" ? " (done, reopen and link are for actions only)" : ""}.`;
     }
+    // A client-level command (home, summary, client, list, queue, add) the door cannot find the client of: "That client does not exist".
+    if (reason === "not_found" && !command?.id && command?.action !== "run")
+        return " Check it with `cockpit manager clients`.";
     // The door's key check (no such key, or a revoked one): this machine needs signing in again.
     if (reason === "http_401")
         return " Sign this machine in to Tower again with `cockpit login`, then retry.";
@@ -201,11 +209,37 @@ function refuse(door, answer, command, requestId) {
     const noAnswer = answer.httpStatus === undefined || answer.httpStatus >= 500;
     // A change to an existing item with no answer may or may not have landed: look before trying again.
     const changedUnknown = !unconfirmed && noAnswer && command?.id !== undefined && WRITES.has(command.action);
+    // A card edit with no answer may or may not have landed: read the Home before trying again.
+    const summaryUnknown = noAnswer && command?.action === "summary";
     const retry = unconfirmed
         ? ` Nothing was confirmed: Tower did not say whether the item was made. Rerun the same command with \`--request-id ${requestId}\` to retry without making a duplicate.`
-        : changedUnknown
-            ? ` It may or may not have been saved: run \`cockpit manager show ${command.id}${command.timeline ? " --timeline" : ""}\` to see, and use the version it prints if you try again.`
-            : "";
+        : summaryUnknown
+            ? ` It may or may not have been saved: run \`cockpit manager home ${clientWord(command)} --json\` to see, and use its summary.updatedAt if you try again.`
+            : changedUnknown
+                ? ` It may or may not have been saved: run \`cockpit manager show ${command.id}${command.timeline ? " --timeline" : ""}\` to see, and use the version it prints if you try again.`
+                : "";
     const stop = hint || retry ? (/[.!?]$/.test(sentence) ? "" : ".") : "";
     return failAgentDoor(door, TAG, answer.reason, `${sentence}${stop}${hint}${retry}`, { ...(refusal ? { refusal } : {}), ...(unconfirmed ? { requestId } : {}) });
+}
+const clientWord = (command) => (command.client && /\s/.test(command.client) ? `"${command.client}"` : command.client ?? "<client>");
+/** The way forward after each named refusal of a "Where we are" edit (`TOWER_MANAGER_SUMMARY_REFUSALS`). */
+function summaryHint(refusal, command) {
+    const home = `\`cockpit manager home ${clientWord(command)} --json\``;
+    const hints = {
+        summary_changed: `Someone or the check wrote the card since: read it again with ${home} and retry with its summary.updatedAt as --version (none only when it has no card).`,
+        summary_empty: "Give at least one of --health, --headline, --bullet, --next, --blocker.",
+        summary_incomplete: "This client has no card yet: give --health, --headline and at least one --bullet together (with --version none).",
+        summary_health_invalid: "--health is on_track, at_risk or blocked.",
+        summary_headline_empty: "Give the headline some words.",
+        summary_headline_too_long: "Keep --headline to 140 characters.",
+        summary_bullets_count: "Give 1 to 5 --bullet flags; together they replace the whole list.",
+        summary_bullet_empty: "Every --bullet needs words (after its date, when it has one).",
+        summary_bullet_too_long: "Keep each --bullet to 160 characters.",
+        summary_bullet_date_invalid: "Start a dated bullet with a real day, \"YYYY-MM-DD: \", or leave the date out.",
+        summary_next_too_long: "Keep --next to 200 characters.",
+        summary_blocker_too_long: "Keep --blocker to 200 characters.",
+        summary_blocked_needs_blocker: "blocked needs a blocker: add --blocker <what blocks it>, or pick another --health.",
+    };
+    const hint = hints[refusal];
+    return hint ? ` ${hint}` : ` Read the card with ${home} and try again.`;
 }

package/dist/commands/memory-consolidation.js

@@ -49,19 +49,29 @@ export async function runMemoryConsolidation(command, door) {
     if (door.json)
         return emitAgentDoor(door, answer.body);
     if (runs.length === 0) {
-        writeLine(door.io.stdout, body.role === "super_admin"
-            ? "No consolidation pass has been recorded yet. The pass is a nightly Railway cron; nothing has run, or nothing has changed."
-            : "No consolidation runs are visible to this account. The receipts are readable by a super_admin; this is the access rule answering, not an outage.");
+        writeNoRunsVisible(door, body.role);
         return 0;
     }
     if (body.night && body.nightLine) {
-        // Last night first (BLI-13376): one line for the whole night, then a row per scope.
-        writeLine(door.io.stdout, body.nightLine);
-        writeLine(door.io.stdout, nightTable(body.nightScopes ?? []));
-        writeLine(door.io.stdout, "");
-        writeLine(door.io.stdout, "merged/rewritten/corrected are what an apply run wrote, or what a report run only proposed (mode column). kept is always a proposal. Nothing is ever deleted. `--json` has every run.");
+        writeLastNight(door, body.nightLine, body.nightScopes ?? []);
         return 0;
     }
+    writeRunList(door, runs);
+    return 0;
+}
+function writeNoRunsVisible(door, role) {
+    writeLine(door.io.stdout, role === "super_admin"
+        ? "No consolidation pass has been recorded yet. The pass is a nightly Railway cron; nothing has run, or nothing has changed."
+        : "No consolidation runs are visible to this account. The receipts are readable by a super_admin; this is the access rule answering, not an outage.");
+}
+/** Last night first (BLI-13376): one line for the whole night, then a row per scope. */
+function writeLastNight(door, nightLine, scopes) {
+    writeLine(door.io.stdout, nightLine);
+    writeLine(door.io.stdout, nightTable(scopes));
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, "merged/rewritten/corrected are what an apply run wrote, or what a report run only proposed (mode column). kept is always a proposal. Nothing is ever deleted. `--json` has every run.");
+}
+function writeRunList(door, runs) {
     for (const run of runs) {
         writeLine(door.io.stdout, `${run.containerTag ?? "(no tag)"}  ${run.mode ?? "?"}`);
         writeLine(door.io.stdout, `    ${run.startedAt ?? "?"} -> ${run.finishedAt ?? "unfinished"}  ${run.reason ?? "no reason recorded"}`);
@@ -74,7 +84,6 @@ export async function runMemoryConsolidation(command, door) {
     }
     writeLine(door.io.stdout, "");
     writeLine(door.io.stdout, "report = proposals only, nothing on the shelf changed. apply = the accepted edits were written as supersessions; nothing is ever deleted.");
-    return 0;
 }
 /** `merge 2, rewrite 1` out of a verb-count object. Never a sentence. */
 function countsOf(value) {

package/dist/commands/memory-daemon-probe.js

@@ -24,6 +24,39 @@ import os from "node:os";
 import { MEMORY_DAEMON_MAX_LINE_BYTES, MEMORY_DAEMON_PROTOCOL_VERSION, memoryDaemonEndpoint, } from "@bli-cockpit/telemetry-core";
 /** A probe waits this long in total. A live local socket answers in ~1 ms. */
 export const DAEMON_PROBE_TIMEOUT_MS = 400;
+function socketErrorReason(code) {
+    return code === "ENOENT" || code === "ECONNREFUSED"
+        ? "daemon_absent"
+        : `daemon_socket_${(code ?? "error").toLowerCase()}`;
+}
+/** What the daemon's reply says so far; undefined while its one line is still arriving. */
+function judgeDaemonReply(buffered) {
+    if (buffered.length > MEMORY_DAEMON_MAX_LINE_BYTES) {
+        return { answering: false, reason: "daemon_answer_too_large" };
+    }
+    const newline = buffered.indexOf("\n");
+    if (newline === -1)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(buffered.slice(0, newline));
+    }
+    catch {
+        return { answering: false, reason: "daemon_answer_unparseable" };
+    }
+    const record = (parsed ?? {});
+    if (record["ok"] !== true) {
+        return { answering: false, reason: typeof record["reason"] === "string" ? record["reason"] : "daemon_refused" };
+    }
+    return {
+        answering: true,
+        reason: "answering",
+        extra: {
+            pid: typeof record["pid"] === "number" ? record["pid"] : null,
+            startedAt: typeof record["startedAt"] === "string" ? record["startedAt"] : null,
+        },
+    };
+}
 export function probeMemoryDaemon(options = {}) {
     const now = options.now ?? Date.now;
     const started = now();
@@ -56,40 +89,16 @@ export function probeMemoryDaemon(options = {}) {
         timer.unref?.();
         const socket = (options.connectImpl ?? ((address) => net.createConnection({ path: address })))(endpoint.address);
         socket.on("error", (error) => {
-            const code = error.code;
-            finish(false, code === "ENOENT" || code === "ECONNREFUSED"
-                ? "daemon_absent"
-                : `daemon_socket_${(code ?? "error").toLowerCase()}`);
+            finish(false, socketErrorReason(error.code));
         });
         socket.on("connect", () => {
             socket.write(`${JSON.stringify({ v: MEMORY_DAEMON_PROTOCOL_VERSION, event: "ping" })}\n`);
         });
         socket.on("data", (chunk) => {
             buffered += chunk.toString("utf8");
-            if (buffered.length > MEMORY_DAEMON_MAX_LINE_BYTES) {
-                finish(false, "daemon_answer_too_large");
-                return;
-            }
-            const newline = buffered.indexOf("\n");
-            if (newline === -1)
-                return;
-            let parsed;
-            try {
-                parsed = JSON.parse(buffered.slice(0, newline));
-            }
-            catch {
-                finish(false, "daemon_answer_unparseable");
-                return;
-            }
-            const record = (parsed ?? {});
-            if (record["ok"] !== true) {
-                finish(false, typeof record["reason"] === "string" ? record["reason"] : "daemon_refused");
-                return;
-            }
-            finish(true, "answering", {
-                pid: typeof record["pid"] === "number" ? record["pid"] : null,
-                startedAt: typeof record["startedAt"] === "string" ? record["startedAt"] : null,
-            });
+            const verdict = judgeDaemonReply(buffered);
+            if (verdict)
+                finish(verdict.answering, verdict.reason, verdict.extra);
         });
         socket.on("close", () => finish(false, "daemon_closed_without_answer"));
     });