@bli-cockpit/mcp 0.1.59 → 0.1.63

package/dist/memory-consolidation-tools.js

@@ -16,6 +16,20 @@
 import { z } from "zod";
 import { callAgentDoor } from "./agent-door.js";
 import { doorFailureText, errorResult, queryString, registrarFor, textResult, withSession, } from "./tool-result.js";
+/** `{merge: 2, rewrite: 1}` as `merge 2, rewrite 1`; `none` when empty. */
+function counts(value) {
+    if (!value || typeof value !== "object")
+        return "none";
+    const entries = Object.entries(value);
+    return entries.length === 0 ? "none" : entries.map(([key, count]) => `${key} ${String(count)}`).join(", ");
+}
+function runLine(run) {
+    const cost = typeof run.costUsd === "number" ? `$${run.costUsd.toFixed(4)}` : "$?";
+    return `${String(run.startedAt ?? "?")}  ${String(run.containerTag ?? "?")}  ${String(run.mode ?? "?")}  `
+        + `clusters ${String(run.clusters ?? 0)}; proposed ${counts(run.proposed)}; applied ${counts(run.applied)}; `
+        + `refused ${counts(run.refused)}; ${cost}${run.model ? ` ${String(run.model)}` : ""}`
+        + `${run.reason ? `  (${String(run.reason)})` : ""}`;
+}
 export function registerMemoryConsolidationTools(server, deps) {
     registrarFor(server)("memory_consolidation", {
         title: "Read the nightly memory consolidation runs",
@@ -44,10 +58,14 @@ export function registerMemoryConsolidationTools(server, deps) {
         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 runs = (Array.isArray(response.body.runs) ? response.body.runs : []);
         const reason = typeof response.body.reason === "string" ? response.body.reason : "runs_read";
+        // 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");
         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);
+            : `${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.`
+                + `\n${lines}`, response.body);
     }));
 }

package/dist/memory-experience-tools.js

