@bli-cockpit/mcp 0.1.55 → 0.1.58

package/README.md

@@ -34,7 +34,7 @@ about what an agent can reach.
 
 <!-- BEGIN GENERATED verb census — `npm run mcp:readme` -->
 
-**104 of 109 Tower verbs have an MCP twin.**
+**107 of 112 Tower verbs have an MCP twin.**
 Each tool goes through the SAME door its CLI verb calls, with the same
 collector device token — never a second route and never a service-role
 reader. `src/verb-census.test.ts` fails when a verb is in none of the
@@ -91,8 +91,11 @@ three tables below.
 | `cockpit mail search` | `mail_search` | `GET /api/mail/search` |
 | `cockpit mail send` | `mail_send` | `POST /api/mail/send` |
 | `cockpit mail sync` | `mail_sync` | `POST /api/mail/accounts/[id]/sync` |
+| `cockpit memory consolidation` | `memory_consolidation` | `GET /api/memory/consolidation` |
 | `cockpit memory forget` | `forget_memory` (`bli-memory`) | `POST /api/memory/forget` |
 | `cockpit memory log` | `memory_experience` | `POST /api/memory/experience` |
+| `cockpit memory profile` | `memory_profile` | `GET /api/memory/profile` |
+| `cockpit memory requeue` | `memory_requeue` | `POST /api/memory/requeue` |
 | `cockpit memory save` | `save_memory` (`bli-memory`) | `POST /api/memory/save` |
 | `cockpit memory search` | `search_memory` (`bli-memory`) | `POST /api/memory/search` |
 | `cockpit memory update` | `update_memory` (`bli-memory`) | `POST /api/memory/update` |

package/dist/memory-consolidation-tools.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `memory_consolidation` — the MCP twin of `cockpit memory consolidation`
+ * (BLI-4534).
+ *
+ * Same door, same device token, same answer: `GET /api/memory/consolidation`.
+ * It reads what the nightly BLI Memory tidy-up pass did — clusters looked at,
+ * edits by verb, refusals by reason, cost — and it cannot start, stop or
+ * change a pass. The pass itself is a Railway cron.
+ *
+ * It lives on `bli-tower` rather than on the `bli-memory` server that carries
+ * `search_memory`/`save_memory`/`update_memory`/`forget_memory`, because this
+ * is a read of a JOB's counts rather than a read or a write of the store.
+ *
+ * No memory text crosses this tool. The door does not send any.
+ */
+import { type ToolDeps } from "./tool-result.js";
+export declare function registerMemoryConsolidationTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: ToolDeps): void;

package/dist/memory-consolidation-tools.js

@@ -0,0 +1,53 @@
+/**
+ * `memory_consolidation` — the MCP twin of `cockpit memory consolidation`
+ * (BLI-4534).
+ *
+ * Same door, same device token, same answer: `GET /api/memory/consolidation`.
+ * It reads what the nightly BLI Memory tidy-up pass did — clusters looked at,
+ * edits by verb, refusals by reason, cost — and it cannot start, stop or
+ * change a pass. The pass itself is a Railway cron.
+ *
+ * It lives on `bli-tower` rather than on the `bli-memory` server that carries
+ * `search_memory`/`save_memory`/`update_memory`/`forget_memory`, because this
+ * is a read of a JOB's counts rather than a read or a write of the store.
+ *
+ * No memory text crosses this tool. The door does not send any.
+ */
+import { z } from "zod";
+import { callAgentDoor } from "./agent-door.js";
+import { doorFailureText, errorResult, queryString, registrarFor, textResult, withSession, } from "./tool-result.js";
+export function registerMemoryConsolidationTools(server, deps) {
+    registrarFor(server)("memory_consolidation", {
+        title: "Read the nightly memory consolidation runs",
+        description: "What the nightly BLI Memory consolidation pass did: clusters, merges/rewrites/dated corrections by verb, refusals by reason, model and cost. With a container tag it answers that space's recent runs; without one, the newest run per container. Read-only — the pass never deletes a memory and this tool never starts one. An empty list means no run is visible to this account (the receipts are super_admin-readable), not an outage.",
+        inputSchema: {
+            container: z
+                .string()
+                .min(1)
+                .max(128)
+                .optional()
+                .describe("One container tag. Omit for the newest run per container."),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(200)
+                .optional()
+                .describe("How many run rows to read. Default 50."),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const params = new URLSearchParams();
+        if (args.container)
+            params.set("container", String(args.container));
+        if (args.limit !== undefined)
+            params.set("limit", String(args.limit));
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/memory/consolidation${queryString(params)}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("memory_consolidation", response));
+        const runs = Array.isArray(response.body.runs) ? response.body.runs : [];
+        const reason = typeof response.body.reason === "string" ? response.body.reason : "runs_read";
+        return textResult(runs.length === 0
+            ? `No consolidation runs are visible (${reason}). The pass is a nightly cron and its receipts are readable by a super_admin; this is the access rule answering, not an outage.`
+            : `${runs.length} consolidation run${runs.length === 1 ? "" : "s"}. report = proposals only, nothing on the shelf changed; apply = accepted edits written as supersessions, which never delete anything.`, response.body);
+    }));
+}

