@bli-cockpit/cli 0.2.128 → 0.2.132

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

@@ -1,10 +1,13 @@
 /**
- * `cockpit memory search|save|update|forget` — the argument table (BLI-4047).
+ * `cockpit memory search|save|update|forget|profile|consolidation|requeue` —
+ * the argument table (BLI-4047; `profile` added by BLI-4533, `consolidation`
+ * by BLI-4534, `requeue` by BLI-4539).
  *
  * BLI Memory was the one Tower surface with no command-line door: the browser
  * had one, the `bli-memory` MCP server had one, and a person or a script at a
- * terminal had nothing. These four verbs are the twins of that server's four
- * tools, over the SAME `/api/memory/*` doors.
+ * terminal had nothing. The first four verbs are the twins of that server's
+ * four tools, over the SAME `/api/memory/*` doors; `profile` is the twin of
+ * `memory_profile` on `bli-tower`, over `GET /api/memory/profile`.
  *
  * Two rules this table exists to enforce, both of them the same discipline
  * `cockpit docs create` and `cockpit notes paste` already follow:
@@ -34,6 +37,12 @@ export const MEMORY_STORE_ACTIONS = new Set([
     "save",
     "update",
     "forget",
+    "profile",
+    // BLI-4534: a READ of the nightly consolidation receipts, not a fifth way to
+    // write a memory. It runs no pass and changes nothing — the pass is a
+    // Railway cron; this is how a person or an agent asks what it did.
+    "consolidation",
+    "requeue",
 ]);
 const ALLOWED_FLAGS = [
     "--home",
@@ -49,6 +58,11 @@ const ALLOWED_FLAGS = [
     "--file",
     "--content-stdin",
     "--reason",
+    "--since",
+    "--until",
+    "--source",
+    "--dry-run",
+    "--apply",
     "--json",
 ];
 const VALUE_FLAGS = [
@@ -62,25 +76,39 @@ const VALUE_FLAGS = [
     "--alias",
     "--file",
     "--reason",
+    "--since",
+    "--until",
+    "--source",
 ];
 export function parseMemoryStoreArgs(action, args) {
     const values = parseNamedArgs(args, { allowedFlags: ALLOWED_FLAGS, valueFlags: VALUE_FLAGS });
     const rest = values.positionals.slice(1);
     const containers = values.flagValues.get("--container") ?? [];
-    if (action !== "search" && containers.length > 1) {
+    if (action !== "search" && action !== "consolidation" && containers.length > 1) {
         throw new Error(`memory ${action} takes at most one --container.`);
     }
     if (action !== "search" && (values.flags.has("--limit") || values.booleans.has("--no-recent"))) {
         throw new Error("--limit and --no-recent only apply to memory search.");
     }
+    if (action === "consolidation" && rest.length > 0) {
+        throw new Error("memory consolidation takes no positionals: `cockpit memory consolidation [--container <tag>] [--json]`.");
+    }
     if (action !== "save" && values.flags.has("--alias")) {
         throw new Error("--alias only applies to memory save.");
     }
     if (action !== "save" && (values.flags.has("--custom-id") || values.booleans.has("--extract"))) {
         throw new Error("--custom-id and --extract only apply to memory save.");
     }
-    if (action !== "forget" && (values.flags.has("--reason") || values.booleans.has("--content-stdin"))) {
-        throw new Error("--reason and --content-stdin only apply to memory forget.");
+    if (action !== "forget" && values.booleans.has("--content-stdin")) {
+        throw new Error("--content-stdin only applies to memory forget.");
+    }
+    if (action !== "forget" && action !== "requeue" && values.flags.has("--reason")) {
+        throw new Error("--reason only applies to memory forget and memory requeue.");
+    }
+    if (action !== "requeue"
+        && (values.flags.has("--since") || values.flags.has("--until") || values.flags.has("--source")
+            || values.booleans.has("--dry-run") || values.booleans.has("--apply"))) {
+        throw new Error("--since, --until, --source, --dry-run and --apply only apply to memory requeue.");
     }
     if (values.flags.has("--file") && action !== "save" && action !== "update") {
         throw new Error("--file only applies to memory save and memory update.");
@@ -96,6 +124,46 @@ export function parseMemoryStoreArgs(action, args) {
             .filter((tag) => tag.length > 0),
         json: values.booleans.has("--json"),
     };
+    if (action === "requeue") {
+        // A window is REQUIRED. There is no requeue-everything: applying re-runs
+        // one model call per receipt, so the ceiling on a wrong filter is a bill.
+        if (rest.length > 0) {
+            throw new Error("memory requeue takes no words; name the window with --since and --until.");
+        }
+        const since = readInstant(values.flags.get("--since"), "--since");
+        if (!since) {
+            throw new Error("memory requeue needs --since <iso>, e.g. `cockpit memory requeue --since 2026-09-21T04:10:00Z --dry-run`.");
+        }
+        const until = readInstant(values.flags.get("--until"), "--until");
+        if (until && until < since)
+            throw new Error("--until is before --since; nothing could match.");
+        const source = optionalNonEmpty(values.flags.get("--source"));
+        if (source && source !== "hook" && source !== "harvest") {
+            throw new Error("--source is hook or harvest — the two values a receipt can carry.");
+        }
+        if (values.booleans.has("--dry-run") && values.booleans.has("--apply")) {
+            throw new Error("--dry-run and --apply are opposites; name one.");
+        }
+        return {
+            ...command,
+            action,
+            since,
+            until,
+            ...(source ? { source: source } : {}),
+            // The safe question unless somebody typed otherwise.
+            dryRun: !values.booleans.has("--apply"),
+            reason: optionalNonEmpty(values.flags.get("--reason")),
+        };
+    }
+    if (action === "profile") {
+        // A pure read of ONE container's compiled page. No positional: there is
+        // nothing to ask it, and a stray word would look like a query this verb
+        // silently ignored.
+        if (rest.length > 0) {
+            throw new Error("memory profile takes no words; it reads this repository's compiled page. Name another space with --container.");
+        }
+        return { ...command, action };
+    }
     if (action === "search") {
         // Every remaining positional joined, so `cockpit memory search what did we
         // decide about pagination` needs no quotes — the same shape `cockpit
@@ -105,6 +173,9 @@ export function parseMemoryStoreArgs(action, args) {
             throw new Error("memory search needs a question, e.g. `cockpit memory search \"pagination rule\"`.");
         return { ...command, action, query, limit: readLimit(values.flags.get("--limit")), includeRecent: !values.booleans.has("--no-recent") };
     }
+    if (action === "consolidation") {
+        return { ...command, action };
+    }
     if (action === "save") {
         if (rest.length > 0) {
             throw new Error("memory save reads the memory from stdin or --file, never from the command line: `echo \"...\" | cockpit memory save`.");
@@ -145,6 +216,16 @@ export function parseMemoryStoreArgs(action, args) {
         reason: optionalNonEmpty(values.flags.get("--reason")),
     };
 }
+/** An ISO instant, normalised, or a refusal naming the flag that was wrong. */
+function readInstant(value, flag) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`${flag} must be an ISO instant like 2026-09-21T04:10:00Z.`);
+    }
+    return new Date(parsed).toISOString();
+}
 /** 1..20, the same window the MCP tool and the door both accept. */
 function readLimit(value) {
     if (value === undefined)

package/dist/commands/local-command-shapes-doctor.js

@@ -0,0 +1,12 @@
+// The six human "set my machine up" doors. They are one thing wearing six
+// hats, so they all run the convergence command, but they keep accepting the
+// flags they always accepted, because DMs, runbooks and AGENTS.md rules across
+// the fleet still spell them out.
+export const DOCTOR_SETUP_ALIASES = [
+    "install",
+    "onboard",
+    "login",
+    "pair",
+    "update",
+    "upgrade",
+];

package/dist/commands/local-command-shapes-memory.js

@@ -10,9 +10,9 @@
  *
  *   `memory`        install / status / help — acts on THIS MACHINE, writing an
  *                   MCP registration and three hooks into a home directory.
- *   `memory-store`  search / save / update / forget — acts on TOWER, over
- *                   `/api/memory/*`, the same doors the `bli-memory` MCP
- *                   server and the browser call.
+ *   `memory-store`  search / save / update / forget / profile / requeue —
+ *                   acts on TOWER, over `/api/memory/*`, the same doors the
+ *                   `bli-memory` MCP server and the browser call.
  *   `memory-log`    the agent-experience opinion, part local file part Tower.
  *
  * They are separate kinds rather than one widening `action` union because they

package/dist/commands/local-command-shapes.js

@@ -1,12 +1 @@
-// The six human "set my machine up" doors. They are one thing wearing six
-// hats, so they all run the convergence command — but they keep accepting the
-// flags they always accepted, because DMs, runbooks and AGENTS.md rules across
-// the fleet still spell them out.
-export const DOCTOR_SETUP_ALIASES = [
-    "install",
-    "onboard",
-    "login",
-    "pair",
-    "update",
-    "upgrade",
-];
+export { DOCTOR_SETUP_ALIASES } from "./local-command-shapes-doctor.js";

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

@@ -580,7 +580,7 @@ export function localSubcommandHelp(command) {
         [
             "memory",
             [
-                "Usage: cockpit memory [search|save|update|forget|install|status|log] [flags]",
+                "Usage: cockpit memory [search|save|update|forget|profile|consolidation|requeue|install|status|log] [flags]",
                 "",
                 "The STORE, over the same /api/memory/* doors the bli-memory MCP server calls:",
                 "  search \"<question>\" [--container <tag>] [--limit 1..20] [--no-recent]",
@@ -593,6 +593,16 @@ export function localSubcommandHelp(command) {
                 "  update <id> [--file <path>]   replacement text on stdin; the old row is kept as history.",
                 "  forget <id> [--reason <label>]",
                 "  forget --content-stdin --container <tag> [--reason <label>]   forget by exact text.",
+                "  profile [--container <tag>]   the compiled one-page briefing; a read, never a compile.",
+                "  consolidation [--container <tag>]   what the nightly tidy-up pass did.",
+                "      Clusters looked at, edits by verb, refusals by reason, model and cost.",
+                "      Read-only: the pass is a nightly cron, it never deletes a memory, and",
+                "      report mode changes nothing on the shelf at all.",
+                "  requeue --since <iso> [--until <iso>] [--source hook|harvest] [--reason <label>] [--apply]",
+                "      puts finished extractions back in the queue after the store refused their",
+                "      writes. Super admins only. A DRY RUN unless you pass --apply, because an",
+                "      apply re-runs one model call per receipt. Nothing is ever deleted: each",
+                "      row keeps its previous outcome under result.requeued_from.",
                 "Refusals keep the door's own label — needs_rls_client, unknown_memory,",
                 "already_superseded, no_match — and --json prints the door's answer unchanged.",
                 "",

package/dist/commands/local-help.js

@@ -94,7 +94,7 @@ export function localCommandHelp(command) {
         "  cockpit serve [--port <port>] [--workspace <path>]",
         "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
         "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
-        "  cockpit memory [search \"<question>\"|save|update <id>|forget <id>|install|status|log <win|loss|noise> --store <bli|supermemory|both> \"<reason>\"] [--container <tag>] [--limit <n>] [--no-recent] [--custom-id <id>] [--extract] [--content-stdin] [--reason <label>] [--file <path>] [--dashboard-url <url>] [--dry-run] [--json]",
+        "  cockpit memory [search \"<question>\"|save|update <id>|forget <id>|profile|install|status|log <win|loss|noise> --store <bli|supermemory|both> \"<reason>\"] [--container <tag>] [--limit <n>] [--no-recent] [--custom-id <id>] [--extract] [--content-stdin] [--reason <label>] [--file <path>] [--dashboard-url <url>] [--dry-run] [--json]",
         "  cockpit clean [--dry-run] [--all-committed] [--reconcile] [--dashboard-url <url>] [--json]",
         "  cockpit docs [list|tree|read <id|slug>|create --title <t>|update <id>] [--parent <id>|root|--clear-parent] [--query <text>] [--limit <n>] [--visibility org|private] [--file <path>|--body-stdin] [--allow-empty] [--dashboard-url <url>] [--json]",
         "  cockpit msg [channels|create <name>|dm <email>|read <channel>|send <channel>|thread <id> --channel <channel>] [--private] [--members a@x,b@y] [--description <text>] [--thread <id>] [--limit <n>] [--dashboard-url <url>] [--json]",

package/dist/commands/memory-consolidation.js

@@ -0,0 +1,83 @@
+/**
+ * `cockpit memory consolidation` — what last night's tidy-up did (BLI-4534).
+ *
+ * The nightly pass runs on Railway, not here. This verb is a READ of its
+ * receipts over `GET /api/memory/consolidation`, with this machine's collector
+ * device token, through `agent-door.ts` — the same door the
+ * `memory_consolidation` MCP tool calls and the same credential every other
+ * `cockpit memory` verb uses.
+ *
+ * With `--container` it answers that space's most recent runs; without one it
+ * answers the newest run per container, because a list of forty nights of one
+ * shelf answers nothing.
+ *
+ * **It cannot start, stop or change a pass, and it never prints a memory.**
+ * The rows carry ids, counts, reason labels, a model id and a dollar figure;
+ * the door does not send text and this does not ask for any. `report` in the
+ * `mode` column means the pass computed proposals and wrote nothing to the
+ * shelf; `apply` means the accepted edits were written as supersessions, which
+ * never delete anything.
+ *
+ * **A refusal keeps the door's own reason label**, printed verbatim by
+ * `failAgentDoor`. An EMPTY list is not a refusal and says so in its own
+ * words: the run table is readable by a super_admin, so a caller who is not
+ * one sees nothing, and that is RLS answering rather than an outage.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[memory cli]";
+const READ_DEADLINE_MS = 30_000;
+/** `memory-store.ts` opens the door once for the whole command run and hands it here. */
+export async function runMemoryConsolidation(command, door) {
+    const container = command.containerTags[0];
+    const query = container ? `?container=${encodeURIComponent(container)}` : "";
+    const answer = await askAgentDoor(door, {
+        path: `/api/memory/consolidation${query}`,
+        method: "GET",
+        label: "memory consolidation",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    const runs = body.runs ?? [];
+    writeLine(door.io.stderr, `${TAG} consolidation ${JSON.stringify({
+        reason: body.reason ?? (runs.length > 0 ? "runs_read" : "no_runs_visible"),
+        container: container ?? null,
+        runs: runs.length,
+    })}`);
+    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.");
+        return 0;
+    }
+    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"}`);
+        writeLine(door.io.stdout, `    clusters ${run.clusters ?? 0}  proposed ${countsOf(run.proposed)}  applied ${countsOf(run.applied)}`);
+        const refused = run.refused ?? {};
+        const refusedText = Object.entries(refused)
+            .map(([label, count]) => `${label} ${count}`)
+            .join(", ");
+        writeLine(door.io.stdout, `    refused ${refusedText.length > 0 ? refusedText : "none"}  ${moneyOf(run.costUsd)}  ${run.model ?? "no model"}`);
+    }
+    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) {
+    const verbs = value?.by_verb;
+    if (!verbs || typeof verbs !== "object")
+        return "none";
+    const parts = Object.entries(verbs)
+        .filter(([, count]) => Number(count) > 0)
+        .map(([verb, count]) => `${verb} ${Number(count)}`);
+    return parts.length > 0 ? parts.join(", ") : "none";
+}
+function moneyOf(value) {
+    return value === null || value === undefined ? "$0.000000" : `$${Number(value).toFixed(6)}`;
+}

package/dist/commands/memory-install-codex-hooks.js

@@ -18,7 +18,10 @@
  *     repo forever.
  *  2. **The file shape is Claude Code's, verbatim.** Event → array of matcher
  *     groups → `hooks: [{ type: "command", command, timeout }]`, with the same
- *     event NAMES: `SessionStart`, `UserPromptSubmit`, `Stop`. That is why the
+ *     event NAMES: `SessionStart`, `UserPromptSubmit`, `Stop` — and, since
+ *     BLI-4535, `PreCompact`, which Codex publishes under that exact name with
+ *     the same `manual`/`auto` trigger Claude Code sends
+ *     (<https://learn.chatgpt.com/docs/hooks>, read 2026-09-21). That is why the
  *     merge here is `applyHookGroups` from `memory-install-claude.ts` and not
  *     a second copy: same contract, one owner.
  *  3. **Hooks are on by default now.** `[features] hooks = false` turns them
@@ -196,5 +199,8 @@ function trustTableNamesOurFile(tableHeader, wantedSource) {
  * which is what `applyHookGroups` writes.
  */
 export function expectedCodexTrustRows(config) {
+    // Read off the config rather than written as a number here, so adding a
+    // fourth event (BLI-4535) moved this expectation with it instead of leaving
+    // every trusted machine reading `needs_trust` for a row nobody counted.
     return config.hooks.length;
 }

package/dist/commands/memory-install-contract.js

@@ -27,7 +27,8 @@
  *   "hooks": [
  *     { "event": "SessionStart",     "command": "bli-memory-mcp hook session-start", "timeout_seconds": 30 },
  *     { "event": "UserPromptSubmit", "command": "bli-memory-mcp hook prompt",        "timeout_seconds": 5 },
- *     { "event": "Stop",             "command": "bli-memory-mcp hook stop",          "timeout_seconds": 30 }
+ *     { "event": "Stop",             "command": "bli-memory-mcp hook stop",          "timeout_seconds": 30 },
+ *     { "event": "PreCompact",       "command": "bli-memory-mcp hook pre-compact",   "timeout_seconds": 30 }
  *   ],
  *   "permissions_allow": ["mcp__bli-memory__search_memory"]
  * }
@@ -47,7 +48,7 @@
  * `@bli-cockpit/cli`'s `node_modules` rather than on PATH — so
  * `withResolvedBinPath` re-points every command at the absolute path this
  * machine resolved before anything is written. Skipping that step registered
- * three hooks that answered `command not found` on every turn.
+ * four hooks that answered `command not found` on every turn.
  *
  * **And the path it is re-pointed at is written for a SHELL, not for the
  * filesystem** — `shellSafeBinPath`. A hook command is a shell string, Windows
@@ -64,22 +65,39 @@ export const MEMORY_MCP_BIN = "bli-memory-mcp";
 export const MEMORY_MCP_SERVER_ID = "bli-memory";
 /** The one env var the server is handed. A URL, never a token. */
 export const MEMORY_DASHBOARD_URL_ENV = "COCKPIT_DASHBOARD_URL";
-/** Claude Code hook events this installer registers, in the order it writes them. */
+/**
+ * Hook events this installer registers, in the order it writes them.
+ *
+ * **All four go to BOTH hosts (BLI-4535).** `PreCompact` was checked against
+ * each vendor's own reference before it was added here rather than assumed
+ * from Claude Code's list: Claude Code fires it "before Claude Code is about
+ * to run a compact operation" with `trigger` of `manual` or `auto`
+ * (<https://code.claude.com/docs/en/hooks>, read 2026-09-21), and Codex fires
+ * `PreCompact` "before Codex compacts the chat" with the same two trigger
+ * values and the same common input fields
+ * (<https://learn.chatgpt.com/docs/hooks>, read 2026-09-21). Same event name,
+ * same file shape, same bin — so `memory-install-codex-hooks.ts` needs no
+ * per-host filter and Codex is NOT left at three events.
+ */
 export const MEMORY_HOOK_EVENTS = [
     "SessionStart",
     "UserPromptSubmit",
     "Stop",
+    "PreCompact",
 ];
 /**
  * The bin's own hook subcommands. `session-start` recalls at session open,
  * `prompt` recalls per turn, `stop` saves the turn — the same three jobs the
  * Supermemory plugin's `session-start.js` / `recall-directive.js` / `capture.js`
- * did, collapsed onto one bin.
+ * did, collapsed onto one bin — and `pre-compact` writes the session's recap
+ * before the host throws the conversation away (BLI-4535), which the vendor
+ * plugin never did at all.
  */
 export const MEMORY_HOOK_SUBCOMMAND = {
     SessionStart: "hook session-start",
     UserPromptSubmit: "hook prompt",
     Stop: "hook stop",
+    PreCompact: "hook pre-compact",
 };
 /**
  * Injection hooks must stay fast — Claude Code discards a hook that outlives
@@ -90,6 +108,10 @@ export const MEMORY_HOOK_TIMEOUT_SECONDS = {
     SessionStart: 30,
     UserPromptSubmit: 5,
     Stop: 30,
+    // BLI-4535. Stop's number for Stop's reason: this hook WRITES, its door call
+    // is one queued INSERT, and the recap is the last thing that can be saved
+    // before the context is gone.
+    PreCompact: 30,
 };
 /**
  * Auto-approved tools. READ ONLY, deliberately: the vendor's

package/dist/commands/memory-requeue.js

@@ -0,0 +1,107 @@
+/**
+ * `cockpit memory requeue` — put a window of extractions back (BLI-4539).
+ *
+ * The terminal twin of `POST /api/memory/requeue`, and the reason it exists at
+ * all: between 04:16Z and 11:36Z on 2026-09-21 every insert into the memory
+ * store that carried aliases was refused, 122 extraction receipts closed as if
+ * nothing were wrong, and putting them back took a one-off script somebody
+ * wrote by hand at a keyboard. The masked content sits on those rows for seven
+ * days; recovering it should be one command.
+ *
+ * Its own module rather than a sixth branch of `memory-store.ts`, because that
+ * file is already at the readability band and because this verb refuses
+ * different things from its five siblings: a window is required, the gate is
+ * super_admin, and the default is a DRY RUN.
+ *
+ * **A dry run is the default.** `--dry-run` is the safe question and an apply
+ * takes `--apply` explicitly. Applying re-runs one model call per receipt, so
+ * the shape of the mistake is somebody's bill, and a flag you have to type is
+ * the cheapest possible guard against it.
+ *
+ * **The door's own reason label reaches the terminal unchanged** —
+ * `since_required`, `window_inverted`, `source_unknown`, `reason_not_a_label`,
+ * `requeue_count_failed` — printed verbatim by `failAgentDoor`, never
+ * rephrased here.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[memory requeue cli]";
+/** Long: the door walks up to twenty pages of receipts and writes each row on its own. */
+const REQUEUE_DEADLINE_MS = 300_000;
+export async function runMemoryRequeue(command, io) {
+    const door = await openAgentDoor("memory", command, io);
+    const answer = await askAgentDoor(door, {
+        path: "/api/memory/requeue",
+        method: "POST",
+        label: "memory requeue",
+        timeoutMs: REQUEUE_DEADLINE_MS,
+        body: {
+            since: command.since ?? "",
+            ...(command.until ? { until: command.until } : {}),
+            ...(command.reason ? { reason: command.reason } : {}),
+            ...(command.source ? { source: command.source } : {}),
+            dryRun: command.dryRun,
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    // An HTTP 200 is not an answer. A dashboard that has not shipped this door
+    // yet renders its own 404 PAGE at 200 with an HTML body, and this verb
+    // printed `applied {matched: 0}` for it — a silent success over a route that
+    // does not exist, which is the exact shape of lie the whole ticket is about.
+    // Proven against production on 2026-09-21, before the door was deployed.
+    if (typeof body.matched !== "number") {
+        return failAgentDoor(door, TAG, "requeue_answer_unreadable", "Tower answered 200 with no requeue receipt in it. The usual cause is a dashboard that has not shipped POST /api/memory/requeue yet; nothing was requeued.");
+    }
+    // Counts and labels only: a receipt's content never enters a log line.
+    writeLine(door.io.stderr, `${TAG} ${body.dryRun ? "dry run" : "applied"} ${JSON.stringify({
+        since: command.since ?? "",
+        until: command.until ?? null,
+        source: command.source ?? null,
+        matched: body.matched ?? 0,
+        scanned: body.scanned ?? 0,
+        requeued: body.requeued ?? 0,
+        refused: body.refused ?? 0,
+        coverage: body.coverage ?? "unknown",
+    })}`);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    const matched = body.matched ?? 0;
+    if (matched === 0) {
+        // Silence is not an outage, and it is not a wrong filter either — say
+        // which one this is by naming the window that was asked about.
+        writeLine(door.io.stdout, `No finished extraction receipt is in that window (${command.since} → ${command.until ?? "now"}${command.source ? `, ${command.source} only` : ""}). Nothing to requeue; the receipts table answered.`);
+        return 0;
+    }
+    writeLine(door.io.stdout, body.dryRun
+        ? `${matched} receipt(s) would be requeued (${describeSplit(body.bySource)}).`
+        : `${body.requeued ?? 0} of ${matched} receipt(s) requeued (${describeSplit(body.bySource)}).`);
+    const reasons = describeSplit(body.byReason);
+    if (reasons)
+        writeLine(door.io.stdout, `  by reason: ${reasons}`);
+    if ((body.refused ?? 0) > 0) {
+        writeLine(door.io.stdout, `  ${body.refused} row(s) were refused — a drain claimed them between the read and the write, which is the conditional update doing its job.`);
+    }
+    if (body.coverage === "capped") {
+        writeLine(door.io.stdout, "  The page ceiling stopped this run before the window ended. Run it again for the rest; nothing is lost.");
+    }
+    if (body.dryRun) {
+        writeLine(door.io.stdout, "");
+        writeLine(door.io.stdout, "Nothing was written. Add --apply to do it for real.");
+    }
+    else {
+        writeLine(door.io.stdout, "");
+        writeLine(door.io.stdout, "They are queued again: the hourly sweep reruns the hook receipts and the harvest pass reserves the rest. The previous result is kept on each row under result.requeued_from.");
+    }
+    return 0;
+}
+/** `hook:104, harvest:18` — counts and labels, in the order the door sorted them. */
+function describeSplit(split) {
+    if (!split)
+        return "";
+    return Object.entries(split)
+        .sort((left, right) => right[1] - left[1] || (left[0] < right[0] ? -1 : 1))
+        .map(([label, count]) => `${label}:${count}`)
+        .join(", ");
+}

package/dist/commands/memory-store.js

@@ -1,16 +1,21 @@
 /**
- * `cockpit memory search|save|update|forget` — BLI Memory at a terminal
- * (BLI-4047).
+ * `cockpit memory search|save|update|forget|profile|consolidation|requeue` —
+ * BLI Memory at a terminal (BLI-4047; `profile` added by BLI-4533,
+ * `consolidation` by BLI-4534 and `requeue` by BLI-4539, the last two running
+ * in `memory-consolidation.ts` and `memory-requeue.ts` next door).
  *
  * Memory was the one Tower surface with no command-line door. The browser had
  * one, the `bli-memory` MCP server had four tools, and a person or a script
  * had nothing — so a machine without an agent host could not read or write the
  * store at all, and `cockpit memory` typed on its own registered an MCP server
- * instead of saying what the noun does. These four verbs are the twins of that
- * server's four tools.
+ * instead of saying what the noun does. The first four verbs are the twins of
+ * that server's four tools; `profile` (BLI-4533) is the twin of the
+ * `memory_profile` tool on `bli-tower`, and reads the compiled one-page
+ * briefing a session start injects.
  *
  * **The same doors, never a second store.** `POST /api/memory/{search,save,
- * update,forget}`, with this machine's collector device token, through
+ * update,forget}` and `GET /api/memory/profile`, with this machine's collector
+ * device token, through
  * `agent-door.ts` — the identical route the MCP server calls in
  * `packages/cockpit-memory-mcp/src/server.ts` and the browser calls from
  * `lib/memory/agent-memories/`. Nothing here talks to Postgres, embeds
@@ -40,6 +45,8 @@
 import { resolveContainerTag } from "@bli-cockpit/memory-mcp/dist/container-tag.js";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+import { runMemoryConsolidation } from "./memory-consolidation.js";
+import { runMemoryRequeue } from "./memory-requeue.js";
 import { readNoteFile } from "./notes-file.js";
 const TAG = "[memory cli]";
 const SEARCH_DEADLINE_MS = 60_000;
@@ -60,8 +67,69 @@ export async function runMemoryStore(command, io) {
             return updateMemory(command, door);
         case "forget":
             return forgetMemory(command, door);
+        case "profile":
+            return profileMemory(command, door);
+        case "consolidation":
+            // BLI-4534. Its own module: it reads a different door, prints a
+            // different shape, and is the only memory verb that is about the JOB
+            // rather than about a memory.
+            return runMemoryConsolidation(command, door);
+        case "requeue":
+            // Its own module too: a window-shaped, super-admin, dry-run-by-default
+            // verb that refuses nothing the others refuse (BLI-4539).
+            return runMemoryRequeue(command, io);
     }
 }
+/**
+ * `cockpit memory profile` — the compiled one-page briefing (BLI-4533).
+ *
+ * The same page `POST /api/memory/v4/profile` injects at session start, read on
+ * its own over `GET /api/memory/profile?container=<tag>`. It is a READ: no
+ * compile happens here and none can be asked for. The daily `memory-profile`
+ * service writes the row; this verb answers "what does this project's memory
+ * say about itself right now?", which is the question a person asks when a
+ * session opened with something wrong in it.
+ *
+ * A container nobody has compiled yet answers 200 with `profile: null` and the
+ * reason `not_compiled_yet`. That is not an error and is not printed as one —
+ * "nothing is compiled" and "the store is down" are different facts, and the
+ * second one arrives as a 502 through `failAgentDoor` with the door's own
+ * label.
+ */
+async function profileMemory(command, door) {
+    const containerTag = containerTagsFor(command)[0];
+    const answer = await askAgentDoor(door, {
+        path: `/api/memory/profile?container=${encodeURIComponent(containerTag)}`,
+        method: "GET",
+        label: "memory profile",
+        timeoutMs: SEARCH_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    const profile = body.profile ?? null;
+    const lines = profile?.lines ?? [];
+    // Counts and labels only: a profile line never enters a log line.
+    writeLine(door.io.stderr, `${TAG} profile ${JSON.stringify({
+        container_tag: body.containerTag ?? containerTag,
+        reason: body.reason ?? "unknown",
+        lines: lines.length,
+        source_rows: profile?.sourceRows ?? 0,
+        compiled_at: profile?.compiledAt ?? null,
+        model: profile?.model ?? null,
+    })}`);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    if (!profile || lines.length === 0) {
+        writeLine(door.io.stdout, `No page is compiled for ${body.containerTag ?? containerTag} yet. The daily compile writes one once this space has memories; the store is fine.`);
+        return 0;
+    }
+    for (const line of lines)
+        writeLine(door.io.stdout, line);
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `Compiled ${String(profile.compiledAt ?? "—")} from ${String(profile.sourceRows ?? 0)} memories by ${String(profile.model ?? "—")}.`);
+    return 0;
+}
 /**
  * The verb list a bare `cockpit memory` prints (BLI-4047).
  *
@@ -77,7 +145,7 @@ export function runMemoryVerbList(io, json) {
             ok: true,
             noun: "memory",
             machine_verbs: ["install", "status"],
-            store_verbs: ["search", "save", "update", "forget"],
+            store_verbs: ["search", "save", "update", "forget", "profile", "consolidation", "requeue"],
             log_verbs: ["log"],
         }));
         return 0;
@@ -92,6 +160,13 @@ export function runMemoryVerbList(io, json) {
         "  cockpit memory update <id> [--file <path>] [--json]        replacement text on stdin",
         "  cockpit memory forget <id> [--reason <label>] [--json]",
         "  cockpit memory forget --content-stdin --container <tag> [--reason <label>] [--json]",
+        "  cockpit memory profile [--container <tag>] [--json]",
+        "      the compiled one-page briefing every session opens with; a read, never a compile",
+        "  cockpit memory consolidation [--container <tag>] [--json]",
+        "      what the nightly tidy-up pass did: clusters, edits by verb, refusals, cost",
+        "  cockpit memory requeue --since <iso> [--until <iso>] [--source hook|harvest] [--reason <label>] [--apply] [--json]",
+        "      put a window of finished extractions back in the queue after the store refused",
+        "      their writes; super admins only, and a DRY RUN unless you pass --apply",
         "",
         "This machine:",
         "  cockpit memory install [--dry-run] [--json]   register the MCP server and the three hooks",

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.128",
+  "version": "0.2.132",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,8 +27,8 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.34",
-    "@bli-cockpit/mcp": "0.1.55",
+    "@bli-cockpit/memory-mcp": "0.1.35",
+    "@bli-cockpit/mcp": "0.1.58",
     "@bli-cockpit/telemetry-core": "0.1.48"
   }
 }