@bli-cockpit/cli 0.2.237 → 0.2.239

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

@@ -37,82 +37,86 @@ export async function resolveMemoryConfig(command, io, platform, deps) {
         cliEntryPoint: deps.cliEntryPoint,
         realpath: deps.realpath,
     });
-    if (!found) {
-        return {
-            config: null,
-            source: "none",
-            binTarget: {
-                target: "bin",
-                status: "skipped",
-                reason: "bin_missing",
-                detail: `${MEMORY_MCP_BIN} is not installed beside this CLI or on PATH; nothing was written, and the next daily run will try again`,
-            },
-        };
-    }
-    if (isUnsafeBinPath(found.path)) {
-        // A hook command is a shell string by the platform's design. A path that
-        // cannot be expressed safely in one is not escaped cleverly, and it is not
-        // swapped for a bare name that may resolve to something else either — the
-        // install refuses and says why. See `shellSafeBinPath` for what CAN be
-        // expressed, including the Windows separator normalisation of BLI-4136.
-        return {
-            config: null,
-            source: "none",
-            binTarget: {
-                target: "bin",
-                status: "failed",
-                reason: "bin_path_unsafe",
-                detail: "the resolved bin path cannot be expressed safely in a hook command; nothing was written",
-            },
-            bin_source: found.source,
-        };
-    }
+    if (!found)
+        return binMissing();
+    if (isUnsafeBinPath(found.path))
+        return binPathUnsafe(found.source);
+    return await configFromPresentBin(io, found, platform, dashboardUrl);
+}
+function binMissing() {
+    return {
+        config: null,
+        source: "none",
+        binTarget: {
+            target: "bin",
+            status: "skipped",
+            reason: "bin_missing",
+            detail: `${MEMORY_MCP_BIN} is not installed beside this CLI or on PATH; nothing was written, and the next daily run will try again`,
+        },
+    };
+}
+function binPathUnsafe(binSource) {
+    // A hook command is a shell string by the platform's design. A path that
+    // cannot be expressed safely in one is not escaped cleverly, and it is not
+    // swapped for a bare name that may resolve to something else either — the
+    // install refuses and says why. See `shellSafeBinPath` for what CAN be
+    // expressed, including the Windows separator normalisation of BLI-4136.
+    return {
+        config: null,
+        source: "none",
+        binTarget: {
+            target: "bin",
+            status: "failed",
+            reason: "bin_path_unsafe",
+            detail: "the resolved bin path cannot be expressed safely in a hook command; nothing was written",
+        },
+        bin_source: binSource,
+    };
+}
+/** The bin exists and its path is safe: take its own printed shape, or the built-in one. */
+async function configFromPresentBin(io, found, platform, dashboardUrl) {
     const printed = await printedMemoryConfig(io, found.path);
-    if (printed) {
-        // The bin prints a BARE command name — it cannot know where it was
-        // installed, and it is nested inside the CLI's node_modules rather than on
-        // PATH. Path-qualifying it here is what makes the registration runnable at
-        // all; see `withResolvedBinPath`.
-        const qualified = withResolvedBinPath(printed, {
-            binPath: found.path,
-            platform,
-            dashboardUrl,
-        });
-        if (qualified) {
-            return {
-                config: qualified,
-                source: "bin",
-                binTarget: { target: "bin", status: "already", reason: "bin_printed_config" },
-                bin_source: found.source,
-            };
-        }
-        // A printed hook command this installer cannot re-point. The template is
-        // always path-qualified, so it is the safe answer — and the reason says
-        // which of the two fallbacks happened.
+    if (!printed) {
         return {
             config: builtinMemoryInstallConfig({ binPath: found.path, platform, dashboardUrl }),
             source: "template",
             binTarget: {
                 target: "bin",
                 status: "already",
-                reason: "bin_printed_config_unqualifiable",
-                detail: "the bin printed a hook command this installer could not re-point at the resolved path; the built-in shape was used",
+                reason: "bin_present_template_used",
+                detail: "the bin did not print a usable --print-config; the built-in shape was used",
             },
             bin_source: found.source,
         };
     }
+    // The bin prints a BARE command name — it cannot know where it was
+    // installed, and it is nested inside the CLI's node_modules rather than on
+    // PATH. Path-qualifying it here is what makes the registration runnable at
+    // all; see `withResolvedBinPath`.
+    const qualified = withResolvedBinPath(printed, {
+        binPath: found.path,
+        platform,
+        dashboardUrl,
+    });
+    if (qualified) {
+        return {
+            config: qualified,
+            source: "bin",
+            binTarget: { target: "bin", status: "already", reason: "bin_printed_config" },
+            bin_source: found.source,
+        };
+    }
+    // A printed hook command this installer cannot re-point. The template is
+    // always path-qualified, so it is the safe answer — and the reason says
+    // which of the two fallbacks happened.
     return {
-        config: builtinMemoryInstallConfig({
-            binPath: found.path,
-            platform,
-            dashboardUrl,
-        }),
+        config: builtinMemoryInstallConfig({ binPath: found.path, platform, dashboardUrl }),
         source: "template",
         binTarget: {
             target: "bin",
             status: "already",
-            reason: "bin_present_template_used",
-            detail: "the bin did not print a usable --print-config; the built-in shape was used",
+            reason: "bin_printed_config_unqualifiable",
+            detail: "the bin printed a hook command this installer could not re-point at the resolved path; the built-in shape was used",
         },
         bin_source: found.source,
     };

package/dist/commands/memory-install.js

@@ -97,18 +97,9 @@ export async function installMemoryIntegration(command, io, deps = {}) {
     // `no_bin_no_write`: with no resolved server there is nothing safe to
     // register, so not one file is opened. The bin target carries the reason.
     if (resolved.config) {
-        targets.push(...(await installClaudeMemoryIntegration({
-            homeDir,
-            config: resolved.config,
-            dryRun: command.dryRun,
-            io: fileIo,
-        })));
-        targets.push(...(await installCodexMemoryIntegration({
-            homeDir,
-            config: resolved.config,
-            dryRun: command.dryRun,
-            io: fileIo,
-        })));
+        const host = { homeDir, config: resolved.config, dryRun: command.dryRun, io: fileIo };
+        targets.push(...(await installClaudeMemoryIntegration(host)));
+        targets.push(...(await installCodexMemoryIntegration(host)));
     }
     // BLI-3706: `bli-tower` (docs_*/msg_* over the collector device token)
     // registers beside `bli-memory` on the SAME command — see
@@ -127,6 +118,20 @@ export async function installMemoryIntegration(command, io, deps = {}) {
     }, command.dryRun)));
     const outcome = {
         action: "install",
+        ...(await readBackOutcome(targets, resolved, homeDir, fileIo)),
+    };
+    logMemoryOutcome(outcome, platform);
+    // The heartbeat reads the cache, not the machine — see the receipt module's
+    // "Where the receipt lives between runs". A dry run caches nothing: it proves
+    // what WOULD happen and nothing about what is on disk.
+    if (!command.dryRun) {
+        await cacheReceipt(homeDir ?? command.homeDir, outcome.receipt);
+    }
+    return outcome;
+}
+/** What both `install` and `status` report once the targets are known: their verdict and the receipt. */
+async function readBackOutcome(targets, resolved, homeDir, fileIo) {
+    return {
         ...aggregate(targets),
         config_source: resolved.source,
         bin_found: resolved.config !== null,
@@ -139,14 +144,6 @@ export async function installMemoryIntegration(command, io, deps = {}) {
             expectedTrustRows: resolved.config ? expectedCodexTrustRows(resolved.config) : 0,
         }),
     };