package/dist/memory-profile-tools.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `memory_profile` (BLI-4533) — the compiled one-page briefing for a memory
+ * space, over the same `GET /api/memory/profile` door `cockpit memory profile`
+ * calls.
+ *
+ * Every session already opens with this page injected by the session-start
+ * hook. This tool exists for the turn AFTER that: an agent that wants to know
+ * what a DIFFERENT project's memory says about itself, or one that wants to
+ * re-read its own briefing without trusting a context window that has since
+ * been compacted.
+ *
+ * It lives on `bli-tower` rather than on `bli-memory` for one reason: the four
+ * store tools on that server are the vendor-compatible set the Claude Code
+ * plugin expects, and this is ours. The DOOR is the same either way.
+ *
+ * Read-only, and there is no compile argument on purpose. The page is written
+ * once a day by the `memory-profile` Railway service; a tool that could trigger
+ * a compile would put a paid model call behind a sentence an agent types.
+ */
+import { type ToolDeps } from "./tool-result.js";
+export declare function registerMemoryProfileTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: ToolDeps): void;

package/dist/memory-profile-tools.js

@@ -0,0 +1,65 @@
+/**
+ * `memory_profile` (BLI-4533) — the compiled one-page briefing for a memory
+ * space, over the same `GET /api/memory/profile` door `cockpit memory profile`
+ * calls.
+ *
+ * Every session already opens with this page injected by the session-start
+ * hook. This tool exists for the turn AFTER that: an agent that wants to know
+ * what a DIFFERENT project's memory says about itself, or one that wants to
+ * re-read its own briefing without trusting a context window that has since
+ * been compacted.
+ *
+ * It lives on `bli-tower` rather than on `bli-memory` for one reason: the four
+ * store tools on that server are the vendor-compatible set the Claude Code
+ * plugin expects, and this is ours. The DOOR is the same either way.
+ *
+ * Read-only, and there is no compile argument on purpose. The page is written
+ * once a day by the `memory-profile` Railway service; a tool that could trigger
+ * a compile would put a paid model call behind a sentence an agent types.
+ */
+import { z } from "zod";
+import { callAgentDoor } from "./agent-door.js";
+import { doorFailureText, errorResult, queryString, registrarFor, textResult, withSession, } from "./tool-result.js";
+export function registerMemoryProfileTools(server, deps) {
+    registrarFor(server)("memory_profile", {
+        title: "Read a memory space's compiled profile",
+        description: "The one-page briefing BLI Memory compiles daily for a container: who works here, what is going on now, "
+            + "standing rules and preferences, how to communicate. The same page a session start injects. Read-only — "
+            + "the compile runs on a cron, never on demand. A container with no page yet answers `not_compiled_yet`, "
+            + "which means nothing has been compiled, NOT that the store is down.",
+        inputSchema: {
+            container: z
+                .string()
+                .min(1)
+                .max(128)
+                .describe("The container tag, e.g. repo_bli_cockpit__12e241cdbc00adfd."),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const container = String(args.container);
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/memory/profile${queryString(new URLSearchParams({ container }))}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("memory_profile", response));
+        const body = response.body;
+        const profile = body.profile ?? null;
+        const lines = profile?.lines ?? [];
+        if (lines.length === 0) {
+            // Named, not blank: the difference between "not compiled yet" and an
+            // empty page is the whole reason the door returns a reason at all.
+            return textResult(`No profile is compiled for ${container} yet (${String(body.reason ?? "unknown")}). `
+                + "The daily compile writes one once this space has memories.", { ok: true, containerTag: container, reason: body.reason ?? "unknown", lines: 0 });
+        }
+        return textResult([
+            ...lines,
+            "",
+            `Compiled ${String(profile?.compiledAt ?? "—")} from ${String(profile?.sourceRows ?? 0)} memories by ${String(profile?.model ?? "—")}.`,
+        ].join("\n"), {
+            ok: true,
+            containerTag: container,
+            reason: body.reason ?? "profile_read",
+            lines: lines.length,
+            compiledAt: profile?.compiledAt ?? null,
+            sourceRows: profile?.sourceRows ?? 0,
+            model: profile?.model ?? null,
+        });
+    }));
+}

