@bli-cockpit/mcp 0.1.114 → 0.1.115

package/README.md

@@ -109,7 +109,7 @@ about what an agent can reach.
 
 <!-- BEGIN GENERATED verb census — `npm run mcp:readme` -->
 
-**159 of 164 Tower verbs have an MCP twin.**
+**160 of 165 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
@@ -195,6 +195,7 @@ three tables below.
 | `cockpit mail send` | `mail_send` | `POST /api/mail/send` |
 | `cockpit mail sync` | `mail_sync` | `POST /api/mail/accounts/[id]/sync` |
 | `cockpit mail sync-status` | `mail_sync_status` | `GET /api/mail/sync-status` |
+| `cockpit memory chain` | `memory_chain` | `GET /api/memory/chain` |
 | `cockpit memory consolidation` | `memory_consolidation` | `GET /api/memory/consolidation` |
 | `cockpit memory forget` | `forget_memory` (`bli-memory`) | `POST /api/memory/forget` |
 | `cockpit memory knowledge` | `memory_knowledge` | `GET /api/memory/knowledge` |

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

@@ -0,0 +1,13 @@
+/**
+ * `memory_chain` (BLI-13376) - the MCP twin of `cockpit memory chain <id>`.
+ *
+ * Same door, same device token: `GET /api/memory/chain?id=<memory id>`. For a
+ * memory the nightly consolidation wrote, it lists the memories that were
+ * folded into it (date, project, text, who saved it). The door applies the
+ * privacy rule: a private original shows only to its owner or a super_admin,
+ * and the rest are counted, never shown. Read-only.
+ */
+import { type ToolDeps } from "./tool-result.js";
+export declare function registerMemoryChainTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: ToolDeps): void;

package/dist/memory-chain-tools.js

@@ -0,0 +1,44 @@
+/**
+ * `memory_chain` (BLI-13376) - the MCP twin of `cockpit memory chain <id>`.
+ *
+ * Same door, same device token: `GET /api/memory/chain?id=<memory id>`. For a
+ * memory the nightly consolidation wrote, it lists the memories that were
+ * folded into it (date, project, text, who saved it). The door applies the
+ * privacy rule: a private original shows only to its owner or a super_admin,
+ * and the rest are counted, never shown. Read-only.
+ */
+import { z } from "zod";
+import { callAgentDoor } from "./agent-door.js";
+import { doorFailureText, errorResult, queryString, registrarFor, textResult, withSession } from "./tool-result.js";
+export function registerMemoryChainTools(server, deps) {
+    registrarFor(server)("memory_chain", {
+        title: "Read the originals behind a consolidated memory",
+        description: "For a memory the nightly consolidation wrote (it says 'from N memories by Name, Name' in search and on the Memory page), the memories that were folded into it: date, project, text and who saved each. A private original is shown only to its owner or a super_admin; the rest are counted ('1 private original not shown'). An id the night never wrote answers consolidated=false. Read-only.",
+        inputSchema: { id: z.string().min(1).describe("The memory id from search_memory, memory_rules or memory_knowledge.") },
+    }, async (args) => withSession(deps, async (session) => {
+        const params = new URLSearchParams();
+        params.set("id", String(args.id));
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/memory/chain${queryString(params)}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("memory_chain", response));
+        const body = response.body;
+        if (!body.consolidated) {
+            return textResult(`Memory ${String(args.id)} was not written by the nightly consolidation, so it has no originals.`, response.body);
+        }
+        const originals = body.originals ?? [];
+        const count = body.count ?? originals.length;
+        const lines = [`Memory ${String(args.id)} is from ${count} ${count === 1 ? "memory" : "memories"}${(body.people ?? []).length ? ` by ${(body.people ?? []).join(", ")}` : ""}.`];
+        for (const original of originals) {
+            lines.push(`[${(original.createdAt ?? "").slice(0, 10)}]${original.project ? ` [${original.project}]` : ""}${original.savedBy ? ` ${original.savedBy}:` : ""} ${original.text ?? ""}`);
+        }
+        const hiddenPrivate = body.hiddenPrivate ?? 0;
+        if (hiddenPrivate > 0)
+            lines.push(`${hiddenPrivate} private ${hiddenPrivate === 1 ? "original" : "originals"} not shown.`);
+        const gone = (body.hiddenForgotten ?? 0) + (body.missing ?? 0);
+        if (gone > 0)
+            lines.push(`${gone} ${gone === 1 ? "original is" : "originals are"} no longer available.`);
+        if (body.truncated)
+            lines.push("Only the first originals are listed.");
+        return textResult(lines.join("\n"), response.body);
+    }));
+}