@@ -7,7 +7,11 @@ export function registerMemoryExperienceTools(server, deps) {
     registrarFor(server)("memory_experience", {
         title: "Log a memory-store experience",
         description: "Append an experience receipt locally and post to Tower. Offline receipts ship on the next collector sync. Copy the recall marker: [bli] = BLI Memory, ◪ = Supermemory. Opinions only; never prompts, memory bodies or secrets.",
-        inputSchema: { store: z.enum(["bli", "supermemory", "both"]), verdict: z.enum(["win", "loss", "noise"]), reason: z.string().min(1).max(500) },
+        inputSchema: {
+            store: z.enum(["bli", "supermemory", "both"]).describe("Which store the recall came from: [bli] is BLI Memory, ◪ is Supermemory."),
+            verdict: z.enum(["win", "loss", "noise"]).describe("win: it shaped the answer. loss: it misled or was missing. noise: it came back and did not matter."),
+            reason: z.string().min(1).max(500).describe("Why, in one line. Never a prompt, a memory body or a secret."),
+        },
     }, async (args) => {
         const entry = await appendExperience({ store: args.store, verdict: args.verdict, reason: String(args.reason) }, { homeDir: deps.homeDir, agent: "MCP", project: "workspace" });
         const delivery = await shipExperience(entry, async (body) => {

package/dist/models-tools.js

@@ -28,7 +28,7 @@ export function registerModelsTools(server, deps) {
         description: "Every model Tower knows about: the provider's documented context window, price per million, reasoning "
             + "modes and tool support, beside our measured latency, observed tokens/s and last probe verdict. "
             + "`STALE:<field>` means a measurement contradicted the documentation, with the command that re-reads the "
-            + "provider. Read-only.",
+            + "provider. One line per model; models_card reads one model in full. Read-only.",
         inputSchema: {},
     }, async () => withSession(deps, async (session) => {
         const response = await callAgentDoor(session, deps.fetchImpl, "GET", "/api/models/cards");
@@ -39,10 +39,23 @@ export function registerModelsTools(server, deps) {
         const lines = (Array.isArray(body.lines) ? body.lines : []);
         const stale = cards.filter((card) => (card.stale?.length ?? 0) > 0).map((card) => card.id ?? "?");
         const unreadable = (Array.isArray(body.unreadable) ? body.unreadable : []);
+        // The structured half is the shelf's INDEX, the same facts the lines
+        // print. Whole cards (documented, measured and bench blocks) were 39 KB
+        // for 14 models on 2026-09-26, and models_card reads one in full
+        // (BLI-10432).
+        const index = cards.map((card) => ({
+            id: card.id ?? null,
+            display_name: card.display_name ?? null,
+            provider: card.provider ?? null,
+            model: card.model ?? null,
+            status: card.status ?? null,
+            slots: card.slots ?? null,
+            stale: (card.stale ?? []).map((entry) => entry.field ?? "?"),
+        }));
         return textResult(`${cards.length} model card(s)`
             + `${stale.length > 0 ? `, ${stale.length} stale: ${stale.join(", ")}` : ", none stale"}`
             + `${unreadable.length > 0 ? `, ${unreadable.length} unreadable: ${unreadable.join(", ")}` : ""}`
-            + `${lines.length > 0 ? `\n${lines.join("\n")}` : ""}`, { cards, stale, unreadable });
+            + `${lines.length > 0 ? `\n${lines.join("\n")}` : ""}`, { cards: index, lines, stale, unreadable });
     }));
     register("models_card", {
         title: "Read one model card",

package/dist/note-folder-tools.js

@@ -4,8 +4,11 @@ import { registrarFor, withSession, textResult, errorResult, doorFailureText } f
 export function registerNoteFolderTools(server, deps) {
     const register = registrarFor(server);
     register("notes_folders", {
-        title: "List note folders", description: "The folder tree with caller-visible note counts.",
-        inputSchema: { tree: z.boolean().optional() },
+        // `tree` was declared here and never read: the door answers one shape,
+        // flat folders with their paths, and a knob that changes nothing is a
+        // description that lies (BLI-10432).
+        title: "List note folders", description: "Every note folder you may see, as a flat list of paths with the note count in each, plus how many notes sit at the root.",
+        inputSchema: {},
     }, async () => withSession(deps, async (session) => {
         const response = await callAgentDoor(session, deps.fetchImpl, "GET", "/api/notes/folders");
         if (!response.ok)
@@ -14,7 +17,7 @@ export function registerNoteFolderTools(server, deps) {
     }));
     register("notes_mkdir", {
         title: "Create a note folder", description: "Create a path, including missing ancestors. Existing paths are reused.",
-        inputSchema: { path: z.string().min(1).max(2000) },
+        inputSchema: { path: z.string().min(1).max(2000).describe("A slash-separated folder path, e.g. Clients/Blue Pearl.") },
     }, async (args) => withSession(deps, async (session) => {
         const response = await callAgentDoor(session, deps.fetchImpl, "POST", "/api/notes/folders", { path: args.path });
         if (!response.ok)
@@ -23,7 +26,7 @@ export function registerNoteFolderTools(server, deps) {
     }));
     register("notes_rmdir", {
         title: "Delete an empty note folder", description: "Delete a folder by path. Refuses any folder with notes or children.",
-        inputSchema: { path: z.string().min(1).max(2000) },
+        inputSchema: { path: z.string().min(1).max(2000).describe("The folder's slash-separated path, as notes_folders lists it.") },
     }, async (args) => withSession(deps, async (session) => {
         const listed = await callAgentDoor(session, deps.fetchImpl, "GET", "/api/notes/folders");
         if (!listed.ok)
@@ -40,7 +43,10 @@ export function registerNoteFolderTools(server, deps) {
     }));
     register("notes_rename", {
         title: "Rename a note folder", description: "Rename a folder by path, updating every descendant path.",
-        inputSchema: { path: z.string().min(1).max(2000), name: z.string().min(1).max(120) },
+        inputSchema: {
+            path: z.string().min(1).max(2000).describe("The folder's slash-separated path, as notes_folders lists it."),
+            name: z.string().min(1).max(120).describe("The folder's new last segment. Its descendants move with it."),
+        },
     }, async (args) => withSession(deps, async (session) => {
         const listed = await callAgentDoor(session, deps.fetchImpl, "GET", "/api/notes/folders");
         if (!listed.ok)

package/dist/notes-account-tools.js

@@ -50,7 +50,7 @@ export function registerNotesAccountTools(server, deps) {
         description: "Reads the meetings this notetaker has recorded since the last pass and files them as meeting notes. "
             + "Answers with the run's own counts and reason label, which is exactly what the ledger row says. "
             + "The half-hourly cron does this unasked; this is the button for when you do not want to wait.",
-        inputSchema: { account_id: z.string().uuid() },
+        inputSchema: { account_id: z.string().uuid().describe("A notetaker account id (notes_accounts).") },
     }, async (args) => withSession(deps, async (session) => {
         const response = await callAgentDoor(session, deps.fetchImpl, "POST", `/api/notes/accounts/${encodeURIComponent(String(args.account_id))}/sync`);
         if (!response.ok)
@@ -64,7 +64,7 @@ export function registerNotesAccountTools(server, deps) {
         title: "Detach a notetaker",
         description: "Removes a notetaker account and its stored key from Tower. The account itself is untouched at the provider, "
             + "and the meetings it already filed stay where they are. Requires confirm: true.",
-        inputSchema: { account_id: z.string().uuid(), confirm: CONFIRM_INPUT },
+        inputSchema: { account_id: z.string().uuid().describe("A notetaker account id (notes_accounts)."), confirm: CONFIRM_INPUT },
     }, async (args) => withSession(deps, async (session) => {
         const refusal = unconfirmed(args, "This would detach that notetaker and forget its stored key (the account itself is untouched at the provider, and the meetings it filed stay).");
         if (refusal)

package/dist/notes-tools.js

@@ -18,7 +18,7 @@ import { registerNoteFolderTools } from "./note-folder-tools.js";
  */
 import { z } from "zod";
 import { callAgentDoor } from "./agent-door.js";
-import { doorFailureText, errorResult, registrarFor, textResult, queryString, withSession, } from "./tool-result.js";
+import { DEFAULT_LIST_LIMIT, doorFailureText, errorResult, registrarFor, textResult, queryString, withSession, } from "./tool-result.js";
 /**
  * The door's own words for "this answer is narrower than the browser's", or
  * "" when it was not narrowed. Never rephrased here.
@@ -48,7 +48,7 @@ const LIBRARY_FILTERS = {
     kind: z.string().min(1).max(100).optional().describe("Only this meeting kind."),
     since: z.string().min(1).max(20).optional().describe("YYYY-MM-DD — meetings on or after this date."),
     until: z.string().min(1).max(20).optional().describe("YYYY-MM-DD — meetings on or before this date."),
-    limit: z.number().int().min(1).max(500).optional(),
+    limit: z.number().int().min(1).max(500).optional().describe("At most this many notes."),
 };
 export function registerNotesTools(server, deps) {
     registerNoteFolderTools(server, deps);
@@ -56,10 +56,17 @@ export function registerNotesTools(server, deps) {
     register("notes_list", {
         title: "List Tower meeting notes",
         description: "The meeting-notes library you may read, grouped by shelf: id, date, kind, participants and file name. "
+            + `Newest ${DEFAULT_LIST_LIMIT} unless you pass limit (up to 500); the answer says when more exist. `
             + "Never a note's text — call notes_show for one. Says when the answer is narrower than a browser's.",
         inputSchema: LIBRARY_FILTERS,
     }, async (args) => withSession(deps, async (session) => {
-        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/notes/library${queryString(libraryQuery(args))}`);
+        // A page by default: the whole library was 136 notes and 58 KB on
+        // 2026-09-26, mostly participant lists (BLI-10432). The door reports
+        // `more` itself, so nothing here guesses.
+        const params = libraryQuery(args);
+        if (args.limit === undefined)
+            params.set("limit", String(DEFAULT_LIST_LIMIT));
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/notes/library${queryString(params)}`);
         if (!response.ok)
             return errorResult(doorFailureText("notes_list", response));
         const body = response.body;
@@ -100,7 +107,7 @@ export function registerNotesTools(server, deps) {
         title: "Your own Tower notes shelf",
         description: "The notes THIS machine's owner put in, with the per-note counts (statements, open to the team, kept back) "
             + "when the server knows them. Says so when it does not, rather than printing zeros.",
-        inputSchema: { limit: z.number().int().min(1).max(500).optional() },
+        inputSchema: { limit: z.number().int().min(1).max(500).optional().describe("At most this many notes.") },
     }, async (args) => withSession(deps, async (session) => {
         const params = new URLSearchParams();
         if (typeof args.limit === "number")

package/dist/ops-tools.js

@@ -40,6 +40,34 @@ export const UNHEALTHY_VERDICTS = new Set([
     // BLI-3762: a job that wrote less than it owed is not healthy. Amber counts.
     "degraded",
 ]);
+/**
+ * A pipeline row as the board needs it. The door's row also carries its cron
+ * string, config file, host, artifact and a paragraph-long caveat per job,
+ * which the text half never printed: 34 KB for 26 jobs (BLI-10432).
+ */
+function pipelineRow(row) {
+    return {
+        id: row.id ?? null,
+        label: row.label ?? null,
+        verdict: row.verdict ?? null,
+        latestIso: row.latestIso ?? null,
+        ageHours: row.ageHours ?? null,
+        expectedIntervalHours: row.expectedIntervalHours ?? null,
+        staleAfterHours: row.staleAfterHours ?? null,
+        detail: row.detail ?? null,
+    };
+}
+/**
+ * The fleet and coverage blocks without their per-device and per-person rows
+ * unless `people: true` asked for them. Those rows were 155 KB of the board's
+ * 175 KB structured half on 2026-09-26 (BLI-10432).
+ */
+function summaryOnly(block, withPeople) {
+    if (withPeople || !block || typeof block !== "object" || Array.isArray(block))
+        return block;
+    const { devices: _devices, people: _people, ...rest } = block;
+    return rest;
+}
 function numberOf(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
@@ -51,14 +79,16 @@ export function registerOpsTools(server, deps) {
     register("ops_status", {
         title: "Read the Tower pipeline board",
         description: "Every scheduled job's verdict against its own expected interval, plus the collector fleet and collection "
-            + "coverage. A job's `detail` is the server's sentence for why — relayed as it stands. Status only: nothing "
-            + "here fires a job.",
+            + "coverage as one summary line each (`people: true` adds the per-device and per-person rows, about 150 KB). "
+            + "A job's `detail` is the server's sentence for why — relayed as it stands. The whole board can take 25 "
+            + "seconds to read. Status only: nothing here fires a job.",
         inputSchema: {
             job: z.string().min(1).max(100).optional().describe("One pipeline id instead of the whole board."),
             skips: z.boolean().optional().describe("Also return the open ingest-skip ledgers."),
             memory: z.boolean().optional().describe("Also return memory adoption and observed prompt-hook outcomes, delay bounds and cache reuse. No memory text."),
             turns: z.boolean().optional().describe("Also return 30-day JARVIS turn aggregates: latency, hops, tools, tokens and error classes."),
             tool_router: z.boolean().optional().describe("Also return the seven-day shadow tool-router agreement board."),
+            people: z.boolean().optional().describe("Also return every device and every person behind the fleet and coverage summaries. Large."),
         },
     }, async (args) => withSession(deps, async (session) => {
         const params = new URLSearchParams();
@@ -73,6 +103,8 @@ export function registerOpsTools(server, deps) {
             return errorResult(doorFailureText("ops_status", response));
         const body = response.body;
         const rows = (Array.isArray(body.pipelines) ? body.pipelines : []);
+        const fleetSummary = typeof asRecord(body.fleet).summary === "string" ? String(asRecord(body.fleet).summary) : "";
+        const coverageSummary = typeof asRecord(body.coverage).summary === "string" ? String(asRecord(body.coverage).summary) : "";
         const unhealthy = rows.filter((row) => UNHEALTHY_VERDICTS.has(row.verdict ?? ""));
         const lines = rows
             .map((row) => `${(row.verdict ?? "?").padEnd(14)}  ${row.id ?? "?"}  ${row.detail ?? row.label ?? ""}`.trimEnd())
@@ -134,6 +166,8 @@ export function registerOpsTools(server, deps) {
         return textResult(`${rows.length} pipeline(s), ${unhealthy.length} unhealthy`
             + `${unhealthy.length > 0 ? `: ${unhealthy.map((row) => row.id ?? "?").join(", ")}` : "."}`
             + `${lines ? `\n${lines}` : ""}`
+            + `${fleetSummary ? `\nFLEET  ${fleetSummary}` : ""}`
+            + `${coverageSummary ? `\nCOVERAGE  ${coverageSummary}` : ""}`
             + `${ladderLine ? `\n${ladderLine}` : ""}`
             + `${memoryLines ? `\n${memoryLines}` : ""}`
             + `${experienceLines ? `\n${experienceLines}` : ""}`
@@ -141,10 +175,10 @@ export function registerOpsTools(server, deps) {
             + `${toolRouterLine ? `\n${toolRouterLine}` : ""}`, 
         // The API owns the wording and the timing boundary on every surface.
         {
-            pipelines: rows,
+            pipelines: rows.map(pipelineRow),
             unhealthy: unhealthy.map((row) => row.id ?? "?"),
-            ...(body.fleet ? { fleet: body.fleet } : {}),
-            ...(body.coverage ? { coverage: body.coverage } : {}),
+            ...(body.fleet ? { fleet: summaryOnly(body.fleet, args.people === true) } : {}),
+            ...(body.coverage ? { coverage: summaryOnly(body.coverage, args.people === true) } : {}),
             ...(body.skips ? { skips: body.skips } : {}),
             ...(body.ladder ? { ladder: body.ladder } : {}),
             ...(memory?.ok ? { memory: memory.body.memory, hooks: memory.body.hooks, experience: memory.body.experience } : {}),
@@ -196,7 +230,7 @@ export function registerOpsTools(server, deps) {
             query: z.string().min(1).max(500).optional().describe("Text to look for."),
             since: z.string().min(1).max(30).optional().describe("YYYY-MM-DD or ISO-8601."),
             until: z.string().min(1).max(30).optional().describe("YYYY-MM-DD or ISO-8601."),
-            limit: z.number().int().min(1).max(500).optional(),
+            limit: z.number().int().min(1).max(500).optional().describe("At most this many messages, newest first."),
         },
     }, async (args) => withSession(deps, async (session) => {
         const body = {};

package/dist/server.d.ts

@@ -19,7 +19,13 @@ export interface ServerDeps {
     fetchImpl: FetchImpl;
 }
 export declare const PACKAGE_NAME = "@bli-cockpit/mcp";
-export declare const PACKAGE_VERSION = "0.1.4";
+/**
+ * The version this server tells a client in `initialize`, read from the
+ * package's own `package.json` (which npm always ships). It was a literal
+ * `"0.1.4"` for fifty-six releases, so every client log named the wrong build
+ * (BLI-10432).
+ */
+export declare const PACKAGE_VERSION: string;
 export declare const emitEventInput: {
     ticket_id: z.ZodString;
     event_type: z.ZodString;
@@ -31,7 +37,7 @@ export declare const emitEventInput: {
     }>>;
     source: z.ZodOptional<z.ZodString>;
     actor_role: z.ZodOptional<z.ZodString>;
-    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    payload: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
     note_md: z.ZodOptional<z.ZodString>;
     correlation_id: z.ZodOptional<z.ZodString>;
     idempotency_key: z.ZodOptional<z.ZodString>;

package/dist/server.js

@@ -4,11 +4,13 @@
  * Pure factory — accepts injected fetch + base URL + token so it can be
  * unit-tested without binding to a real network or transport.
  */
+import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { registerBriefTools } from "./brief-tools.js";
 import { registerBriefWriteTools } from "./brief-write-tools.js";
 import { registerDocsMsgTools } from "./docs-msg-tools.js";
+import { registerDocsNotionTools } from "./docs-notion-tools.js";
 import { registerJarvisTools } from "./jarvis-tools.js";
 import { registerCalTools } from "./cal-tools.js";
 import { registerMailTools } from "./mail-tools.js";
@@ -30,7 +32,23 @@ import { registerWorkTools } from "./work-tools.js";
 import { registerCareersTools } from "./careers-tools.js";
 import { registerUsageTools } from "./usage-tools.js";
 export const PACKAGE_NAME = "@bli-cockpit/mcp";
-export const PACKAGE_VERSION = "0.1.4";
+/**
+ * The version this server tells a client in `initialize`, read from the
+ * package's own `package.json` (which npm always ships). It was a literal
+ * `"0.1.4"` for fifty-six releases, so every client log named the wrong build
+ * (BLI-10432).
+ */
+export const PACKAGE_VERSION = readPackageVersion();
+function readPackageVersion() {
+    try {
+        const manifest = createRequire(import.meta.url)("../package.json");
+        return typeof manifest.version === "string" ? manifest.version : "unknown";
+    }
+    catch (error) {
+        process.stderr.write(`[bli-cockpit-mcp] package.json unreadable; serving version "unknown" (${error instanceof Error ? error.message.split("\n")[0] : String(error)})\n`);
+        return "unknown";
+    }
+}
 // ---- input schemas (Zod raw shapes) -----------------------------------------
 export const emitEventInput = {
     ticket_id: z
@@ -44,7 +62,9 @@ export const emitEventInput = {
     event_version: z
         .number()
         .int()
-        .positive()
+        // `.min(1)`, not `.positive()`: the latter publishes `exclusiveMinimum`,
+        // which strict clients reject (BLI-10432).
+        .min(1)
         .optional()
         .describe("Event schema version. Defaults to 1 in the API."),
     kind: z
@@ -62,7 +82,9 @@ export const emitEventInput = {
         .optional()
         .describe("Actor role for the event. Defaults to operator."),
     payload: z
-        .record(z.string(), z.unknown())
+        // `looseObject`, not `record`: a record publishes `propertyNames`, a
+        // keyword strict clients reject (BLI-10432). Same values accepted.
+        .looseObject({})
         .optional()
         .describe("Event payload object. Defaults to {}."),
     note_md: z
@@ -335,7 +357,9 @@ function errorContent(err) {
         content: [
             {
                 type: "text",
-                text: code ? `[${code}] ${message}` : message,
+                // `ApiError`'s own message already opens with `[code]`; prefixing it
+                // again printed "[BLI-E003] [BLI-E003] …" (BLI-10432).
+                text: code && !message.startsWith(`[${code}]`) ? `[${code}] ${message}` : message,
             },
         ],
     };
@@ -392,6 +416,8 @@ export function createServer(deps) {
     // no `cockpit login` pairing yet still serves the three event tools; only a
     // docs/msg call on that machine fails, by name.
     registerDocsMsgTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-10430: docs_link, the Notion half of the docs tools, on the same path.
+    registerDocsNotionTools(server, { fetchImpl: deps.fetchImpl });
     // BLI-3716: `work_*` — the issue tracker, on the same device-token path as
     // the docs/msg tools above, for the same reason: a coding session should
     // file and move a Tower issue the way it files and moves a Linear one.

package/dist/settings-tools.js

@@ -43,6 +43,9 @@ function sectionPayload(response, door) {
         return { visible: false, reason: "admin_only" };
     return { visible: false, reason: doorFailureText(door, response) };
 }
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
 function sectionWord(response) {
     if (response.ok)
         return "ok";
@@ -55,7 +58,8 @@ async function oneSection(deps, session, tool, path) {
     const response = await readSection(deps, session, path);
     if (!response.ok)
         return errorResult(doorFailureText(tool, response));
-    return textResult(JSON.stringify(response.body, null, 2), response.body);
+    // Compact JSON: indentation was a third of what a model paid for (BLI-10432).
+    return textResult(JSON.stringify(response.body), response.body);
 }
 export function registerSettingsTools(server, deps) {
     const register = registrarFor(server);
@@ -91,7 +95,7 @@ export function registerSettingsTools(server, deps) {
             .map((key) => `${key.padEnd(10)}  ${sectionWord(byKey[key])}`)
             .join("\n");
         const payload = Object.fromEntries(keys.map((key) => [key, sectionPayload(byKey[key], `settings ${key}`)]));
-        return textResult(`TOWER SETTINGS\n${lines}\n\n${JSON.stringify(payload, null, 2)}`, payload);
+        return textResult(`TOWER SETTINGS\n${lines}\n\n${JSON.stringify(payload)}`, payload);
     }));
     register("settings_list", {
         title: "List Tower env files",
@@ -112,17 +116,36 @@ export function registerSettingsTools(server, deps) {
     }));
     register("team_members", {
         title: "Read the Tower team directory",
-        description: "Who is on this team, their roles, and any invitations still open.",
+        description: "Who is on this team: every person on the roster or with an account, their standing (account or roster "
+            + "only), Tower role and team role, and the user id team_role takes.",
         inputSchema: {},
     }, async () => withSession(deps, async (session) => {
         const response = await readSection(deps, session, "/api/team/members");
         if (!response.ok)
             return errorResult(doorFailureText("team_members", response));
-        const members = (Array.isArray(response.body.members) ? response.body.members : []);
-        const lines = members
-            .map((member) => `${String(member.role ?? "?").padEnd(12)}  ${String(member.email ?? member.userId ?? "?")}`)
+        // The door answers `people`, one row per person with an optional
+        // `account`. This read `members`, a key the door no longer sends, and
+        // answered "0 member(s)." over a twelve-person team (BLI-10432).
+        const people = (Array.isArray(response.body.people) ? response.body.people : []);
+        const team = asRecord(response.body.currentTeam);
+        const lines = people
+            .map((person) => {
+            const account = asRecord(person.account);
+            const name = String(person.name ?? person.email ?? person.key ?? "?");
+            const email = typeof person.email === "string" && person.email !== name ? ` <${person.email}>` : "";
+            const roles = typeof account.role === "string"
+                ? `  role ${account.role}${typeof account.teamRole === "string" ? `, team ${account.teamRole}` : ""}`
+                : "";
+            const id = typeof account.userId === "string" ? `  id ${account.userId}` : "";
+            return `${name}${email}  ${String(person.standing ?? "?")}${person.active === false ? " (inactive)" : ""}${roles}${id}`;
+        })
             .join("\n");
-        return textResult(`${members.length} member(s).${lines ? `\n${lines}` : ""}`, response.body);
+        const heading = typeof team.name === "string" ? `${team.name}: ` : "";
+        const rosterError = typeof response.body.rosterError === "string"
+            ? ` The roster could not be read (${response.body.rosterError}), so people without an account may be missing.`
+            : "";
+        return textResult(`${heading}${people.length} person(s).${rosterError}${response.body.canManage === true ? "" : " Read-only: only an admin can invite or change roles."}`
+            + `${lines ? `\n${lines}` : ""}`, response.body);
     }));
     register("team_device_list", {
         title: "List the collector devices Tower knows",
@@ -134,9 +157,13 @@ export function registerSettingsTools(server, deps) {
         if (!response.ok)
             return errorResult(doorFailureText("team_device_list", response));
         const devices = (Array.isArray(response.body.devices) ? response.body.devices : []);
+        // The door's row names its owner and trust state, and carries no
+        // `cli_version`: every line used to print "?" there (BLI-10432). These
+        // are the fields `cockpit team device list` prints.
         const lines = devices
             .map((device) => `${String(device.device_id ?? "?")}  ${String(device.device_name ?? "?")}  `
-            + `${String(device.cli_version ?? "?")}  last seen ${String(device.last_seen_at ?? "never")}`)
+            + `${String(device.trust_state ?? "unknown")}  owner ${String(device.owner_label ?? "?")}  `
+            + `last seen ${String(device.last_seen_at ?? "never")}${typeof device.summary === "string" ? `  ${device.summary}` : ""}`)
             .join("\n");
         return textResult(`${devices.length} device(s).${lines ? `\n${lines}` : ""}`, response.body);
     }));

package/dist/tool-catalog.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Every `bli-tower` tool, sorted by what calling it DOES (BLI-10432).
+ *
+ * `npm run mcp:smoke` calls every READ and every DRY-RUN against production
+ * and never a WRITE; `tool-catalog.test.ts` fails when a registered tool is in
+ * none of the three lists, so a new tool joins the smoke (or is declared a
+ * write) the day it is registered, not the day somebody notices.
+ *
+ * Deliberately dependency-free: `scripts/smoke.ts` imports this file straight
+ * 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_list_issues", "work_get_issue", "work_issue_history", "work_list_projects", "careers_list", "careers_show", "careers_resume_url", "careers_takehome_show", "careers_settings_show", "usage_people", "usage_sessions", "mail_accounts", "mail_inbox", "mail_read", "mail_search", "mail_attachment", "cal_today", "cal_week", "cal_next", "cal_find", "cal_calendars", "jarvis_ask", "jarvis_trace", "jarvis_check", "models_list", "models_card", "models_compare", "brief_read", "brief_history", "brief_status", "notes_folders", "notes_list", "notes_show", "notes_shelf", "notes_shelves", "notes_place", "notes_accounts", "ops_status", "slack_coverage", "slack_read", "memory_profile", "memory_consolidation", "settings_show", "settings_list", "model_show", "team_members", "team_device_list", "scout_board", "workbook_read", "tower_search"];
+/**
+ * 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).
+ */
+export declare const DRY_RUN_TOOLS: readonly ["ops_recompile", "memory_requeue"];
+/**
+ * Tools that change real data: send mail, post messages, file issues, move
+ * 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 ["emit_event", "docs_create", "docs_update", "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_takehome_set", "careers_settings_set", "mail_send", "mail_sync", "mail_detach", "cal_create", "cal_share", "cal_sync", "cal_detach", "jarvis_dispatch", "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_device_revoke"];
+/** 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"];
+/**
+ * Reads whose answer IS one whole item (a document, a transcript, a thread),
+ * so its size is the item's and not a list the caller failed to narrow. The
+ * smoke does not hold these to the per-half budget.
+ */
+export declare const SINGLE_ITEM_TOOLS: readonly ["docs_read", "notes_show", "mail_read", "workbook_read", "jarvis_trace", "models_card", "careers_show", "memory_profile"];