package/dist/memory-requeue-tools.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `memory_requeue` (BLI-4539) — put a window of finished extractions back in
+ * the queue, over the same `POST /api/memory/requeue` door
+ * `cockpit memory requeue` calls.
+ *
+ * It exists because the alternative was a one-off script. 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
+ * recovering them meant somebody hand-writing SQL against production.
+ *
+ * It lives on `bli-tower` rather than on `bli-memory` for the same reason
+ * `memory_profile` does: that server's four tools are the vendor-compatible
+ * set the Claude Code plugin expects, and this is ours.
+ *
+ * **`dryRun` defaults to TRUE, here as at the door.** An apply re-runs one
+ * model call per receipt, so an agent that means to count must never be able
+ * to spend by omission. The door's super_admin gate is the real boundary; this
+ * default is the one that stops an honest mistake.
+ */
+import { type ToolDeps } from "./tool-result.js";
+export declare function registerMemoryRequeueTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: ToolDeps): void;

package/dist/memory-requeue-tools.js

@@ -0,0 +1,107 @@
+/**
+ * `memory_requeue` (BLI-4539) — put a window of finished extractions back in
+ * the queue, over the same `POST /api/memory/requeue` door
+ * `cockpit memory requeue` calls.
+ *
+ * It exists because the alternative was a one-off script. 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
+ * recovering them meant somebody hand-writing SQL against production.
+ *
+ * It lives on `bli-tower` rather than on `bli-memory` for the same reason
+ * `memory_profile` does: that server's four tools are the vendor-compatible
+ * set the Claude Code plugin expects, and this is ours.
+ *
+ * **`dryRun` defaults to TRUE, here as at the door.** An apply re-runs one
+ * model call per receipt, so an agent that means to count must never be able
+ * to spend by omission. The door's super_admin gate is the real boundary; this
+ * default is the one that stops an honest mistake.
+ */
+import { z } from "zod";
+import { callAgentDoor } from "./agent-door.js";
+import { doorFailureText, errorResult, registrarFor, textResult, withSession, } from "./tool-result.js";
+/** `hook:104, harvest:18` — counts and labels only, never a receipt's content. */
+function split(counts) {
+    if (!counts)
+        return "none";
+    const entries = Object.entries(counts).sort((left, right) => right[1] - left[1] || (left[0] < right[0] ? -1 : 1));
+    return entries.length === 0 ? "none" : entries.map(([label, count]) => `${label}:${count}`).join(", ");
+}
+export function registerMemoryRequeueTools(server, deps) {
+    registrarFor(server)("memory_requeue", {
+        title: "Requeue a window of memory extractions",
+        description: "Put finished `memory_extract_jobs` receipts back to `queued` after the store refused their writes — "
+            + "the recovery for a `store_failed` window once its cause is fixed. Nothing is ever deleted: the previous "
+            + "outcome is kept on the row under `result.requeued_from`. Super admins only. `dryRun` defaults to TRUE "
+            + "and an apply re-runs one model call per receipt, so count first. A window is required; there is no "
+            + "requeue-everything.",
+        inputSchema: {
+            since: z
+                .string()
+                .min(1)
+                .describe("ISO instant; receipts that FINISHED at or after it, e.g. 2026-09-21T04:10:00Z."),
+            until: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("ISO instant; receipts that finished at or before it."),
+            source: z
+                .enum(["hook", "harvest"])
+                .optional()
+                .describe("One arm only. Absent means both."),
+            reason: z
+                .string()
+                .min(1)
+                .max(80)
+                .optional()
+                .describe("A short label, written onto the row as `requeued:<label>`. Never a sentence."),
+            dryRun: z
+                .boolean()
+                .optional()
+                .describe("Count and write nothing. Defaults to true; pass false to apply."),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const dryRun = args.dryRun === undefined ? true : Boolean(args.dryRun);
+        const response = await callAgentDoor(session, deps.fetchImpl, "POST", "/api/memory/requeue", {
+            since: String(args.since),
+            ...(args.until === undefined ? {} : { until: String(args.until) }),
+            ...(args.source === undefined ? {} : { source: String(args.source) }),
+            ...(args.reason === undefined ? {} : { reason: String(args.reason) }),
+            dryRun,
+        });
+        if (!response.ok)
+            return errorResult(doorFailureText("memory_requeue", response));
+        const body = response.body;
+        const matched = body.matched ?? 0;
+        if (matched === 0) {
+            // Named, not blank: "nothing matched" and "the store is down" are
+            // different facts, and the second one took the branch above.
+            return textResult(`No finished extraction receipt is in that window. Nothing to requeue; the receipts table answered.`, { ok: true, dryRun: body.dryRun ?? dryRun, matched: 0, requeued: 0 });
+        }
+        const head = body.dryRun
+            ? `${matched} receipt(s) would be requeued`
+            : `${body.requeued ?? 0} of ${matched} receipt(s) requeued`;
+        return textResult([
+            `${head} (${split(body.bySource)}).`,
+            `By reason: ${split(body.byReason)}.`,
+            body.coverage === "capped"
+                ? "The page ceiling stopped this run before the window ended; run it again for the rest."
+                : "",
+            body.dryRun
+                ? "Nothing was written. Call again with dryRun: false to apply."
+                : "The previous result is kept on each row under result.requeued_from.",
+        ]
+            .filter((line) => line.length > 0)
+            .join("\n"), {
+            ok: true,
+            dryRun: body.dryRun ?? dryRun,
+            matched,
+            scanned: body.scanned ?? 0,
+            requeued: body.requeued ?? 0,
+            refused: body.refused ?? 0,
+            coverage: body.coverage ?? "unknown",
+            bySource: body.bySource ?? {},
+            byReason: body.byReason ?? {},
+        });
+    }));
+}