package/dist/memory-consolidation-tools.js

@@ -23,6 +23,17 @@ function counts(value) {
     const entries = Object.entries(value);
     return entries.length === 0 ? "none" : entries.map(([key, count]) => `${key} ${String(count)}`).join(", ");
 }
+/** One scope of last night, as the door computed it (BLI-13376). */
+function scopeLine(scope) {
+    const refused = Array.isArray(scope.topRefused)
+        ? scope.topRefused.map((item) => `${String(item.label)} ${String(item.count)}`).join(", ")
+        : "";
+    const cost = typeof scope.costUsd === "number" ? `$${scope.costUsd.toFixed(4)}` : "$?";
+    return `${String(scope.label ?? scope.containerTag ?? "?")}  ${String(scope.mode ?? "?")}  clusters ${String(scope.clusters ?? 0)}; `
+        + `merged ${String(scope.merged ?? 0)}; rewritten ${String(scope.rewritten ?? 0)}; corrected ${String(scope.corrected ?? 0)}; `
+        + `kept ${String(scope.kept ?? 0)}; refused ${String(scope.refused ?? 0)}${refused ? ` (${refused})` : ""}; `
+        + `cross-person ${String(scope.crossPersonClusters ?? 0)}; ${cost}`;
+}
 function runLine(run) {
     const cost = typeof run.costUsd === "number" ? `$${run.costUsd.toFixed(4)}` : "$?";
     return `${String(run.startedAt ?? "?")}  ${String(run.containerTag ?? "?")}  ${String(run.mode ?? "?")}  `
@@ -33,7 +44,7 @@ function runLine(run) {
 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.",
+        description: "What the nightly BLI Memory consolidation pass did, LAST NIGHT first: a one-line night total (runs, finished vs unfinished, cost) and per container or scope the clusters, merged, rewritten, corrected, kept, refused (with top labels), cross-person clusters and cost; the structured half is the full door body plus a computed `night` object. 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()
@@ -63,6 +74,13 @@ export function registerMemoryConsolidationTools(server, deps) {
         // One line per run in the text half. It used to carry only the count,
         // so a Claude-family client never saw a run (BLI-10432).
         const lines = runs.map(runLine).join("\n");
+        // Last night first (BLI-13376): the door's one-line total, then a line per scope.
+        const nightLine = typeof response.body.nightLine === "string" ? response.body.nightLine : null;
+        const scopes = (Array.isArray(response.body.nightScopes) ? response.body.nightScopes : []);
+        if (nightLine) {
+            return textResult(`${nightLine}\n${scopes.map(scopeLine).join("\n")}\n`
+                + "merged/rewritten/corrected are what an apply run wrote or what a report run only proposed (mode); kept is always a proposal; nothing is ever deleted.", response.body);
+        }
         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.`

package/dist/memory-rules-tools.js

@@ -1,6 +1,37 @@
 import { z } from "zod";
 import { callAgentDoor } from "./agent-door.js";
 import { doorFailureText, errorResult, queryString, registrarFor, textResult, withSession } from "./tool-result.js";
+/** The plain sentence, or the machine wording marked as the original while no plain one is written yet. Same rule as `cockpit memory`. */
+function sentence(idea) {
+    const c = idea.consolidated;
+    // "(from 4 memories by Edward, Vee)" marks a memory the nightly pass wrote (BLI-13376).
+    const origin = c ? ` (from ${c.count} ${c.count === 1 ? "memory" : "memories"}${c.people.length ? ` by ${c.people.join(", ")}` : ""})` : "";
+    return (idea.human_text ? idea.human_text : `${idea.text} (original wording)`) + origin;
+}
+/** The text half of the answer: the same header words the page and the CLI print, then each project's ideas as plain sentences. */
+function answerText(body, action) {
+    const lines = [body.words?.summary, body.words?.ranking, body.freshness?.words, ...(body.notes ?? [])].filter((line) => Boolean(line));
+    if (body.projectGroups?.length)
+        for (const group of body.projectGroups) {
+            lines.push("", `${group.project}, ${group.count.toLocaleString("en-US")} memories`);
+            const topics = group.topics ?? [];
+            const headed = Boolean(group.ranked) && topics.length > 1;
+            if (topics.length)
+                for (const topic of topics)
+                    lines.push(...(headed ? [`  ${topic.title}`] : []), ...topic.memories.map(idea => `${headed ? "    " : "  "}${sentence(idea)}`));
+            else
+                lines.push(...(group.memories ?? []).map(idea => `  ${sentence(idea)}`));
+        }
+    else
+        for (const group of body.groups ?? []) {
+            lines.push(group.owner, ...group.rules.map(rule => `  [${rule.created_at.slice(0, 10)}] ${rule.project ? `[${rule.project}] ` : ""}${sentence(rule)}`));
+        }
+    if (!body.returned)
+        lines.push(`No ${action === "rules" ? "ground rules" : "project knowledge"} matched.`);
+    if (body.capped)
+        lines.push("Result capped; narrow by person or project, or raise limit (max 1000) or per_project (max 100).");
+    return lines.join("\n");
+}
 export function registerMemoryRulesTools(server, deps) {
     registrarFor(server)("memory_map", {
         title: "Read the memory map",
@@ -18,25 +49,21 @@ export function registerMemoryRulesTools(server, deps) {
     for (const action of ["rules", "knowledge"])
         registrarFor(server)(`memory_${action}`, {
             title: `Read BLI agent ${action}`,
-            description: `Memories grouped by project and topic, ranked by Jev importance, repetition, then recency. Reads only memories visible to you, over the same door as cockpit memory ${action}. Default 200 ideas, max 1000; capped means narrow the filters or increase the bound.`,
-            inputSchema: { person: z.string().min(1).optional().describe("Exact roster name, or unattributed for memories with no author."), project: z.string().min(1).optional().describe("Case-insensitive project name or canonical slug, for example Pearl Portal or pearl-portal."), limit: z.number().int().min(1).max(1000).optional().describe("Maximum ranked ideas, default 200, maximum 1000. Scan or output bounds are marked capped.") },
+            description: `Memories grouped by project, each project with its own quota of ideas, ranked by importance, repetition, then recency. The text is plain header words (what the list covers, how it is ordered, how fresh it is, any problems) then one plain sentence per idea; quote those sentences, never ids or scores. structuredContent is the whole answer, with both wordings per idea: human_text for people, text for agents. Reads only memories visible to you, over the same door as cockpit memory ${action}. Default 15 ideas per project, 1000 in all; capped means narrow the filters or raise a bound.`,
+            inputSchema: {
+                person: z.string().min(1).optional().describe("Exact roster name, or unattributed for memories with no author."),
+                project: z.string().min(1).optional().describe("Case-insensitive project name or canonical slug, for example Pearl Portal or pearl-portal."),
+                limit: z.number().int().min(1).max(1000).optional().describe("Maximum ideas in all, default 1000, maximum 1000."),
+                per_project: z.number().int().min(1).max(100).optional().describe("Ideas shown from each project, default 15, maximum 100."),
+            },
         }, async (args) => withSession(deps, async (session) => {
             const params = new URLSearchParams();
-            for (const key of ["person", "project", "limit"])
+            for (const key of ["person", "project", "limit", "per_project"])
                 if (args[key] !== undefined)
                     params.set(key, String(args[key]));
             const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/memory/${action}${queryString(params)}`);
             if (!response.ok)
                 return errorResult(doorFailureText(`memory_${action}`, response));
-            const body = response.body;
-            const lines = body.projectGroups ? body.projectGroups.flatMap(group => [
-                `${group.project} (${group.count}): ${group.headline.split("\n")[0]}`,
-                ...group.topics.flatMap(topic => [topic.title, ...topic.memories.map(memory => `${memory.text}${memory.repetition > 1 ? ` (said ${memory.repetition} times)` : ""}${memory.importance !== null ? ` [importance ${memory.importance}/100]` : ""}`)]),
-            ]) : (body.groups ?? []).flatMap((group) => [group.owner, ...group.rules.map((rule) => `[${rule.created_at.slice(0, 10)}] ${rule.project ? `[${rule.project}] ` : ""}${rule.text}${group.owner === "unattributed" ? ` (space: ${rule.container})` : ""}`)]);
-            if (!lines.length)
-                lines.push(`No ${action === "rules" ? "ground rules" : "project knowledge"} matched.`);
-            if (body.capped)
-                lines.push("Result capped; narrow by person/project or increase limit (max 1000).");
-            return textResult(lines.join("\n"), response.body);
+            return textResult(answerText(response.body, action), response.body);
         }));
 }

