@bli-cockpit/cli 0.2.222 → 0.2.236

package/dist/commands/logs.js

@@ -18,6 +18,7 @@ import { asRecord, callTower, openTower, writeCommandFailure } from "./tower-com
 import { getCollectorRuntimePaths } from "../local-state-paths.js";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { runStoredLogs, storedProject } from "./logs-stored.js";
+import { runLogsSearch } from "./logs-search.js";
 const TAG = "[logs cli]";
 const MAX_STDIN_CHARS = 64 * 1024 * 1024;
 function refuse(io, json, reason, detail) {
@@ -38,6 +39,8 @@ export async function runLogs(command, io, deps = {}) {
         writeLine(io.stdout, command.json ? JSON.stringify(result.body) : String(asRecord(result.body).key));
         return 0;
     }
+    if (command.search)
+        return runLogsSearch(command, io);
     // BLI-12855: a project name (or --stored, or --list) reads the digests Tower's cron stored, not a local log.
     const stored = storedProject(command);
     if (command.list || stored)

package/dist/commands/memory-exam.js

@@ -0,0 +1,47 @@
+/**
+ * `cockpit memory exam` - the nightly memory exam score (BLI-19249).
+ *
+ * A READ of `GET /api/memory/exam`, with this machine's device token, through `agent-door.ts`: the same door the
+ * `memory_exam` MCP tool calls. The exam itself is a step of the nightly `memory-consolidate` Railway job. Output: the
+ * one line (purity, graded of planned, trend, worst project); `--misses` adds the missed questions with their reason
+ * label, true answer and fix status. The rows are the owner's own words, so no one else reads them, a super admin
+ * included; a caller with no exam gets `no exam yet`, never somebody else's night. Logs carry counts only.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[memory cli]";
+const READ_DEADLINE_MS = 30_000;
+export async function runMemoryExam(command, door) {
+    const params = new URLSearchParams();
+    if (command.night)
+        params.set("night", command.night);
+    if (command.misses)
+        params.set("misses", "1");
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    const answer = await askAgentDoor(door, { path: `/api/memory/exam${query}`, method: "GET", label: "memory exam", timeoutMs: READ_DEADLINE_MS });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(door.io.stderr, `${TAG} exam ${JSON.stringify({ reason: body.reason ?? "exam_read", night: body.latest?.night ?? null, previous_nights: body.previous?.length ?? 0, misses: body.misses?.length ?? null })}`);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    if (!body.latest || !body.line) {
+        writeLine(door.io.stdout, body.reason === "night_not_found"
+            ? `No exam is recorded for ${command.night ?? "that night"}.`
+            : "No memory exam yet. It runs as the last step of the nightly memory-consolidate job; nothing has been recorded for you.");
+        return 0;
+    }
+    const { latest } = body;
+    writeLine(door.io.stdout, body.line);
+    for (const detail of body.detail ?? [])
+        writeLine(door.io.stdout, detail);
+    const reasons = Object.entries(latest.missReasons ?? {}).map(([label, count]) => `${label} ${count}`).join(", ");
+    writeLine(door.io.stdout, `Mode ${latest.mode ?? "report"}; spent $${Number(latest.costUsd ?? 0).toFixed(4)}; misses: ${reasons || "none"}.`);
+    for (const miss of body.misses ?? []) {
+        writeLine(door.io.stdout, `  #${miss.ordinal ?? "?"} [${miss.source ?? "?"}${miss.project ? ` / ${miss.project}` : ""}] ${miss.reason ?? "no reason"}${miss.fixStatus ? ` (${miss.fixKind ?? "fix"}: ${miss.fixStatus})` : ""}`);
+        writeLine(door.io.stdout, `      asked: ${miss.question ?? ""}`);
+        writeLine(door.io.stdout, `      truth: ${miss.expected ?? ""}`);
+        writeLine(door.io.stdout, `      said:  ${miss.answer ?? "(no answer)"}`);
+    }
+    return 0;
+}

package/dist/commands/memory-repeats.js

@@ -0,0 +1,44 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { optionalNonEmpty, optionalUrl, parseNamedArgs } from "./local-arg-values.js";
+/** A whole number inside a range, or a refusal that names the flag. */
+function bounded(flag, raw, min, max) {
+    if (raw === undefined)
+        return undefined;
+    if (!/^\d+$/.test(raw) || Number(raw) < min || Number(raw) > max)
+        throw new Error(`${flag} must be between ${min} and ${max}.`);
+    return Number(raw);
+}
+/** BLI-19253: `cockpit memory repeats [--project <name>] [--min <n>] [--limit <n>] [--json]`. */
+export function parseMemoryRepeatsArgs(args) {
+    const values = parseNamedArgs(args, { allowedFlags: ["--project", "--min", "--limit", "--json", "--home", "--dashboard-url"], valueFlags: ["--project", "--min", "--limit", "--home", "--dashboard-url"] });
+    if (values.positionals.slice(1).length)
+        throw new Error("memory repeats takes no positionals; use --project, --min and --limit.");
+    return { kind: "memory-store", action: "repeats", containerTags: [], project: optionalNonEmpty(values.flags.get("--project")),
+        minCount: bounded("--min", values.flags.get("--min"), 2, 50), limit: bounded("--limit", values.flags.get("--limit"), 1, 200), json: values.booleans.has("--json"),
+        homeDir: optionalNonEmpty(values.flags.get("--home")), dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")) };
+}
+export async function runMemoryRepeats(command, door) {
+    const params = new URLSearchParams();
+    if (command.project)
+        params.set("project", command.project);
+    if (command.minCount !== undefined)
+        params.set("min", String(command.minCount));
+    if (command.limit !== undefined)
+        params.set("limit", String(command.limit));
+    const query = params.toString();
+    const answer = await askAgentDoor(door, { method: "GET", path: `/api/memory/repeats${query ? `?${query}` : ""}`, label: "memory repeats", timeoutMs: 60_000 });
+    if (!answer.ok)
+        return failAgentDoor(door, "[memory repeats cli]", answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(door.io.stderr, `[memory repeats cli] answered ${JSON.stringify({ reason: body.capped ? "capped" : "exhausted", requested: body.requested, returned: body.returned })}`);
+    if (door.json)
+        return emitAgentDoor(door, body);
+    writeLine(door.io.stdout, body.words);
+    for (const repeat of body.repeats)
+        writeLine(door.io.stdout, `- ${repeat.line}${repeat.project ? ` [${repeat.project}]` : ""}`);
+    for (const row of body.coverage)
+        writeLine(door.io.stdout, `${row.label}: ${row.labelled.toLocaleString("en-US")} memories, ${row.grouped.toLocaleString("en-US")} grouped by subject`);
+    writeLine(door.io.stdout, `As of ${body.asOf}.${body.capped ? " Result capped; raise --limit (max 200)." : ""}`);
+    return 0;
+}

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

@@ -0,0 +1,95 @@
+/**
+ * How `cockpit memory search` prints its rows (split out of `memory-store.ts`, which is at the file-length ceiling).
+ *
+ * A merged memory prints its originals under it (BLI-19246); an original found by an exact-detail question prints as
+ * its own row, tagged. One already printed as its own row is not repeated under its merged sentence.
+ */
+import { memoryProjectPrefix } from "./memory-project-label.js";
+import { writeLine } from "./cli-io.js";
+/** One terminal line: newlines folded, so a long memory cannot break the listing. */
+export function oneLine(value) {
+    return String(value ?? "").replace(/\s+/g, " ").trim();
+}
+/** `[87%] ` when the row was found by meaning, empty when it was a keyword hit. */
+function similarityLabel(row) {
+    const channels = row["channels"];
+    if (Array.isArray(channels) && !channels.includes("semantic"))
+        return "";
+    const similarity = Number(row["similarity"]);
+    return Number.isFinite(similarity) && similarity >= 0 && similarity <= 1
+        ? `[${Math.round(similarity * 100)}%] `
+        : "";
+}
+/**
+ * BLI-12927: memory is public across the team, so a hit can be a teammate's.
+ * `  filed by Edward on 2026-09-14` ahead of nothing when it is the caller's own.
+ */
+function filedByLabel(row) {
+    const name = typeof row["savedBy"] === "string" ? row["savedBy"].trim() : "";
+    if (!name)
+        return "";
+    const filed = typeof row["createdAt"] === "string" ? new Date(row["createdAt"]) : null;
+    const day = filed && !Number.isNaN(filed.getTime()) ? filed.toISOString().slice(0, 10) : null;
+    return day ? `  filed by ${name} on ${day}` : `  filed by ${name}`;
+}
+/** `, true from 2026-07-01 to 2026-09-01`, or nothing when the door sent no window. */
+function windowText(row) {
+    return typeof row["window"] === "string" && row["window"] ? `, ${row["window"]}` : "";
+}
+export function printSearchRows(out, results) {
+    const printed = new Set(results.filter((entry) => entry["original"] === true || entry["earlierVersion"] === true).map((entry) => String(entry["id"])));
+    for (const row of results) {
+        const head = row["original"] === true
+            ? `(original, merged into ${String(row["successorId"] ?? "?")}) `
+            : row["earlierVersion"] === true
+                // BLI-19247: a fact a newer one replaced, with when it was true.
+                ? `(earlier version${windowText(row)}, replaced by ${String(row["successorId"] ?? "?")}) `
+                : similarityLabel(row);
+        writeLine(out, `${head}${memoryProjectPrefix(row)}${oneLine(row["memory"])}`);
+        writeLine(out, `    ${String(row["id"] ?? "")}  ${String(row["containerTag"] ?? "")}${filedByLabel(row)}`);
+        printOriginals(out, row, printed);
+        printSource(out, row["source"], "    ");
+    }
+}
+/** Why a source gave no text, in words (BLI-19255). */
+const SOURCE_STATUS_WORDS = {
+    no_pointer: "this memory names no source",
+    unsupported_source: "it was imported from another store, so there is no raw source here",
+    needs_rls_client: "no session the database can attribute to you; run `cockpit login` again",
+    not_readable: "the source belongs to someone else and you may not read it",
+    missing: "the source is no longer available",
+    too_large: "the stored session is too large to read for an excerpt",
+    redaction_stub: "only a redaction stub was stored for that session",
+    fact_not_found: "the source was read and does not contain this fact",
+    budget: "reading the source ran out of time",
+    read_failed: "the archive did not answer",
+};
+/** The verbatim stretch of the raw session or note behind a memory, or the reason there is none (BLI-19255). */
+export function printSource(out, source, indent) {
+    if (!source)
+        return;
+    const excerpt = (source["excerpt"] ?? null);
+    if (source["status"] !== "excerpt" || !excerpt) {
+        writeLine(out, `${indent}source not shown: ${SOURCE_STATUS_WORDS[String(source["status"])] ?? String(source["status"])}.`);
+        return;
+    }
+    const kind = source["type"] === "meeting_note" ? "meeting note" : "session";
+    writeLine(out, `${indent}source, verbatim from the ${kind} (lines ${String(excerpt["startLine"])}-${String(excerpt["endLine"])} of ${String(excerpt["totalLines"])}):`);
+    for (const line of String(excerpt["text"] ?? "").split("\n"))
+        writeLine(out, `${indent}  | ${line}`);
+}
+function printOriginals(out, row, alreadyPrinted) {
+    const originals = Array.isArray(row["originals"]) ? row["originals"] : [];
+    const fresh = originals.filter((original) => !alreadyPrinted.has(String(original["id"])));
+    if (fresh.length === 0)
+        return;
+    const merged = Number(row["consolidatedFrom"] ?? 0);
+    writeLine(out, merged > 0 ? `    merged from ${merged} memories; originals, for exact details:` : "    earlier versions, replaced by this one:");
+    for (const original of fresh) {
+        const earlier = original["kind"] === "earlier_version" ? `[earlier version${windowText(original)}] ` : "";
+        writeLine(out, `      - ${earlier}${oneLine(original["memory"])}  (${String(original["id"] ?? "")})`);
+    }
+    const hidden = (row["originalsHidden"] ?? {});
+    if (Number(hidden["private"] ?? 0) > 0)
+        writeLine(out, `      (${String(hidden["private"])} private original(s) not shown)`);
+}

package/dist/commands/memory-source.js

@@ -0,0 +1,39 @@
+/**
+ * `cockpit memory source <id> [--query "<words>"] [--chars 200..6000]` (BLI-19255): the raw session or meeting
+ * behind a memory, as a bounded verbatim excerpt.
+ *
+ * Memory is an index over the archive. A READ over `GET /api/memory/source`, the same door the `memory_source` MCP
+ * tool calls, with this machine's device token. The door follows the memory's own source pointer and returns the
+ * stretch of the stored transcript or note around the fact, as stored (redaction unchanged), or the reason there is
+ * none (`not_readable`, `missing`, `too_large`, ...). It reads only what your own session may read and writes nothing.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { printSource } from "./memory-search-print.js";
+const TAG = "[memory cli]";
+const READ_DEADLINE_MS = 30_000;
+export async function runMemorySource(command, door) {
+    if (!command.memoryId) {
+        return failAgentDoor(door, TAG, "id_required", "memory source needs the memory id `cockpit memory search` printed.");
+    }
+    const params = new URLSearchParams({ id: command.memoryId });
+    if (command.sourceQuery)
+        params.set("query", command.sourceQuery);
+    if (command.sourceChars !== undefined)
+        params.set("chars", String(command.sourceChars));
+    const answer = await askAgentDoor(door, {
+        path: `/api/memory/source?${params.toString()}`,
+        method: "GET",
+        label: "memory source",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    // Status and sizes only: a source's text never enters a log line.
+    writeLine(door.io.stderr, `${TAG} source ${JSON.stringify({ status: body.source?.status ?? null, type: body.source?.type ?? null, chars: body.source?.excerpt?.chars ?? 0 })}`);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    printSource(door.io.stdout, body.source, "");
+    return 0;
+}

package/dist/commands/memory-store.js

@@ -43,13 +43,17 @@
  * newline in it cannot be quoted correctly anyway.
  */
 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 { 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";
 import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { runMemoryChain } from "./memory-chain.js";
+import { runMemoryExam } from "./memory-exam.js";
+import { runMemorySource } from "./memory-source.js";
 import { runMemoryConsolidation } from "./memory-consolidation.js";
 import { cacheAgeLabel, cacheCoverage, readThroughCache } from "./read-cache.js";
 import { runMemoryRequeue } from "./memory-requeue.js";
@@ -69,6 +73,9 @@ export async function runMemoryStore(command, io) {
     switch (command.action) {
         case "map":
             return runMemoryMap(door);
+        case "repeats":
+            // BLI-19253: subjects people corrected or ordered more than once. Its own module and door.
+            return runMemoryRepeats(command, door);
         case "knowledge":
         case "rules":
             return runMemoryRules(command, door);
@@ -90,6 +97,12 @@ export async function runMemoryStore(command, io) {
             return runMemoryRequeue(command, io);
         case "chain":
             return runMemoryChain(command, door);
+        case "exam":
+            // BLI-19249. Its own module: the nightly memory exam score, owner-only.
+            return runMemoryExam(command, door);
+        case "source":
+            // BLI-19255: the raw session or meeting behind a memory. Its own module, a different door and shape.
+            return runMemorySource(command, door);
         case "private":
         case "public":
             // BLI-12927: the narrowing switch. Its own module, so this file stays
@@ -163,6 +176,10 @@ async function searchMemory(command, door) {
         containerTag: containerTags,
         ...(command.limit === undefined ? {} : { limit: command.limit }),
         includeProfile: command.includeRecent !== false,
+        // BLI-19246: absent lets the door decide by the question.
+        ...(command.includeOriginals === undefined ? {} : { includeOriginals: command.includeOriginals }),
+        // BLI-19255: absent lets the door decide by the question.
+        ...(command.includeSource === undefined ? {} : { includeSource: command.includeSource }),
     };
     const answer = await readThroughCache({
         io: door.io,
@@ -216,10 +233,7 @@ async function searchMemory(command, door) {
         writeLine(door.io.stdout, "No memories matched. The record is silent on this — it does not mean the store is down.");
     }
     else {
-        for (const row of results) {
-            writeLine(door.io.stdout, `${similarityLabel(row)}${memoryProjectPrefix(row)}${oneLine(row["memory"])}`);
-            writeLine(door.io.stdout, `    ${String(row["id"] ?? "")}  ${String(row["containerTag"] ?? "")}${filedByLabel(row)}`);
-        }
+        printSearchRows(door.io.stdout, results);
     }
     if (recent.length > 0) {
         writeLine(door.io.stdout, "");
@@ -382,30 +396,4 @@ async function readBody(command, door, maxChars, what) {
             detail: error instanceof Error ? error.message : String(error),
         };
     }
-}
-/** `[87%] ` when the row was found by meaning, empty when it was a keyword hit. */
-function similarityLabel(row) {
-    const channels = row["channels"];
-    if (Array.isArray(channels) && !channels.includes("semantic"))
-        return "";
-    const similarity = Number(row["similarity"]);
-    return Number.isFinite(similarity) && similarity >= 0 && similarity <= 1
-        ? `[${Math.round(similarity * 100)}%] `
-        : "";
-}
-/**
- * BLI-12927: memory is public across the team, so a hit can be a teammate's.
- * `  filed by Edward on 2026-09-14` ahead of nothing when it is the caller's own.
- */
-function filedByLabel(row) {
-    const name = typeof row["savedBy"] === "string" ? row["savedBy"].trim() : "";
-    if (!name)
-        return "";
-    const filed = typeof row["createdAt"] === "string" ? new Date(row["createdAt"]) : null;
-    const day = filed && !Number.isNaN(filed.getTime()) ? filed.toISOString().slice(0, 10) : null;
-    return day ? `  filed by ${name} on ${day}` : `  filed by ${name}`;
-}
-/** One terminal line: newlines folded, so a long memory cannot break the listing. */
-function oneLine(value) {
-    return String(value ?? "").replace(/\s+/g, " ").trim();
 }

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

@@ -26,7 +26,7 @@ export function runMemoryVerbList(io, json) {
             ok: true,
             noun: "memory",
             machine_verbs: ["install", "status"],
-            store_verbs: ["rules", "knowledge", "search", "save", "update", "forget", "private", "public", "profile", "consolidation", "chain", "requeue"],
+            store_verbs: ["rules", "knowledge", "search", "save", "update", "forget", "private", "public", "profile", "consolidation", "chain", "source", "exam", "requeue"],
             log_verbs: ["log"],
         }));
         return 0;
@@ -35,7 +35,7 @@ export function runMemoryVerbList(io, json) {
         "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] [--json]",
+        "  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",
@@ -45,6 +45,8 @@ export function runMemoryVerbList(io, json) {
         "  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",
@@ -55,6 +57,9 @@ export function runMemoryVerbList(io, json) {
         "  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",

package/dist/commands/notes-reads.js

@@ -107,6 +107,21 @@ export async function listShelves(command, door) {
     }
     return 0;
 }
+/** One line per claim with its citations: `- text [s12 Ada 00:03:04]`. */
+export function renderCitedSummary(summary) {
+    const lines = [`Summary v${summary.version} (${summary.supported} cited claims, ${summary.dropped} dropped as unsupported or uncited)`];
+    for (const [kind, heading] of [["decision", "Decisions"], ["action_item", "Action items"], ["key_point", "Key points"]]) {
+        const items = summary.items.filter((item) => item.kind === kind);
+        if (items.length === 0)
+            continue;
+        lines.push("", `${heading}:`);
+        for (const item of items) {
+            const cites = item.citations.map((c) => `${c.segment_id} ${c.speaker}${c.at ? ` ${c.at}` : ""}`).join("; ");
+            lines.push(`- ${item.owner ? `${item.owner}: ` : ""}${item.text} [${cites}]`);
+        }
+    }
+    return lines;
+}
 /** `?offset=&limit=` for `notes show`: characters, like `docs read` (BLI-18006). */
 function showQuery(command) {
     const query = new URLSearchParams();
@@ -149,6 +164,11 @@ export async function showNote(command, door) {
         const { offset, returnedChars, totalChars, nextOffset } = body.slice;
         writeLine(door.io.stdout, `Characters ${offset}-${offset + returnedChars} of ${totalChars}${nextOffset === null ? " (the end)" : `; continue with --offset ${nextOffset}`}.`);
     }
+    if (body.summary && body.summary.items.length > 0) {
+        writeLine(door.io.stdout, "");
+        for (const line of renderCitedSummary(body.summary))
+            writeLine(door.io.stdout, line);
+    }
     writeLine(door.io.stdout, "");
     writeLine(door.io.stdout, note.content.replace(/^In the room:/gm, "Invited:"));
     return 0;

package/dist/commands/notes-writes.js

@@ -205,6 +205,30 @@ export async function shareNote(command, door) {
     sayUpload(door, body);
     return 0;
 }
+/** A summary run is two model calls over a long transcript: give it room (BLI-20882). */
+const SUMMARIZE_DEADLINE_MS = 330_000;
+/**
+ * `cockpit notes summarize <note-id>` (BLI-20882): write a new summary where every decision,
+ * action item and key point cites the speaker, timestamp and segment id it came from. A claim
+ * the transcript does not support is dropped. Earlier summaries are kept as older versions.
+ */
+export async function summarizeNote(command, door) {
+    const answer = await ask(door, {
+        path: `/api/notes/library/${encodeURIComponent(command.noteId ?? "")}/summary`,
+        method: "POST",
+        label: "notes summarize",
+        timeoutMs: SUMMARIZE_DEADLINE_MS,
+        body: {},
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(door.io.stderr, `${TAG} summarize answered ${JSON.stringify({ note_id: command.noteId ?? null, status: body.status ?? null })}`);
+    if (door.json)
+        return emit(door, body);
+    writeLine(door.io.stdout, body.text ?? body.message ?? "Tower answered without a summary.");
+    return 0;
+}
 /**
  * `cockpit notes place <note-id> [--apply]` — BLI-4058.
  *

package/dist/commands/notes.js

@@ -43,7 +43,7 @@
  */
 import { loadPairedSession } from "../tower-client.js";
 import { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
-import { uploadNotes, pasteNote, shareNote, moveNote, placeNote } from "./notes-writes.js";
+import { uploadNotes, pasteNote, shareNote, summarizeNote, moveNote, placeNote } from "./notes-writes.js";
 import { runFolderCommand } from "./notes-folders.js";
 import { armNotesWebhook, connectNotetaker, detachNotetaker, listNotesAccounts, showNotesWebhook, syncNotetaker, syncStatusNotetakers, } from "./notes-accounts.js";
 import { showBotUpcoming } from "./notes-bot-upcoming.js";
@@ -51,7 +51,7 @@ import { showGranolaStatus } from "./notes-granola-status.js";
 import { showTranscriptionStats } from "./notes-transcription-stats.js";
 import { listRecordings, showRecording } from "./notes-recordings.js";
 export { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
-export { uploadNotes, pasteNote, shareNote, moveNote, placeNote } from "./notes-writes.js";
+export { uploadNotes, pasteNote, shareNote, summarizeNote, moveNote, placeNote } from "./notes-writes.js";
 export { armNotesWebhook, connectNotetaker, detachNotetaker, listNotesAccounts, showNotesWebhook, syncNotetaker, syncStatusNotetakers, } from "./notes-accounts.js";
 export { showGranolaStatus } from "./notes-granola-status.js";
 export { showTranscriptionStats } from "./notes-transcription-stats.js";
@@ -86,6 +86,8 @@ export async function runNotes(command, io) {
         case "share":
         case "unshare":
             return shareNote(command, door);
+        case "summarize":
+            return summarizeNote(command, door);
         case "move":
             return moveNote(command, door);
         case "place":

package/dist/commands/people.js

@@ -0,0 +1,29 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[people cli]";
+const READ_DEADLINE_MS = 30_000;
+export async function runPeople(command, io) {
+    let door;
+    try {
+        door = await openAgentDoor("people", command, io);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : "this machine is not paired with Tower";
+        writeLine(io.stderr, `${TAG} refused ${JSON.stringify({ reason: "not_paired" })}`);
+        if (command.json)
+            writeLine(io.stdout, JSON.stringify({ ok: false, error: "not_paired", detail }));
+        else
+            writeLine(io.stderr, detail);
+        return 1;
+    }
+    const path = command.person ? `/api/people?${new URLSearchParams({ person: command.person }).toString()}` : "/api/people";
+    const answer = await askAgentDoor(door, { path, method: "GET", label: "people show", timeoutMs: READ_DEADLINE_MS });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    writeLine(io.stderr, `${TAG} answered ${JSON.stringify({ view: command.person ? "person" : "list", people: body.people?.length ?? 1 })}`);
+    if (command.json)
+        return emitAgentDoor(door, body);
+    writeLine(io.stdout, body.text);
+    return 0;
+}

package/dist/commands/public-root.js

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

package/dist/commands/spend.js

@@ -0,0 +1,79 @@
+/**
+ * `cockpit spend memory [--days 1|7|30] [--json]`: what each memory operation cost, held against the real OpenAI
+ * bill (BLI-19254).
+ *
+ * One read of `GET /api/ops/memory-spend`, the same door the `spend_memory` MCP tool and JARVIS call. The
+ * terminal prints the operations ranked by list dollars, top first, with real dollars, share of the ledger, the
+ * trend against the previous window, and then how much of OpenAI's own bill the ledger explains and what it does
+ * not (`untagged`, never hidden). `--json` prints the door's body untouched.
+ *
+ * A super_admin reads it; anyone else gets the door's own refusal reason, printed verbatim by `failAgentDoor`.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { optionalNonEmpty, optionalUrl, parseNamedArgs } from "./local-arg-values.js";
+const USAGE = "Usage: cockpit spend memory [--days 1|7|30] [--dashboard-url <url>] [--json]";
+export function parseSpendArgs(args) {
+    const values = parseNamedArgs(args, { allowedFlags: ["--days", "--json", "--home", "--dashboard-url"], valueFlags: ["--days", "--home", "--dashboard-url"] });
+    const [action, ...rest] = values.positionals;
+    if (action !== "memory" || rest.length > 0)
+        throw new Error(USAGE);
+    const raw = values.flags.get("--days");
+    const days = raw === undefined ? 7 : Number(raw);
+    if (days !== 1 && days !== 7 && days !== 30)
+        throw new Error(`--days must be 1, 7 or 30. ${USAGE}`);
+    return { kind: "spend", action: "memory", days, json: values.booleans.has("--json"), homeDir: optionalNonEmpty(values.flags.get("--home")), dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")) };
+}
+const usd = (value) => (value === null || value === undefined ? "n/a" : value.toFixed(value >= 100 ? 0 : 2));
+const money = (value) => (value === null || value === undefined ? "n/a" : `$${usd(value)}`);
+const trend = (value) => (value === null ? "new" : `${value >= 0 ? "+" : ""}${value}%`);
+const millions = (tokens) => `${(tokens / 1e6).toFixed(1)}M`;
+export function renderMemorySpend(body) {
+    const lines = [];
+    const { window } = body;
+    lines.push(`Tower memory spend, last ${window.days} day${window.days === 1 ? "" : "s"} (${window.from} to ${window.to} UTC), as of ${body.asOf.slice(11, 16)}Z. Today is partial; trend is against the ${window.days} day${window.days === 1 ? "" : "s"} before (${window.previousFrom} to ${window.previousTo}).`);
+    if (body.operations.length === 0) {
+        lines.push("The ledger has no spend in this window yet. Live tallying starts at deploy; `backfill` rebuilds history from the older receipt tables.");
+    }
+    else {
+        const header = ["operation", "list $", "real $", "share", "vs prev", "calls", "biggest callers"];
+        const rows = body.operations.map((op) => [
+            op.operation, usd(op.listUsd), usd(op.realUsd), `${Math.round(op.share * 100)}%`, trend(op.trendPct), String(op.calls),
+            op.topCallers.map((caller) => `${caller.caller} $${usd(caller.listUsd)}`).join(", "),
+        ]);
+        rows.push(["total", usd(body.totals.listUsd), usd(body.totals.realUsd), "", trend(body.totals.trendPct), String(body.totals.calls), ""]);
+        const widths = header.map((cell, column) => Math.max(cell.length, ...rows.map((row) => row[column].length)));
+        const render = (cells) => cells.map((cell, column) => (column === 0 || column === 6 ? cell.padEnd(widths[column]) : cell.padStart(widths[column]))).join("  ").trimEnd();
+        lines.push("", render(header), ...rows.map(render));
+    }
+    const bill = body.reconcile;
+    lines.push("");
+    if (!bill.hasBill) {
+        lines.push(`OpenAI bill: not reconciled. ${bill.reason ?? "no reason recorded"}.`);
+    }
+    else {
+        lines.push(`OpenAI bill for Tower's keys over ${bill.billDays} complete day${bill.billDays === 1 ? "" : "s"} (read ${bill.billAsOf?.slice(0, 16).replace("T", " ") ?? "?"}Z): list ${money(bill.towerBillListUsd)}, real ${money(bill.towerBillRealUsd)}.`);
+        lines.push(`The ledger explains ${bill.coveragePct === null ? "n/a" : `${bill.coveragePct}%`} of it (list ${money(bill.ledgerOpenAiListUsd)}). Untagged: list ${money(bill.untaggedListUsd)}, real ${money(bill.untaggedRealUsd)}, which no tagged call accounts for.`);
+        if (bill.tokenGaps.length > 0) {
+            lines.push("Untagged input tokens by model and tier (bill minus ledger): " + bill.tokenGaps.slice(0, 5).map((gap) => `${gap.model} ${gap.tier} ${millions(gap.untaggedInputTokens)}`).join("; ") + ".");
+        }
+        if ((bill.otherAppsBillListUsd ?? 0) > 0)
+            lines.push(`Other apps on the same OpenAI org (not Tower's, not counted above): list ${money(bill.otherAppsBillListUsd)}.`);
+    }
+    if (body.reads.failures.length > 0)
+        lines.push("", `Could not read: ${body.reads.failures.join(", ")}. The rest is shown as read.`);
+    for (const note of body.notes)
+        lines.push(note);
+    return lines;
+}
+export async function runSpend(command, io) {
+    const door = await openAgentDoor("spend", command, io);
+    const answer = await askAgentDoor(door, { path: `/api/ops/memory-spend?days=${command.days}`, method: "GET", label: "spend memory", timeoutMs: 60_000 });
+    if (!answer.ok)
+        return failAgentDoor(door, "[spend cli]", answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    for (const line of renderMemorySpend(answer.body))
+        writeLine(door.io.stdout, line);
+    return 0;
+}

package/dist/commands/sync-heal-agent-plugins.js

@@ -0,0 +1,46 @@
+/**
+ * The tick's half of the company plugin install (BLI-18200). Doctor's
+ * `agent-plugins` row converges a machine when a person runs `cockpit doctor`;
+ * this puts the same plugin on a machine nobody is looking at, every 15 minutes
+ * and cheaply: a steady machine costs four file reads, a failed host waits six
+ * hours, and an installed plugin is refreshed once a day.
+ *
+ * It reports through the same install-event channel as the agent-rules heal
+ * (`agent_plugins_install`), once per real attempt, with reason labels only.
+ */
+import os from "node:os";
+import { convergeAgentPlugins } from "../agent-plugins-converge.js";
+export async function healAgentPlugins(command, io, paths, now) {
+    const exec = io.exec;
+    if (!exec) {
+        console.error("[sync-heal] agent plugins not checked; this io has no process runner", JSON.stringify({ reason: "runner_unavailable" }));
+        return null;
+    }
+    const outcomes = await convergeAgentPlugins({
+        homeDir: command.homeDir ?? os.homedir(),
+        stateDir: paths.state_dir,
+        exec,
+        unattended: true,
+        refresh: true,
+        now,
+    });
+    return eventFor(outcomes);
+}
+/** One event per real attempt; steady state, throttled retries and absent hosts report nothing. */
+export function eventFor(outcomes) {
+    const acted = outcomes.filter((outcome) => !outcome.quiet);
+    if (acted.length === 0)
+        return null;
+    const detail = acted.map((outcome) => `${outcome.host}=${outcome.reason}`).join("; ");
+    const failed = acted.find((outcome) => outcome.status === "failed");
+    if (failed)
+        return { step: "agent_plugins_install", status: "fail", error_code: failed.reason, error_detail: detail };
+    if (acted.every((outcome) => outcome.status === "skipped"))
+        return { step: "agent_plugins_install", status: "skipped", error_code: acted[0].reason, error_detail: detail };
+    const refreshOnly = acted.every((outcome) => outcome.status === "refreshed");
+    // A failed daily refresh keeps the plugin; it is still worth one line, as a skipped step.
+    const refreshFailed = acted.find((outcome) => outcome.reason.startsWith("refresh_failed_"));
+    if (refreshFailed)
+        return { step: "agent_plugins_install", status: "skipped", error_code: refreshFailed.reason, error_detail: detail };
+    return { step: refreshOnly ? "agent_plugins_refresh" : "agent_plugins_install", status: "ok", error_detail: detail };
+}