@bli-cockpit/mcp 0.1.114 → 0.1.116

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.**
+**169 of 174 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
@@ -117,6 +117,15 @@ three tables below.
 
 | CLI verb | MCP tool | Door |
 | --- | --- | --- |
+| `cockpit approvals approve` | `approvals_approve` | `POST /api/approvals/[id]/approve` |
+| `cockpit approvals create` | `approvals_create` | `POST /api/approvals` |
+| `cockpit approvals edit` | `approvals_edit` | `PATCH /api/approvals/[id]` |
+| `cockpit approvals list` | `approvals_list` | `GET /api/approvals` |
+| `cockpit approvals reject` | `approvals_reject` | `POST /api/approvals/[id]/reject` |
+| `cockpit approvals rules` | `approvals_rules` | `GET /api/approvals/rules` |
+| `cockpit approvals rules create` | `approvals_rules_create` | `POST /api/approvals/rules` |
+| `cockpit approvals rules revoke` | `approvals_rules_revoke` | `POST /api/approvals/rules/[id]/revoke` |
+| `cockpit approvals show` | `approvals_show` | `GET /api/approvals/[id]` |
 | `cockpit brain retry` | `brain_retry` | `POST /api/brain/incidents/retry` |
 | `cockpit brain status` | `brain_status` | `GET /api/brain/incidents` |
 | `cockpit brief done` | `brief_done` | `POST /api/jarvis/ticks` |
@@ -195,6 +204,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/approvals-tools.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDeps } from "./tool-result.js";
+export declare function registerApprovalsTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: ToolDeps): void;

package/dist/approvals-tools.js