package/dist/server.js

@@ -20,6 +20,7 @@ import { registerNotesTools } from "./notes-tools.js";
 import { registerNotesBotUpcomingTool } from "./notes-bot-upcoming-tool.js";
 import { registerNotesGranolaStatusTool } from "./notes-granola-status-tool.js";
 import { registerNotesWriteTools } from "./notes-write-tools.js";
+import { registerMemoryChainTools } from "./memory-chain-tools.js";
 import { registerMemoryConsolidationTools } from "./memory-consolidation-tools.js";
 import { registerMemoryExperienceTools } from "./memory-experience-tools.js";
 import { registerMemoryRulesTools } from "./memory-rules-tools.js";
@@ -487,6 +488,8 @@ export function createServer(deps, options = {}) {
     // 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-13376: the originals behind a consolidated memory, twin of `cockpit memory chain`.
+    registerMemoryChainTools(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 });

package/dist/tool-catalog.d.ts

@@ -10,7 +10,7 @@
  * from `src/` under Node's type stripping, so it may import nothing.
  */
 /** Tools that change nothing. The smoke calls every one. */
-export declare const READ_TOOLS: readonly ["get_ticket_timeline", "get_active_tickets", "docs_list", "docs_tree", "docs_read", "docs_sync_status", "msg_channels", "msg_read", "msg_thread", "work_board", "work_list_issues", "work_get_issue", "work_issue_history", "work_list_projects", "careers_list", "careers_show", "careers_resume_url", "careers_takehome_show", "careers_settings_show", "rename_pending", "github_pr", "setup_read", "speed_read", "speed_seen", "usage_people", "usage_sessions", "mail_accounts", "mail_inbox", "mail_read", "mail_search", "mail_attachment", "mail_sync_status", "cal_today", "cal_week", "cal_next", "cal_find", "cal_calendars", "cal_sync_status", "jarvis_ask", "jarvis_trace", "jarvis_check", "models_list", "models_card", "models_compare", "brief_read", "brief_history", "brief_status", "brief_missed", "notes_folders", "notes_list", "glossary_list", "notes_show", "notes_shelf", "notes_shelves", "notes_place", "notes_accounts", "notes_recordings", "notes_recording", "notes_sync_status", "notes_granola_status", "notes_bot_upcoming", "ops_status", "slack_coverage", "slack_connect", "slack_disconnect", "slack_read", "memory_map", "memory_rules", "memory_knowledge", "memory_profile", "memory_consolidation", "settings_show", "settings_list", "model_show", "team_members", "team_github_login_add", "team_github_login_remove", "team_github_login_list", "team_device_list", "scout_board", "workbook_read", "tower_search", "sources_check", "logs_digest", "brain_status"];
+export declare const READ_TOOLS: readonly ["get_ticket_timeline", "get_active_tickets", "docs_list", "docs_tree", "docs_read", "docs_sync_status", "msg_channels", "msg_read", "msg_thread", "work_board", "work_list_issues", "work_get_issue", "work_issue_history", "work_list_projects", "careers_list", "careers_show", "careers_resume_url", "careers_takehome_show", "careers_settings_show", "rename_pending", "github_pr", "setup_read", "speed_read", "speed_seen", "usage_people", "usage_sessions", "mail_accounts", "mail_inbox", "mail_read", "mail_search", "mail_attachment", "mail_sync_status", "cal_today", "cal_week", "cal_next", "cal_find", "cal_calendars", "cal_sync_status", "jarvis_ask", "jarvis_trace", "jarvis_check", "models_list", "models_card", "models_compare", "brief_read", "brief_history", "brief_status", "brief_missed", "notes_folders", "notes_list", "glossary_list", "notes_show", "notes_shelf", "notes_shelves", "notes_place", "notes_accounts", "notes_recordings", "notes_recording", "notes_sync_status", "notes_granola_status", "notes_bot_upcoming", "ops_status", "slack_coverage", "slack_connect", "slack_disconnect", "slack_read", "memory_map", "memory_rules", "memory_knowledge", "memory_profile", "memory_consolidation", "memory_chain", "settings_show", "settings_list", "model_show", "team_members", "team_github_login_add", "team_github_login_remove", "team_github_login_list", "team_device_list", "scout_board", "workbook_read", "tower_search", "sources_check", "logs_digest", "brain_status"];
 /**
  * Tools that write, but answer a dry run that writes nothing. The smoke calls
  * each one ONLY with its dry-run flag set (`scripts/smoke.ts` says which).

package/dist/tool-catalog.js

@@ -83,6 +83,8 @@ export const READ_TOOLS = [
     "memory_knowledge",
     "memory_profile",
     "memory_consolidation",
+    // BLI-13376: a read of the originals behind a consolidated memory.
+    "memory_chain",
     "settings_show",
     "settings_list",
     "model_show",

package/dist/verb-census.js

@@ -354,6 +354,9 @@ export const MCP_TWINS = {
     // `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-13376: the originals behind a consolidated memory. Also on `bli-tower`:
+    // the door filters private and forgotten originals before anything leaves.
+    "memory chain": { tool: "memory_chain", door: "GET /api/memory/chain" },
     // 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/mcp",
-  "version": "0.1.114",
+  "version": "0.1.115",
   "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",