-    logMemoryOutcome(outcome, platform);
-    // The heartbeat reads the cache, not the machine — see the receipt module's
-    // "Where the receipt lives between runs". A dry run caches nothing: it proves
-    // what WOULD happen and nothing about what is on disk.
-    if (!command.dryRun) {
-        await cacheReceipt(homeDir ?? command.homeDir, outcome.receipt);
-    }
-    return outcome;
 }
 /**
  * Reading the trust state never fails an install. A `config.toml` we cannot
@@ -185,16 +182,9 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
     // against, so `status` says the one true thing — the server is not here —
     // rather than reporting four targets against a shape we invented.
     if (resolved.config) {
-        targets.push(...(await inspectClaudeMemoryIntegration({
-            homeDir,
-            config: resolved.config,
-            io: fileIo,
-        })));
-        targets.push(...(await inspectCodexMemoryIntegration({
-            homeDir,
-            config: resolved.config,
-            io: fileIo,
-        })));
+        const host = { homeDir, config: resolved.config, io: fileIo };
+        targets.push(...(await inspectClaudeMemoryIntegration(host)));
+        targets.push(...(await inspectCodexMemoryIntegration(host)));
     }
     // BLI-3706: see the matching note in `installMemoryIntegration`.
     targets.push(...(await inspectTowerIntegration({
@@ -213,17 +203,7 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
         // bounded, it opens nothing but a local socket, and a machine without one
         // is reported as exactly that rather than as a problem.
         daemon: await probeMemoryDaemon({ ...(homeDir ? { homeDir } : {}) }),
-        ...aggregate(targets),
-        config_source: resolved.source,
-        bin_found: resolved.config !== null,
-        ...(resolved.bin_source ? { bin_source: resolved.bin_source } : {}),
-        targets,
-        receipt: buildMemoryInstallReceipt({
-            targets,
-            binFound: resolved.config !== null,
-            codexTrust: await codexTrustFor(homeDir, fileIo),
-            expectedTrustRows: resolved.config ? expectedCodexTrustRows(resolved.config) : 0,
-        }),
+        ...(await readBackOutcome(targets, resolved, homeDir, fileIo)),
     };
     // `status` is a pure read and its reading is exactly as good as an install's
     // — both re-parse the stored files — so it refreshes the cache too. A person

package/dist/commands/memory-requeue.js

@@ -54,7 +54,19 @@ export async function runMemoryRequeue(command, io) {
     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.
+    logRequeueReceipt(door, command, body);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    const matched = body.matched ?? 0;
+    if (matched === 0) {
+        writeNothingMatched(door, command);
+        return 0;
+    }
+    writeRequeueSummary(door, body, matched);
+    return 0;
+}
+/** Counts and labels only: a receipt's content never enters a log line. */
+function logRequeueReceipt(door, command, body) {
     writeLine(door.io.stderr, `${TAG} ${body.dryRun ? "dry run" : "applied"} ${JSON.stringify({
         since: command.since ?? "",
         until: command.until ?? null,
@@ -65,15 +77,15 @@ export async function runMemoryRequeue(command, io) {
         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;
-    }
+}
+/**
+ * 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.
+ */
+function writeNothingMatched(door, command) {
+    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.`);
+}
+function writeRequeueSummary(door, body, matched) {
     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)}).`);
@@ -86,15 +98,10 @@ export async function runMemoryRequeue(command, io) {
     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;
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, body.dryRun
+        ? "Nothing was written. Add --apply to do it for real."
+        : "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.");
 }
 /** `hook:104, harvest:18` — counts and labels, in the order the door sorted them. */
 function describeSplit(split) {

package/dist/commands/memory-rules.js

@@ -46,19 +46,31 @@ function printProjects(groups, machine, write) {
     for (const group of groups) {
         write("");
         write(`${group.project}, ${group.count.toLocaleString("en-US")} memories`);
-        const topics = group.topics ?? [];
-        // Topic headings help only when topics rank the ideas; a lone "Other" heading is noise.
-        const headed = Boolean(group.ranked) && topics.length > 1;
-        if (topics.length)
-            for (const topic of topics) {
-                if (headed)
-                    write(`  ${topic.title}`);
-                for (const idea of topic.memories)
-                    write(`${headed ? "    " : "  "}${machine ? agentWording(idea) : personWording(idea)}`);
-            }
-        else
-            for (const idea of group.memories ?? [])
-                write(`  ${machine ? agentWording(idea) : personWording(idea)}`);
+        printProjectIdeas(group, machine, write);
+    }
+}
+function printProjectIdeas(group, machine, write) {
+    const wording = machine ? agentWording : personWording;
+    const topics = group.topics ?? [];
+    if (topics.length === 0) {
+        for (const idea of group.memories ?? [])
+            write(`  ${wording(idea)}`);
+        return;
+    }
+    // Topic headings help only when topics rank the ideas; a lone "Other" heading is noise.
+    const headed = Boolean(group.ranked) && topics.length > 1;
+    for (const topic of topics) {
+        if (headed)
+            write(`  ${topic.title}`);
+        for (const idea of topic.memories)
+            write(`${headed ? "    " : "  "}${wording(idea)}`);
+    }
+}
+function printOwnerGroups(groups, machine, write) {
+    for (const group of groups) {
+        write(group.owner);
+        for (const rule of group.rules)
+            write(`  [${rule.created_at.slice(0, 10)}] ${rule.project ? `[${rule.project}] ` : ""}${machine ? rule.text : personWording(rule)}`);
     }
 }
 export async function runMemoryRules(command, door) {
@@ -87,11 +99,7 @@ export async function runMemoryRules(command, door) {
     if (projects)
         printProjects(body.projectGroups ?? [], Boolean(command.machine), write);
     else
-        for (const group of body.groups ?? []) {
-            write(group.owner);
-            for (const rule of group.rules)
-                write(`  [${rule.created_at.slice(0, 10)}] ${rule.project ? `[${rule.project}] ` : ""}${command.machine ? rule.text : personWording(rule)}`);
-        }
+        printOwnerGroups(body.groups ?? [], Boolean(command.machine), write);
     if (!body.returned)
         write(`No ${command.action === "knowledge" ? "project knowledge" : "ground rules"} matched.`);
     if (body.capped)

package/dist/commands/memory-search-print.js

@@ -92,4 +92,30 @@ function printOriginals(out, row, alreadyPrinted) {
     const hidden = (row["originalsHidden"] ?? {});
     if (Number(hidden["private"] ?? 0) > 0)
         writeLine(out, `      (${String(hidden["private"])} private original(s) not shown)`);
+}
+export function writeSearchResults(out, results, degraded) {
+    if (results.length > 0) {
+        printSearchRows(out, results);
+        return;
+    }
+    if (degraded) {
+        // BLI-10448: an empty answer from a search that lost a channel is NOT the
+        // record being silent. `semantic_timed_out` is the store answering on
+        // keywords alone after its vector search ran out of time, and saying
+        // "the record is silent" over it sends a person away from memories that
+        // exist.
+        writeLine(out, `No memories matched on the channels that answered, and one did not (${degraded}). Do not read this as the record being silent; ask again.`);
+        return;
+    }
+    // The distinction the whole store is built on: silence is not an outage.
+    // A failure took the `!answer.ok` branch above and named itself there.
+    writeLine(out, "No memories matched. The record is silent on this — it does not mean the store is down.");
+}
+export function writeRecentContext(out, recent) {
+    writeLine(out, "");
+    writeLine(out, "Recent context:");
+    for (const row of recent) {
+        const author = typeof row["savedBy"] === "string" && row["savedBy"] ? `(from ${row["savedBy"]}) ` : "";
+        writeLine(out, `  - ${memoryProjectPrefix(row)}${row["project"] ? "" : author}${oneLine(row["preview"] ?? row["memory"])}`);
+    }
 }

package/dist/commands/memory-store.js

@@ -45,8 +45,7 @@
 import { runMemoryMap } from "./memory-map.js";
 import { runMemoryRepeats } from "./memory-repeats.js";
 import { runMemoryRules } from "./memory-rules.js";
-import { memoryProjectPrefix } from "./memory-project-label.js";
-import { oneLine, printSearchRows } from "./memory-search-print.js";
+import { oneLine, writeRecentContext, writeSearchResults } from "./memory-search-print.js";
 import { memorySaveOutsideRoots } from "@bli-cockpit/memory-mcp/dist/recorded-outside-roots.js";
 import { resolveContainerTag } from "@bli-cockpit/memory-mcp/dist/container-tag.js";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
@@ -169,9 +168,8 @@ function containerTagsFor(command) {
         return command.containerTags;
     return [resolveContainerTag({ cwd: command.workspace ?? process.cwd() }).containerTag];
 }
-async function searchMemory(command, door) {
-    const containerTags = containerTagsFor(command);
-    const requestBody = {
+function searchRequestBody(command, containerTags) {
+    return {
         query: command.query,
         containerTag: containerTags,
         ...(command.limit === undefined ? {} : { limit: command.limit }),
@@ -181,6 +179,10 @@ async function searchMemory(command, door) {
         // BLI-19255: absent lets the door decide by the question.
         ...(command.includeSource === undefined ? {} : { includeSource: command.includeSource }),
     };
+}
+async function searchMemory(command, door) {
+    const containerTags = containerTagsFor(command);
+    const requestBody = searchRequestBody(command, containerTags);
     const answer = await readThroughCache({
         io: door.io,
         homeDir: door.homeDir,
@@ -219,30 +221,9 @@ async function searchMemory(command, door) {
     if (answer.fromCache) {
         writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
     }
-    if (results.length === 0 && body.degraded) {
-        // BLI-10448: an empty answer from a search that lost a channel is NOT the
-        // record being silent. `semantic_timed_out` is the store answering on
-        // keywords alone after its vector search ran out of time, and saying
-        // "the record is silent" over it sends a person away from memories that
-        // exist.
-        writeLine(door.io.stdout, `No memories matched on the channels that answered, and one did not (${body.degraded}). Do not read this as the record being silent; ask again.`);
-    }
-    else if (results.length === 0) {
-        // The distinction the whole store is built on: silence is not an outage.
-        // A failure took the `!answer.ok` branch above and named itself there.
-        writeLine(door.io.stdout, "No memories matched. The record is silent on this — it does not mean the store is down.");
-    }
-    else {
-        printSearchRows(door.io.stdout, results);
-    }
-    if (recent.length > 0) {
-        writeLine(door.io.stdout, "");
-        writeLine(door.io.stdout, "Recent context:");
-        for (const row of recent) {
-            const author = typeof row["savedBy"] === "string" && row["savedBy"] ? `(from ${row["savedBy"]}) ` : "";
-            writeLine(door.io.stdout, `  - ${memoryProjectPrefix(row)}${row["project"] ? "" : author}${oneLine(row["preview"] ?? row["memory"])}`);
-        }
-    }
+    writeSearchResults(door.io.stdout, results, body.degraded);
+    if (recent.length > 0)
+        writeRecentContext(door.io.stdout, recent);
     if (body.degraded) {
         writeLine(door.io.stdout, "");
         writeLine(door.io.stdout, `This answer is thinner than usual (${body.degraded}) — one search channel did not run.`);
@@ -289,6 +270,10 @@ async function saveMemory(command, door) {
     })}`);
     if (door.json)
         return emitAgentDoor(door, answer.body);