@@ -0,0 +1,191 @@
+/**
+ * The approvals inbox over MCP (BLI-16945): the nine twins of `cockpit approvals`.
+ *
+ * Plain words: an agent PREPARES an outward act (a mail, a message) as a card; the person
+ * approves it, edits it and approves it, or rejects it. After a few approvals of one kind the
+ * person can turn it into a standing rule ("send without asking"). Every run leaves a receipt.
+ * These tools ride the SAME `/api/approvals` doors the browser page and the CLI call, on this
+ * machine's device token, never a second route.
+ *
+ * Three of them are deliberate acts and refuse without `confirm: true`, the same gate as
+ * `mail_send` and the CLI's `--yes`: `approvals_approve` (the guarded act runs and cannot be
+ * recalled), `approvals_rules_create` (future cards send without asking) and
+ * `approvals_rules_revoke` (a standing rule stops). Creating a card, editing one and rejecting one
+ * reach nobody, so they need none.
+ *
+ * A refused send answers 502 with the door's reason and its "Not sent" sentence; this relays both
+ * verbatim, as an error, and approving again retries.
+ */
+import { z } from "zod";
+import { callAgentDoor } from "./agent-door.js";
+import { CONFIRM_INPUT, EMAIL_INPUT, dataResult, doorFailureText, errorResult, queryString, registrarFor, unconfirmed, withSession, } from "./tool-result.js";
+const LIST_STATUSES = ["open", "done", "pending", "executing", "executed", "failed", "rejected"];
+const SOURCE_KINDS = ["session", "meeting", "ticket", "message", "mail", "jarvis", "schedule", "manual"];
+const CARD_ID = z.string().uuid().describe("The card id, from approvals_list.");
+const ADDRESS = z.object({
+    name: z.string().max(200).optional().describe("The person's display name."),
+    address: EMAIL_INPUT.describe("The email address."),
+});
+/** Every field a card's `payload` can carry today (mail.send and msg.send); the door checks the fields of the kind named. */
+const PAYLOAD = z.looseObject({
+    account: z.string().max(100).optional().describe("mail.send: the exact connected mailbox label to send from. Omit for the default."),
+    account_id: z.string().uuid().optional().describe("mail.send: the mailbox id to send from, instead of a label."),
+    to: z.array(ADDRESS).max(50).optional().describe("mail.send: recipients as { name?, address }."),
+    cc: z.array(ADDRESS).max(50).optional().describe("mail.send: copied recipients as { name?, address }."),
+    subject: z.string().max(998).optional().describe("mail.send: the subject line."),
+    text: z.string().max(500_000).optional().describe("mail.send: the plain-text body."),
+    in_reply_to_message_id: z.string().uuid().optional().describe("mail.send: a message id from mail_read, to send as a reply in that thread."),
+    channel_id: z.string().uuid().optional().describe("msg.send: the channel id from msg_channels."),
+    content: z.string().max(8000).optional().describe("msg.send: the message text."),
+    thread_parent_id: z.string().uuid().optional().describe("msg.send: a message id to reply under."),
+});
+const EDIT = z.looseObject({
+    subject: z.string().max(998).optional().describe("mail.send: the new subject line."),
+    text: z.string().max(500_000).optional().describe("mail.send: the new plain-text body."),
+    content: z.string().max(8000).optional().describe("msg.send: the new message text."),
+});
+export function registerApprovalsTools(server, deps) {
+    const register = registrarFor(server);
+    /** One door call, relayed: the data on success, the door's own reason and sentence on a refusal. */
+    async function ask(tool, method, path, body, headline) {
+        return withSession(deps, async (session) => {
+            const response = await callAgentDoor(session, deps.fetchImpl, method, path, body);
+            if (!response.ok)
+                return errorResult(doorFailureText(tool, response));
+            return dataResult(headline(response.body), response.body);
+        });
+    }
+    const titleOf = (answer) => {
+        const card = answer.card;
+        return typeof card?.title === "string" ? card.title : "that card";
+    };
+    register("approvals_list", {
+        title: "List approval cards",
+        description: "The approvals inbox: outward acts (a mail, a message) that an agent prepared and a person has yet to decide. `status` open (default) is everything still waiting "
+            + "(pending, executing, failed); done is everything decided; or name one status. Each card has its title, who it goes to, why, where it came from, the exact content and its "
+            + "latest receipt. Newest first; `has_more` and `next_before` page backwards. Read-only. `cockpit approvals`, same door.",
+        inputSchema: {
+            status: z.enum(LIST_STATUSES).optional().describe("open (default), done, or one of pending, executing, executed, failed, rejected."),
+            limit: z.number().int().min(1).max(100).optional().describe("How many cards, 1 to 100. Default 50."),
+            before: z.string().min(1).max(100).optional().describe("The next_before cursor of the previous page, to read older cards."),
+        },
+    }, async (args) => {
+        const query = new URLSearchParams();
+        if (typeof args.status === "string")
+            query.set("status", args.status);
+        if (typeof args.limit === "number")
+            query.set("limit", String(args.limit));
+        if (typeof args.before === "string")
+            query.set("before", args.before);
+        return ask("approvals_list", "GET", `/api/approvals${queryString(query)}`, undefined, (answer) => `${String(answer.returned ?? 0)} card(s) shown, ${String(answer.waiting ?? 0)} waiting for a decision.${answer.has_more === true ? " More exist: pass next_before as before." : ""}`);
+    });
+    register("approvals_show", {
+        title: "Read one approval card",
+        description: "One card in full: who it goes to, why, where it came from, the exact content that will be (or was) sent, every receipt with the content the act door was given, "
+            + "and whether a standing rule is worth offering. Read-only. `cockpit approvals show`, same door.",
+        inputSchema: { id: CARD_ID },
+    }, async (args) => ask("approvals_show", "GET", `/api/approvals/${encodeURIComponent(String(args.id))}`, undefined, (answer) => `${titleOf(answer)}.`));
+    register("approvals_create", {
+        title: "Prepare an approval card",
+        description: "Prepares an outward act as a card for the person to approve; nothing is sent. `act_kind` is mail.send (payload: to, subject, text, and optionally account, cc, in_reply_to_message_id) "
+            + "or msg.send (payload: channel_id, content, optionally thread_parent_id). `reason` is why, in a sentence the person reads. `dedupe_key` makes a retry return the same card. "
+            + "If a standing rule already covers the act it is sent at once and the answer says so. `cockpit approvals create`, same door.",
+        inputSchema: {
+            act_kind: z.enum(["mail.send", "msg.send"]).describe("Which kind of act: mail.send or msg.send."),
+            payload: PAYLOAD.describe("The act's exact content; the fields of the kind named."),
+            reason: z.string().trim().min(1).max(2000).describe("Why this should go out, in a sentence the person reads."),
+            kind_label: z.string().trim().min(1).max(120).optional().describe("A short name for this sort of card, like Client follow-up email."),
+            source_kind: z.enum(SOURCE_KINDS).optional().describe("Where the act came from. Default manual."),
+            source_ref: z.string().trim().min(1).max(200).optional().describe("An id or link for the source, like a ticket identifier."),
+            source_label: z.string().trim().min(1).max(300).optional().describe("A short human label for the source, shown on the card."),
+            prepared_by: z.string().trim().min(1).max(80).optional().describe("Who prepared it, like Claude. Default an agent on a paired machine."),
+            dedupe_key: z.string().trim().min(1).max(200).optional().describe("A stable key so preparing the same card twice returns the first."),
+        },
+    }, async (args) => ask("approvals_create", "POST", "/api/approvals", args, (answer) => {
+        if (answer.deduped === true)
+            return `${titleOf(answer)} was already prepared. Nothing new was created.`;
+        if (answer.executed_by_rule === true)
+            return `${titleOf(answer)}: a standing rule sent it without asking.`;
+        return `${titleOf(answer)} is prepared and waiting for the person's decision.`;
+    }));
+    register("approvals_approve", {
+        title: "Approve an approval card",
+        description: "Approves a card: the guarded act RUNS (the mail goes out, the message posts) and cannot be taken back, so confirm must be true. `edit` ({ subject, text } or { content }) "
+            + "is applied first, in one step. If the send is refused the answer is an error carrying the door's reason and its \"Not sent\" sentence, the card is marked failed, and approving again retries. "
+            + "A card already decided is refused with already_decided. `cockpit approvals approve`, same door.",
+        inputSchema: {
+            id: CARD_ID,
+            edit: EDIT.optional().describe("An edit to apply before approving: { subject, text } for mail, { content } for a message."),
+            confirm: CONFIRM_INPUT,
+        },
+    }, async (args) => {
+        const refusal = unconfirmed(args, "Approving lets the guarded act run, and a sent mail or message cannot be recalled.");
+        if (refusal)
+            return refusal;
+        return ask("approvals_approve", "POST", `/api/approvals/${encodeURIComponent(String(args.id))}/approve`, args.edit ? { edit: args.edit } : {}, (answer) => {
+            const receipt = answer.receipt;
+            return `Approved. ${typeof receipt?.summary === "string" ? receipt.summary : "Done."}`;
+        });
+    });
+    register("approvals_edit", {
+        title: "Edit an approval card",
+        description: "Saves an edit to a waiting card ({ subject, text } for mail, { content } for a message). The card stays waiting and nothing is sent; to edit and send in one step, call "
+            + "approvals_approve with `edit`. Recipients cannot be edited (field_not_editable). `cockpit approvals edit`, same door.",
+        inputSchema: { id: CARD_ID, edit: EDIT.describe("The edit: { subject, text } for mail, { content } for a message.") },
+    }, async (args) => ask("approvals_edit", "PATCH", `/api/approvals/${encodeURIComponent(String(args.id))}`, { edit: args.edit }, (answer) => `Saved your edit to ${titleOf(answer)}. It is still waiting for a decision.`));
+    register("approvals_reject", {
+        title: "Reject an approval card",
+        description: "Declines a waiting card. Nothing is sent and the card is closed; a card already decided is refused with already_decided. `cockpit approvals reject`, same door.",
+        inputSchema: { id: CARD_ID },
+    }, async (args) => ask("approvals_reject", "POST", `/api/approvals/${encodeURIComponent(String(args.id))}/reject`, {}, (answer) => `Rejected ${titleOf(answer)}. Nothing was sent.`));
+    register("approvals_rules", {
+        title: "List standing approval rules",
+        description: "The person's standing rules: kinds of card that send without asking, who they cover, how often each has fired and whether it is still active. Read-only. `cockpit approvals rules`, same door.",
+        inputSchema: {
+            active: z.boolean().optional().describe("true for rules still in force, false for revoked ones. Omit for both."),
+            limit: z.number().int().min(1).max(100).optional().describe("How many rules, 1 to 100. Default 50."),
+        },
+    }, async (args) => {
+        const query = new URLSearchParams();
+        if (typeof args.active === "boolean")
+            query.set("active", String(args.active));
+        if (typeof args.limit === "number")
+            query.set("limit", String(args.limit));
+        return ask("approvals_rules", "GET", `/api/approvals/rules${queryString(query)}`, undefined, (answer) => `${String(answer.returned ?? 0)} standing rule(s).`);
+    });
+    register("approvals_rules_create", {
+        title: "Create a standing approval rule",
+        description: "Turns a card the person approved into a standing rule: from now on this kind of card sends WITHOUT asking, so confirm must be true. `audience` same (default) covers the same people; "
+            + "any covers every audience of this kind. Refused unless the person approved the card themselves (card_not_approved) and when a rule already exists (rule_exists). `cockpit approvals rules create`, same door.",
+        inputSchema: {
+            card_id: z.string().uuid().describe("The id of a card the person approved."),
+            audience: z.enum(["same", "any"]).optional().describe("same (default): the same people. any: every audience of this kind."),
+            label: z.string().trim().min(1).max(400).optional().describe("A name for the rule, shown in the rules list."),
+            confirm: CONFIRM_INPUT,
+        },
+    }, async (args) => {
+        const refusal = unconfirmed(args, "A standing rule makes this kind of card send without asking from now on.");
+        if (refusal)
+            return refusal;
+        const { confirm: _confirm, ...body } = args;
+        return ask("approvals_rules_create", "POST", "/api/approvals/rules", body, (answer) => {
+            const rule = answer.rule;
+            return `Standing rule created: ${typeof rule?.label === "string" ? rule.label : "see the rule"}.`;
+        });
+    });
+    register("approvals_rules_revoke", {
+        title: "Revoke a standing approval rule",
+        description: "Takes a standing rule back: matching cards wait for a decision again. The rule stays in the list as revoked, with the reason. Confirm must be true. "
+            + "`cockpit approvals rules revoke`, same door.",
+        inputSchema: {
+            id: z.string().uuid().describe("The rule id, from approvals_rules."),
+            reason: z.string().trim().min(1).max(300).optional().describe("Why the rule is taken back."),
+            confirm: CONFIRM_INPUT,
+        },
+    }, async (args) => {
+        const refusal = unconfirmed(args, "Revoking a standing rule changes what Tower sends without asking.");
+        if (refusal)
+            return refusal;
+        return ask("approvals_rules_revoke", "POST", `/api/approvals/rules/${encodeURIComponent(String(args.id))}/revoke`, args.reason ? { reason: args.reason } : {}, () => "Standing rule revoked.");
+    });
+}

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";
@@ -41,6 +42,7 @@ import { registerSpeedTools } from "./speed-tools.js";
 import { registerUsageTools } from "./usage-tools.js";
 import { registerLogsTools } from "./logs-tools.js";
 import { registerBrainTools } from "./brain-tools.js";