package/dist/server.js

@@ -15,7 +15,10 @@ import { registerMailTools } from "./mail-tools.js";
 import { registerNotesAccountTools } from "./notes-account-tools.js";
 import { registerNotesTools } from "./notes-tools.js";
 import { registerNotesWriteTools } from "./notes-write-tools.js";
+import { registerMemoryConsolidationTools } from "./memory-consolidation-tools.js";
 import { registerMemoryExperienceTools } from "./memory-experience-tools.js";
+import { registerMemoryProfileTools } from "./memory-profile-tools.js";
+import { registerMemoryRequeueTools } from "./memory-requeue-tools.js";
 import { registerModelsTools } from "./models-tools.js";
 import { registerOpsTools } from "./ops-tools.js";
 import { registerPagesTools } from "./pages-tools.js";
@@ -423,6 +426,14 @@ export function createServer(deps) {
     registerNotesTools(server, { fetchImpl: deps.fetchImpl });
     registerOpsTools(server, { fetchImpl: deps.fetchImpl });
     registerMemoryExperienceTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-4533: the compiled one-page profile, the twin of `cockpit memory profile`.
+    registerMemoryProfileTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-4534: the nightly consolidation receipts, twin of `cockpit memory
+    // consolidation`. Read-only, and the pass it reports on never deletes.
+    registerMemoryConsolidationTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-4539: putting a window of refused extractions back, the twin of
+    // `cockpit memory requeue`. Dry run by default, super_admin at the door.
+    registerMemoryRequeueTools(server, { fetchImpl: deps.fetchImpl });
     registerSettingsTools(server, { fetchImpl: deps.fetchImpl });
     registerPagesTools(server, { fetchImpl: deps.fetchImpl });
     // BLI-3756 batch 2: the WRITES. Same doors, same device token, same refusal

package/dist/verb-census.js

@@ -300,6 +300,18 @@ export const MCP_TWINS = {
     "memory save": { tool: "save_memory", door: "POST /api/memory/save", server: "bli-memory" },
     "memory update": { tool: "update_memory", door: "POST /api/memory/update", server: "bli-memory" },
     "memory forget": { tool: "forget_memory", door: "POST /api/memory/forget", server: "bli-memory" },
+    // BLI-4533: the compiled one-page profile. Its twin is on `bli-tower`, not
+    // `bli-memory`: that server's four tools are the vendor-compatible set the
+    // Claude Code plugin expects, and this page is ours.
+    "memory profile": { tool: "memory_profile", door: "GET /api/memory/profile" },
+    // BLI-4534: the nightly consolidation receipts. This twin lives on
+    // `bli-tower` rather than `bli-memory`, because it is a read of a JOB s
+    // counts and not a read or write of the store itself.
+    "memory consolidation": { tool: "memory_consolidation", door: "GET /api/memory/consolidation" },
+    // BLI-4539: the recovery verb, after a window of extractions whose writes
+    // the store refused. Also on `bli-tower`, for the same reason
+    // `memory profile` is: it is ours, not the vendor's four.
+    "memory requeue": { tool: "memory_requeue", door: "POST /api/memory/requeue" },
     "ops status": { tool: "ops_status", door: "GET /api/ops/status" },
     "ops recompile": { tool: "ops_recompile", door: "POST /api/ops/recompile" },
     "slack coverage": { tool: "slack_coverage", door: "GET /api/ops/slack/coverage" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/mcp",
-  "version": "0.1.55",
+  "version": "0.1.58",
   "private": false,
   "description": "bli-tower: an MCP server over BLI Cockpit's agent doors: JARVIS (jarvis_*), documents (docs_*), channels (msg_*), issues (work_*), the daily page (brief_*), meeting notes (notes_*), the ops board (ops_status/slack_*), settings/team/model, Scout and the workbook, plus the legacy event-stream tools (emit_event, get_ticket_timeline, get_active_tickets).",
   "type": "module",