+    writeSavedMemory(door, saved, containerTag);
+    return 0;
+}
+function writeSavedMemory(door, saved, containerTag) {
     // The container the SERVER used, which is the canonical one when this
     // repository has more than one tag on the shelf; saying the tag we sent
     // would name a space the row is not in.
@@ -300,7 +285,6 @@ async function saveMemory(command, door) {
     if (saved["extract"] === "fell_back_verbatim") {
         writeLine(door.io.stdout, `Saved as written; extraction failed (${String(saved["extractFailureReason"] ?? "unknown")}).`);
     }
-    return 0;
 }
 async function updateMemory(command, door) {
     const body = await readBody(command, door, BODY_MAX_CHARS, "A memory");

package/dist/commands/memory-verb-list.js

@@ -11,6 +11,54 @@
  * Every string moved verbatim.
  */
 import { writeLine } from "./cli-io.js";
+/** The human page: what the noun does, one screen. */
+const VERB_LIST_LINES = [
+    "cockpit memory — BLI Memory: the store, and this machine's registration.",
+    "",
+    "The store (Tower, over /api/memory/*):",
+    "  cockpit memory search \"<question>\" [--container <tag>] [--limit 1..20] [--no-recent] [--include-originals|--no-originals] [--include-source|--no-source] [--json]",
+    "  cockpit memory save [--container <tag>] [--custom-id <id>] [--extract] [--file <path>] [--json]",
+    "      the memory comes from stdin, or --file; never from the command line",
+    "  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]",
+    "      you can forget or update only your own memories (a super admin, any)",
+    "  cockpit memory private <id> [--json]       only you and super admins can read this memory",
+    "  cockpit memory public <id> [--json]        every member can read it again (how every memory starts)",
+    "  cockpit memory map [--json]",
+    "  cockpit memory repeats [--project <name-or-slug>] [--min 2..50] [--limit 1..200] [--json]",
+    "      subjects a person corrected an agent about, or ordered with emphasis, more than once",
+    "  cockpit memory rules [--person <name>] [--project <name-or-slug>] [--limit <n>] [--per-project <n>] [--machine] [--json]",
+    "  cockpit memory knowledge [--person <name>] [--project <name-or-slug>] [--limit <n>] [--per-project <n>] [--machine] [--json]",
+    "      plain sentences per project; --per-project 1..100 (default 15) is each project's own",
+    "      quota, --limit 1..1000 caps the ideas in all; --machine prints the agent wording with",
+    "      scores and spaces; --json is the whole answer, both wordings (--by-project is accepted)",
+    "  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 chain <id> [--json]",
+    "  cockpit memory exam [--night <YYYY-MM-DD>] [--misses] [--json]",
+    "      the nightly memory exam: purity, coverage, trend and worst project; yours alone",
+    "  cockpit memory source <id> [--query \"<words>\"] [--chars 200..6000] [--json]",
+    "      the memories the nightly pass folded into this one: who, when, what they said",
+    "  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",
+    "  cockpit memory status [--json]                read the stored config back",
+    "",
+    "The experience log:",
+    "  cockpit memory log <win|loss|noise> --store <bli|supermemory|both> \"<reason>\"",
+    "",
+    "Search: --limit caps the MEMORIES (default 5, at most 20). Up to 3 Tower pages and",
+    "tickets ride beside them whatever --limit says; for more, use `cockpit search`.",
+    "Save accepts repeated --alias names (up to 16 names of 64 characters).",
+    "Omit --container and this repository's own memory space is used — the same",
+    "space the bli-memory MCP server and its hooks read and write.",
+];
 /**
  * The verb list a bare `cockpit memory` prints (BLI-4047).
  *
@@ -31,54 +79,7 @@ export function runMemoryVerbList(io, json) {
         }));
         return 0;
     }
-    for (const line of [
-        "cockpit memory — BLI Memory: the store, and this machine's registration.",
-        "",
-        "The store (Tower, over /api/memory/*):",
-        "  cockpit memory search \"<question>\" [--container <tag>] [--limit 1..20] [--no-recent] [--include-originals|--no-originals] [--include-source|--no-source] [--json]",
-        "  cockpit memory save [--container <tag>] [--custom-id <id>] [--extract] [--file <path>] [--json]",
-        "      the memory comes from stdin, or --file; never from the command line",
-        "  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]",
-        "      you can forget or update only your own memories (a super admin, any)",
-        "  cockpit memory private <id> [--json]       only you and super admins can read this memory",
-        "  cockpit memory public <id> [--json]        every member can read it again (how every memory starts)",
-        "  cockpit memory map [--json]",
-        "  cockpit memory repeats [--project <name-or-slug>] [--min 2..50] [--limit 1..200] [--json]",
-        "      subjects a person corrected an agent about, or ordered with emphasis, more than once",
-        "  cockpit memory rules [--person <name>] [--project <name-or-slug>] [--limit <n>] [--per-project <n>] [--machine] [--json]",
-        "  cockpit memory knowledge [--person <name>] [--project <name-or-slug>] [--limit <n>] [--per-project <n>] [--machine] [--json]",
-        "      plain sentences per project; --per-project 1..100 (default 15) is each project's own",
-        "      quota, --limit 1..1000 caps the ideas in all; --machine prints the agent wording with",
-        "      scores and spaces; --json is the whole answer, both wordings (--by-project is accepted)",
-        "  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 chain <id> [--json]",
-        "  cockpit memory exam [--night <YYYY-MM-DD>] [--misses] [--json]",
-        "      the nightly memory exam: purity, coverage, trend and worst project; yours alone",
-        "  cockpit memory source <id> [--query \"<words>\"] [--chars 200..6000] [--json]",
-        "      the memories the nightly pass folded into this one: who, when, what they said",
-        "  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",
-        "  cockpit memory status [--json]                read the stored config back",
-        "",
-        "The experience log:",
-        "  cockpit memory log <win|loss|noise> --store <bli|supermemory|both> \"<reason>\"",
-        "",
-        "Search: --limit caps the MEMORIES (default 5, at most 20). Up to 3 Tower pages and",
-        "tickets ride beside them whatever --limit says; for more, use `cockpit search`.",
-        "Save accepts repeated --alias names (up to 16 names of 64 characters).",
-        "Omit --container and this repository's own memory space is used — the same",
-        "space the bli-memory MCP server and its hooks read and write.",
-    ]) {
+    for (const line of VERB_LIST_LINES)
         writeLine(io.stdout, line);
-    }
     return 0;
 }

package/dist/commands/msg-read-line.js

@@ -0,0 +1,32 @@
+/**
+ * The read line, from a terminal (BLI-21299), split out of `msg.ts` to keep it
+ * under the file-size ratchet: the two fields every channel read now carries
+ * (`provenance`, `readBoundary`) and the `read --mark-read` step. The web page,
+ * MCP `msg_read` `mark_read` and this all call `POST /api/msg/channels/[id]/read`.
+ */
+import { askAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[msg cli]";
+const WRITE_DEADLINE_MS = 30_000;
+/** POST the read line to the newest top-level message of a page just read (newest first). */
+export async function markReadThrough(door, channelId, messages) {
+    const newest = messages.find((message) => !message.thread_parent_id);
+    if (!newest) {
+        writeLine(door.io.stderr, `${TAG} mark-read skipped ${JSON.stringify({ channel_id: channelId, reason: "nothing_to_mark" })}`);
+        return { ok: false, reason: "nothing_to_mark", detail: "There was no top-level message on this page to mark read." };
+    }
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(channelId)}/read`,
+        method: "POST",
+        label: "msg mark-read",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { message_id: newest.id },
+    });
+    if (!answer.ok) {
+        writeLine(door.io.stderr, `${TAG} mark-read failed ${JSON.stringify({ channel_id: channelId, reason: answer.reason })}`);
+        return { ok: false, reason: answer.reason, detail: answer.detail };
+    }
+    const changed = answer.body.move?.changed === true;
+    writeLine(door.io.stderr, `${TAG} mark-read ${JSON.stringify({ channel_id: channelId, message_id: newest.id, changed })}`);
+    return { ok: true, messageId: newest.id, changed };
+}