+import { registerApprovalsTools } from "./approvals-tools.js";
 import { registerSourcesTools } from "./sources-tools.js";
 import { TOWER_SERVER_ICONS } from "./server-icons.js";
 import { installToolRegistration } from "./tool-registration.js";
@@ -487,6 +489,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 });
@@ -519,5 +523,7 @@ export function createServer(deps, options = {}) {
     // BLI-12859: Tower's incident queue (one incident, one issue, per recurring log problem), over
     // the same GET /api/brain/incidents door `cockpit brain status` reads. Read-only.
     registerBrainTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-16945: the approvals inbox, over the same /api/approvals doors the page and `cockpit approvals` call.
+    registerApprovalsTools(server, { fetchImpl: deps.fetchImpl });
     return server;
 }

package/dist/tool-annotations.d.ts

@@ -17,7 +17,7 @@ export interface TowerToolAnnotations {
  * Writes a person cannot take back by writing again: deletes, revokes,
  * detaches and a merge. These also carry `destructiveHint: true`.
  */
-export declare const DESTRUCTIVE_TOOLS: readonly ["docs_delete", "cal_delete", "cal_detach", "mail_detach", "notes_detach", "notes_rmdir", "glossary_remove", "settings_delete", "team_device_revoke", "github_merge"];
+export declare const DESTRUCTIVE_TOOLS: readonly ["docs_delete", "cal_delete", "cal_detach", "mail_detach", "notes_detach", "notes_rmdir", "glossary_remove", "settings_delete", "team_device_revoke", "github_merge", "approvals_rules_revoke"];
 /**
  * Tools the HOSTED server leaves out, each with the reason. A hosted process
  * is one machine answering many people: a tool that reads that machine's

package/dist/tool-annotations.js

@@ -24,6 +24,7 @@ export const DESTRUCTIVE_TOOLS = [
     "settings_delete",
     "team_device_revoke",
     "github_merge",
+    "approvals_rules_revoke",
 ];
 /**
  * Tools the HOSTED server leaves out, each with the reason. A hosted process

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", "approvals_list", "approvals_show", "approvals_rules"];
 /**
  * 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).
@@ -21,7 +21,7 @@ export declare const DRY_RUN_TOOLS: readonly ["ops_recompile", "memory_requeue"]
  * candidates, share calendars. Never called by the smoke; covered by the unit
  * suites (`write-tools.test.ts` and each family's own).
  */
-export declare const WRITE_TOOLS: readonly ["logs_key_mint", "brain_retry", "emit_event", "docs_create", "docs_update", "docs_delete", "docs_link", "msg_create_channel", "msg_dm", "msg_send", "work_create_issue", "work_update_issue", "work_move_issue", "work_comment_issue", "careers_rescreen", "careers_send_takehome", "careers_invite", "careers_grade", "careers_decide", "careers_followup", "careers_interview", "careers_takehome_set", "careers_settings_set", "rename_resolve", "github_merge", "github_retitle", "github_rerun", "mail_send", "mail_draft", "mail_rename", "mail_enable", "mail_disable", "mail_default", "mail_remove", "cal_change", "mail_sync", "mail_detach", "cal_create", "cal_share", "cal_sync", "cal_detach", "cal_delete", "jarvis_dispatch", "glossary_add", "glossary_remove", "notes_mkdir", "notes_rmdir", "notes_rename", "notes_upload", "notes_paste", "notes_share", "notes_unshare", "notes_move", "notes_sync", "notes_detach", "memory_experience", "scout_start", "scout_dismiss", "scout_undo", "brief_rewrite", "brief_correct", "brief_done", "brief_undone", "settings_set", "settings_delete", "model_set", "team_invite", "team_role", "team_grant", "team_revoke", "team_device_revoke", "team_device_doctor"];
+export declare const WRITE_TOOLS: readonly ["approvals_create", "approvals_approve", "approvals_edit", "approvals_reject", "approvals_rules_create", "approvals_rules_revoke", "logs_key_mint", "brain_retry", "emit_event", "docs_create", "docs_update", "docs_delete", "docs_link", "msg_create_channel", "msg_dm", "msg_send", "work_create_issue", "work_update_issue", "work_move_issue", "work_comment_issue", "careers_rescreen", "careers_send_takehome", "careers_invite", "careers_grade", "careers_decide", "careers_followup", "careers_interview", "careers_takehome_set", "careers_settings_set", "rename_resolve", "github_merge", "github_retitle", "github_rerun", "mail_send", "mail_draft", "mail_rename", "mail_enable", "mail_disable", "mail_default", "mail_remove", "cal_change", "mail_sync", "mail_detach", "cal_create", "cal_share", "cal_sync", "cal_detach", "cal_delete", "jarvis_dispatch", "glossary_add", "glossary_remove", "notes_mkdir", "notes_rmdir", "notes_rename", "notes_upload", "notes_paste", "notes_share", "notes_unshare", "notes_move", "notes_sync", "notes_detach", "memory_experience", "scout_start", "scout_dismiss", "scout_undo", "brief_rewrite", "brief_correct", "brief_done", "brief_undone", "settings_set", "settings_delete", "model_set", "team_invite", "team_role", "team_grant", "team_revoke", "team_device_revoke", "team_device_doctor"];
 /** Reads that spend a model turn. The smoke's `--no-model` leaves these out. */
 export declare const MODEL_SPENDING_TOOLS: readonly ["jarvis_ask", "jarvis_check"];
 /**

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",
@@ -99,6 +101,10 @@ export const READ_TOOLS = [
     "logs_digest",
     // BLI-12859: Tower's incident queue, per project. Reads only.
     "brain_status",
+    // BLI-16945: the approvals inbox and its standing rules. Reads only.
+    "approvals_list",
+    "approvals_show",
+    "approvals_rules",
 ];
 /**
  * Tools that write, but answer a dry run that writes nothing. The smoke calls
@@ -111,6 +117,13 @@ export const DRY_RUN_TOOLS = ["ops_recompile", "memory_requeue"];
  * suites (`write-tools.test.ts` and each family's own).
  */
 export const WRITE_TOOLS = [
+    // BLI-16945: approve runs the guarded act; a rule sends without asking. Never smoked.
+    "approvals_create",
+    "approvals_approve",
+    "approvals_edit",
+    "approvals_reject",
+    "approvals_rules_create",
+    "approvals_rules_revoke",
     "logs_key_mint",
     "brain_retry",
     "emit_event",

package/dist/verb-census-spellings.js

@@ -22,6 +22,8 @@
 export const TYPED_SPELLING = {
     // The action is `invite`; the button, the help wall and the docs all say
     // send-takehome, so that is what a stranger is told to type.
+    "approvals rules-create": "approvals rules create",
+    "approvals rules-revoke": "approvals rules revoke",
     "careers invite": "careers send-takehome",
     "careers takehome-show": "careers takehome show",
     "careers takehome-set": "careers takehome set",

package/dist/verb-census.js

@@ -244,6 +244,15 @@ export const MCP_TWINS = {
     "logs": { tool: "logs_digest", door: "LOCAL @bli-cockpit/telemetry-core/log-digest (this machine's logs); `project` reads GET /api/logs (the stored digests)" },
     "brain retry": { tool: "brain_retry", door: "POST /api/brain/incidents/retry" },
     "brain status": { tool: "brain_status", door: "GET /api/brain/incidents" },
+    "approvals list": { tool: "approvals_list", door: "GET /api/approvals" },
+    "approvals show": { tool: "approvals_show", door: "GET /api/approvals/[id]" },
+    "approvals create": { tool: "approvals_create", door: "POST /api/approvals" },
+    "approvals approve": { tool: "approvals_approve", door: "POST /api/approvals/[id]/approve" },
+    "approvals edit": { tool: "approvals_edit", door: "PATCH /api/approvals/[id]" },
+    "approvals reject": { tool: "approvals_reject", door: "POST /api/approvals/[id]/reject" },
+    "approvals rules": { tool: "approvals_rules", door: "GET /api/approvals/rules" },
+    "approvals rules-create": { tool: "approvals_rules_create", door: "POST /api/approvals/rules" },
+    "approvals rules-revoke": { tool: "approvals_rules_revoke", door: "POST /api/approvals/rules/[id]/revoke" },
     "usage sessions": { tool: "usage_sessions", door: "GET /api/usage/sessions" },
     "setup": { tool: "setup_read", door: "GET /api/setup" },
     // BLI-13033: times the data door of every rail page; the twin runs the same GETs.
@@ -354,6 +363,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.116",
   "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",