@bli-cockpit/mcp 0.1.2 → 0.1.4

package/dist/pages-tools.js

@@ -0,0 +1,190 @@
+/**
+ * `scout_board` / `workbook_read` MCP tools (BLI-3756) — the two read-only
+ * `/api/cockpit/**` pages, over the same doors `cockpit scout` and
+ * `cockpit workbook` call with the same device token.
+ *
+ * **The sentences belong to the page, not to this file.** Both doors return
+ * the finished words the browser renders — Scout's standing lines come from
+ * `lib/cockpit/scout-lines.ts`, and the workbook's markdown comes from
+ * `lib/workbook/to-markdown.ts` walking the same static elements the page
+ * renders. A tool that reworded either would eventually disagree with the page
+ * about what happened, and an agent would have no way to tell which was right.
+ *
+ * **A bounded read says so.** The Scout door returns at most 8 cards and 12
+ * signals and reports the totals in `coverage`; a truncated board and a quiet
+ * board must never read alike.
+ *
+ * Moving a Scout card (`scout_start`/`scout_dismiss`/`scout_undo`, BLI-3756
+ * batch 2) is super_admin server-side, so those three RELAY a decision rather
+ * than making one — and each reads the board first, so an id is matched
+ * exactly against cards that exist and a refusal still hands back the read.
+ */
+import { z } from "zod";
+import { callAgentDoor } from "./agent-door.js";
+import { doorFailureText, errorResult, registrarFor, textResult, queryString, withSession, } from "./tool-result.js";
+/** "8 of 23 (truncated)" — never a bare count that hides what was left out. */
+function coverageWord(coverage, shown) {
+    if (!coverage)
+        return String(shown);
+    const total = coverage.total ?? null;
+    return `${coverage.returned ?? shown}${total === null ? "" : ` of ${total}`}${coverage.truncated ? " (truncated)" : ""}`;
+}
+export function registerPagesTools(server, deps) {
+    const register = registrarFor(server);
+    register("scout_board", {
+        title: "Read the Tower Scout board",
+        description: "The experiment cards Scout is proposing, the ones already settled, and the raw signals behind them — plus "
+            + "the page's own standing sentences. Read only; moving a card is not on this surface.",
+        inputSchema: {
+            days: z.number().int().min(1).max(365).optional().describe("How many days of signals to look back over."),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const params = new URLSearchParams();
+        if (typeof args.days === "number")
+            params.set("days", String(args.days));
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/cockpit/scout${queryString(params)}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("scout_board", response));
+        const board = (response.body.board ?? {});
+        const lines = (response.body.lines ?? {});
+        const experiments = board.experiments ?? [];
+        const settled = board.settled ?? [];
+        const signals = board.signals ?? [];
+        const said = [lines.watch, lines.headline, lines.quiet].filter(Boolean).join("\n");
+        const cards = experiments
+            .map((card) => `  ${card.id ?? "?"}  ${card.status ?? "?"}  ${card.title ?? ""}\n    ${card.claimSummary ?? ""}`)
+            .join("\n");
+        const settledCards = settled.map((card) => `  ${card.id ?? "?"}  ${card.title ?? ""}`).join("\n");
+        const rawSignals = signals.map((signal) => `  ${signal.source ?? "?"}  ${signal.title ?? ""}`).join("\n");
+        return textResult(`${said}\n\n${lines.waitingLabel ?? "OPEN"} — ${coverageWord(board.coverage?.openExperiments, experiments.length)}`
+            + `${cards ? `\n${cards}` : ""}`
+            + `\n\n${lines.settledLabel ?? "SETTLED"} — ${coverageWord(board.coverage?.settledExperiments, settled.length)}`
+            + `${settledCards ? `\n${settledCards}` : ""}`
+            + `\n\n${lines.rawWatchLabel ?? "SIGNALS"} — ${coverageWord(board.coverage?.signals, signals.length)}`
+            + `${rawSignals ? `\n${rawSignals}` : `\n  ${lines.rawWatchEmpty ?? ""}`}`, {
+            audience: response.body.audience ?? null,
+            windowDays: response.body.windowDays ?? board.windowDays ?? null,
+            board,
+            lines,
+        });
+    }));
+    register("workbook_read", {
+        title: "Read the Tower workbook",
+        description: "The per-project document library. With no arguments: every project and the documents in it. With `project` "
+            + "and `doc`: that document as markdown, rendered by the same walker the page uses.",
+        inputSchema: {
+            project: z.string().min(1).max(200).optional().describe("A project slug, as workbook_read lists it."),
+            doc: z.string().min(1).max(200).optional().describe("A document slug within that project. Needs `project` too."),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const wantsDoc = Boolean(args.doc);
+        if (wantsDoc && !args.project) {
+            return errorResult("workbook_read needs `project` beside `doc` — a document slug is only unique within its project.");
+        }
+        const params = new URLSearchParams();
+        if (wantsDoc) {
+            params.set("project", String(args.project));
+            params.set("doc", String(args.doc));
+        }
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/cockpit/workbook${queryString(params)}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("workbook_read", response));
+        if (wantsDoc) {
+            const markdown = typeof response.body.markdown === "string" ? response.body.markdown : "";
+            if (markdown === "") {
+                return errorResult(`Tower answered workbook_read without a document for ${String(args.project)}/${String(args.doc)}.`);
+            }
+            return textResult(markdown, {
+                project: response.body.project ?? null,
+                doc: response.body.doc ?? null,
+                markdown,
+                sections: response.body.sections ?? [],
+            });
+        }
+        const projects = (Array.isArray(response.body.projects) ? response.body.projects : []);
+        // A named project that is not there is a refusal with the list beside
+        // it: an agent that guessed a slug can fix the guess in one step.
+        if (args.project) {
+            const found = projects.find((project) => project.slug === args.project);
+            if (!found) {
+                const known = projects.map((project) => project.slug ?? "").filter(Boolean);
+                return errorResult(`No project "${String(args.project)}" in the workbook library (${known.join(", ") || "none"}).`);
+            }
+            const docs = (found.docs ?? []).map((doc) => `  ${doc.slug ?? "?"}  ${doc.title ?? ""}`).join("\n");
+            return textResult(`${found.title ?? found.slug ?? ""}\n${found.line ?? ""}${docs ? `\n${docs}` : ""}`, { project: found });
+        }
+        const docCount = projects.reduce((count, project) => count + (project.docs?.length ?? 0), 0);
+        const lines = projects
+            .map((project) => {
+            const docs = (project.docs ?? []).map((doc) => `  ${doc.slug ?? "?"}  ${doc.title ?? ""}`).join("\n");
+            return `${(project.title ?? project.slug ?? "").toUpperCase()} (${project.slug ?? "?"})${docs ? `\n${docs}` : ""}`;
+        })
+            .join("\n\n");
+        return textResult(`WORKBOOK · ${projects.length} project(s) · ${docCount} document(s).${lines ? `\n\n${lines}` : ""}`, { projects });
+    }));
+    // BLI-3756 batch 2: the three verbs that MOVE a Scout card. Deciding a card
+    // is super_admin server-side and reading the board is not, so a refusal here
+    // never costs the caller the read it already had — the open cards come back
+    // beside the refusal, exactly as `cockpit scout` leaves the board on stdout.
+    for (const action of SCOUT_ACTIONS) {
+        register(`scout_${action}`, {
+            title: SCOUT_TITLES[action],
+            description: SCOUT_DESCRIPTIONS[action],
+            inputSchema: {
+                experiment_id: z
+                    .string()
+                    .min(1)
+                    .max(200)
+                    .describe("A full experiment id, exactly as scout_board reports it. No prefixes on this surface."),
+            },
+        }, async (args) => withSession(deps, async (session) => {
+            const experimentId = String(args.experiment_id ?? "");
+            // The board is read FIRST, as the CLI does: it is what says whether
+            // the id names a card that exists, and it is what a refused caller
+            // still gets to keep.
+            const read = await callAgentDoor(session, deps.fetchImpl, "GET", "/api/cockpit/scout");
+            if (!read.ok)
+                return errorResult(doorFailureText(`scout_${action}`, read));
+            const board = (read.body.board ?? {});
+            const open = board.experiments ?? [];
+            const card = [...open, ...(board.settled ?? [])].find((one) => one.id === experimentId);
+            if (!card) {
+                // The exact-match rule, and the list to fix a wrong guess from in
+                // one step. Never a prefix: a near-miss that resolved to the wrong
+                // card would settle an experiment nobody decided on.
+                const known = open.map((one) => `  ${one.id ?? "?"}  ${one.title ?? ""}`).join("\n");
+                return errorResult(`Refused (unknown_experiment): no card on the Scout board has the id "${experimentId}". `
+                    + `Ids come from scout_board and are matched exactly.${known ? `\n\nOpen cards:\n${known}` : ""}`);
+            }
+            const serverAction = action === "undo" ? "undo_dismiss" : action;
+            const applied = await callAgentDoor(session, deps.fetchImpl, "POST", "/api/cockpit/scout", {
+                experiment_id: experimentId,
+                action: serverAction,
+            });
+            if (!applied.ok) {
+                const gate = applied.status === 403
+                    ? " Deciding a Scout card is a super_admin action; reading the board is not."
+                    : "";
+                return errorResult(`${doorFailureText(`scout_${action}`, applied)}${gate}`);
+            }
+            return textResult(`${SCOUT_PAST_TENSE[action]} ${experimentId} · ${card.claimSummary ?? card.title ?? "that card"}`, { ok: true, action: serverAction, experiment: applied.body.experiment ?? null });
+        }));
+    }
+}
+/** The three verbs `cockpit scout` has beyond reading the board. */
+export const SCOUT_ACTIONS = ["start", "dismiss", "undo"];
+const SCOUT_TITLES = {
+    start: "Start a Scout experiment",
+    dismiss: "Dismiss a Scout card",
+    undo: "Restore a dismissed Scout card",
+};
+const SCOUT_DESCRIPTIONS = {
+    start: "Marks one experiment card as being run — `cockpit scout start`, same door. super_admin, decided on the server.",
+    dismiss: "Sets one experiment card aside — `cockpit scout dismiss`, same door. Reversible with scout_undo. super_admin, decided on the server.",
+    undo: "Puts a dismissed card back on the board — `cockpit scout undo`, which the door calls `undo_dismiss`. super_admin, decided on the server.",
+};
+const SCOUT_PAST_TENSE = {
+    start: "Started",
+    dismiss: "Dismissed",
+    undo: "Restored",
+};

package/dist/readme-census.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The README's verb table, rendered from the census (BLI-3756).
+ *
+ * `npm run mcp:readme` writes the output of `renderCensusMarkdown()` between
+ * the two markers below, and `readme-census.test.ts` fails when the committed
+ * README no longer matches — so the table a stranger reads and the map the
+ * suite polices cannot disagree. A table typed by hand beside a list of tools
+ * is a table that goes stale on the next batch; this one cannot.
+ *
+ * Pure: it reads the census (which reads the collector's own decision tables)
+ * and returns a string. No file writing here — that is the script's job, so
+ * this can be asserted without touching a disk.
+ */
+export declare const CENSUS_BEGIN = "<!-- BEGIN GENERATED verb census \u2014 `npm run mcp:readme` -->";
+export declare const CENSUS_END = "<!-- END GENERATED verb census -->";
+export declare function renderCensusMarkdown(): string;
+/** The README with a fresh census block spliced in. Throws if the markers are gone. */
+export declare function spliceCensus(readme: string): string;

package/dist/readme-census.js

@@ -0,0 +1,79 @@
+/**
+ * The README's verb table, rendered from the census (BLI-3756).
+ *
+ * `npm run mcp:readme` writes the output of `renderCensusMarkdown()` between
+ * the two markers below, and `readme-census.test.ts` fails when the committed
+ * README no longer matches — so the table a stranger reads and the map the
+ * suite polices cannot disagree. A table typed by hand beside a list of tools
+ * is a table that goes stale on the next batch; this one cannot.
+ *
+ * Pure: it reads the census (which reads the collector's own decision tables)
+ * and returns a string. No file writing here — that is the script's job, so
+ * this can be asserted without touching a disk.
+ */
+import { AWAITING_TWIN, MCP_TWINS, TERMINAL_ONLY, towerVerbs } from "./verb-census.js";
+export const CENSUS_BEGIN = "<!-- BEGIN GENERATED verb census — `npm run mcp:readme` -->";
+export const CENSUS_END = "<!-- END GENERATED verb census -->";
+/** `cockpit docs read` → `` `cockpit docs read` ``; `jarvis --trace` keeps its flag. */
+function spell(verb) {
+    return `\`cockpit ${verb}\``;
+}
+export function renderCensusMarkdown() {
+    // Every verb the collector's own tables name, plus the one hand-entered mode
+    // flag — in the same order the census sorts them, so a diff is readable.
+    const verbs = [...new Set([...towerVerbs().map((verb) => verb.spelling), ...Object.keys(MCP_TWINS)])].sort();
+    const twinRows = verbs
+        .filter((verb) => MCP_TWINS[verb])
+        .map((verb) => {
+        const twin = MCP_TWINS[verb];
+        return `| ${spell(verb)} | \`${twin.tool}\` | \`${twin.door}\` |`;
+    });
+    const owedRows = verbs
+        .filter((verb) => AWAITING_TWIN[verb])
+        .map((verb) => `| ${spell(verb)} | ${AWAITING_TWIN[verb]} |`);
+    const terminalRows = verbs
+        .filter((verb) => TERMINAL_ONLY[verb])
+        .map((verb) => `| ${spell(verb)} | ${TERMINAL_ONLY[verb]} |`);
+    return [
+        CENSUS_BEGIN,
+        "",
+        `**${twinRows.length} of ${twinRows.length + owedRows.length + terminalRows.length} 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",
+        "three tables below.",
+        "",
+        "| CLI verb | MCP tool | Door |",
+        "| --- | --- | --- |",
+        ...twinRows,
+        "",
+        "### Owed a twin",
+        "",
+        "This table should only ever shrink.",
+        "",
+        // An empty table is a rendering wart AND a lost claim: "nothing is owed"
+        // is the thing a reader wants to know, and a bare header does not say it.
+        ...(owedRows.length === 0
+            ? ["_Nothing. Every Tower verb an agent could want has a door (BLI-3756)._"]
+            : ["| CLI verb | Who owes it, and why it is not built yet |", "| --- | --- |", ...owedRows]),
+        "",
+        "### Terminal-only",
+        "",
+        "A claim about the verb's nature, not a backlog.",
+        "",
+        ...(terminalRows.length === 0
+            ? ["_Nothing: no verb has been claimed as impossible._"]
+            : ["| CLI verb | Why it can never have a twin |", "| --- | --- |", ...terminalRows]),
+        "",
+        CENSUS_END,
+    ].join("\n");
+}
+/** The README with a fresh census block spliced in. Throws if the markers are gone. */
+export function spliceCensus(readme) {
+    const start = readme.indexOf(CENSUS_BEGIN);
+    const end = readme.indexOf(CENSUS_END);
+    if (start < 0 || end < 0) {
+        throw new Error(`README.md has no census markers. Put ${CENSUS_BEGIN} and ${CENSUS_END} back, or the generated table has nowhere to go.`);
+    }
+    return readme.slice(0, start) + renderCensusMarkdown() + readme.slice(end + CENSUS_END.length);
+}

package/dist/search-tool.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `tower_search` — one bar over five corpora, as an MCP tool (BLI-3728).
+ *
+ * The same `GET /api/search` door the browser's search bar and `cockpit
+ * search` press, over this machine's device token
+ * (`agent-door-session.ts`/`agent-door.ts`). Nothing about ranking, scoping or
+ * snippets is decided here; this file turns one HTTP answer into one tool
+ * result.
+ *
+ * WHY IT IS ONE TOOL AND NOT FIVE
+ * -------------------------------
+ * `docs_list`, `msg_read` and the rest already exist and answer "show me this
+ * corpus". The question this tool answers is different and is the reason the
+ * ticket exists: "where in Tower is the thing I half-remember?" A model that
+ * has to pick a corpus before it can look has already been asked to know the
+ * answer. `kinds` narrows it when the model DOES know.
+ *
+ * Its result carries provenance, and that is not decoration: every hit says
+ * which corpus produced it, what its address is, and — for the corpora that
+ * could not answer — that they did not. A tool result that folds "messages
+ * failed" into "no messages matched" invites the model to report the record as
+ * silent when nobody asked it. That is the same rule the door, the CLI and the
+ * browser overlay all keep.
+ */
+import { loadAgentDoorSession } from "./agent-door-session.js";
+import { type FetchImpl } from "./agent-door.js";
+export interface SearchToolDeps {
+    fetchImpl: FetchImpl;
+    /** Injectable for tests; defaults to reading `~/.config/bli-cockpit/session.json`. */
+    loadSession?: typeof loadAgentDoorSession;
+}
+interface SearchHit {
+    kind: string;
+    id: string;
+    title: string;
+    snippet: string;
+    date: string | null;
+    author: string | null;
+    href: string | null;
+    score: number;
+    channels: string[];
+}
+export declare function registerSearchTool(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: SearchToolDeps): void;
+/**
+ * The sentence a model reads.
+ *
+ * Every line carries its own provenance — corpus, address, author, date — so a
+ * model quoting a result can cite it without a second call, and so a `Source:`
+ * line in its answer is copied rather than invented.
+ */
+export declare function renderHits(query: string, hits: readonly SearchHit[], failures: Record<string, string>): string;
+export {};

package/dist/search-tool.js

@@ -0,0 +1,134 @@
+/**
+ * `tower_search` — one bar over five corpora, as an MCP tool (BLI-3728).
+ *
+ * The same `GET /api/search` door the browser's search bar and `cockpit
+ * search` press, over this machine's device token
+ * (`agent-door-session.ts`/`agent-door.ts`). Nothing about ranking, scoping or
+ * snippets is decided here; this file turns one HTTP answer into one tool
+ * result.
+ *
+ * WHY IT IS ONE TOOL AND NOT FIVE
+ * -------------------------------
+ * `docs_list`, `msg_read` and the rest already exist and answer "show me this
+ * corpus". The question this tool answers is different and is the reason the
+ * ticket exists: "where in Tower is the thing I half-remember?" A model that
+ * has to pick a corpus before it can look has already been asked to know the
+ * answer. `kinds` narrows it when the model DOES know.
+ *
+ * Its result carries provenance, and that is not decoration: every hit says
+ * which corpus produced it, what its address is, and — for the corpora that
+ * could not answer — that they did not. A tool result that folds "messages
+ * failed" into "no messages matched" invites the model to report the record as
+ * silent when nobody asked it. That is the same rule the door, the CLI and the
+ * browser overlay all keep.
+ */
+import { z } from "zod";
+import { loadAgentDoorSession } from "./agent-door-session.js";
+import { callAgentDoor } from "./agent-door.js";
+const KINDS = ["doc", "msg", "issue", "note", "memory"];
+const KIND_LABELS = {
+    doc: "Document",
+    msg: "Message",
+    issue: "Issue",
+    note: "Meeting note",
+    memory: "Memory",
+};
+function textResult(text, structured) {
+    return {
+        content: [{ type: "text", text }],
+        ...(structured ? { structuredContent: structured } : {}),
+    };
+}
+function errorResult(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}
+export function registerSearchTool(server, deps) {
+    const register = server.registerTool.bind(server);
+    register("tower_search", {
+        title: "Search everything in Tower",
+        description: "One search over documents, messages, issues, meeting notes and BLI Memory. Use it when you know WHAT you are looking for but not WHERE it lives. Every result names the corpus it came from and where to open it; a memory has no page, so its text is the whole record. A corpus that could not answer is reported separately from one that found nothing — do not read a failure as silence.",
+        inputSchema: {
+            query: z.string().min(2).max(1000).describe("What to look for, in the words a person would type."),
+            kinds: z
+                .array(z.enum(KINDS))
+                .optional()
+                .describe("Narrow to these corpora. Omit to search all five."),
+            limit: z.number().int().min(1).max(50).optional().describe("Results to return (default 20)."),
+        },
+    }, async (args) => {
+        const loadSession = deps.loadSession ?? loadAgentDoorSession;
+        const loaded = loadSession();
+        if (!loaded.ok) {
+            return errorResult(`This machine is not paired with Tower (${loaded.reason}). ${loaded.message}`);
+        }
+        const query = String(args.query ?? "");
+        const params = new URLSearchParams({ q: query });
+        if (Array.isArray(args.kinds) && args.kinds.length > 0) {
+            params.set("kinds", args.kinds.join(","));
+        }
+        if (typeof args.limit === "number")
+            params.set("limit", String(args.limit));
+        const response = await callAgentDoor(loaded.session, deps.fetchImpl, "GET", `/api/search?${params.toString()}`);
+        if (!response.ok) {
+            if (response.transportError) {
+                return errorResult(`Tower could not be reached for tower_search (${response.transportError}). Nothing was searched — this is an outage, not an empty result.`);
+            }
+            const reason = typeof response.body.reason === "string" ? response.body.reason : "unknown_error";
+            const message = typeof response.body.message === "string"
+                ? response.body.message
+                : `Tower answered ${response.status}.`;
+            return errorResult(`Tower refused tower_search (${reason}): ${message}`);
+        }
+        const hits = (Array.isArray(response.body.hits) ? response.body.hits : []);
+        const failures = (response.body.failures ?? {});
+        return textResult(renderHits(query, hits, failures), {
+            query,
+            hits,
+            failures,
+            elapsedMs: response.body.elapsedMs ?? null,
+        });
+    });
+}
+/**
+ * The sentence a model reads.
+ *
+ * Every line carries its own provenance — corpus, address, author, date — so a
+ * model quoting a result can cite it without a second call, and so a `Source:`
+ * line in its answer is copied rather than invented.
+ */
+export function renderHits(query, hits, failures) {
+    const lines = [];
+    const failed = Object.entries(failures);
+    if (hits.length === 0) {
+        lines.push(failed.length === 0
+            ? `Nothing in Tower matches "${query}". Every corpus answered — the record is silent on this, it did not fail.`
+            : `Nothing matched "${query}" in the corpora that answered.`);
+    }
+    else {
+        lines.push(`${hits.length} result(s) for "${query}".`);
+        lines.push("");
+        for (const hit of hits) {
+            const label = KIND_LABELS[hit.kind] ?? hit.kind;
+            lines.push(`${label}: ${hit.title}`);
+            if (hit.snippet)
+                lines.push(`  ${hit.snippet.replace(/\s+/g, " ").trim()}`);
+            const provenance = [
+                `Source: ${label.toLowerCase()}`,
+                hit.href ? `at ${hit.href}` : "no page — the text above is the whole record",
+                hit.author ? `by ${hit.author}` : null,
+                hit.date ? `on ${hit.date.slice(0, 10)}` : null,
+                `matched by ${(hit.channels ?? []).join(" + ") || "unknown channel"}`,
+            ]
+                .filter(Boolean)
+                .join(", ");
+            lines.push(`  ${provenance}`);
+            lines.push("");
+        }
+    }
+    // Never folded into "nothing matched". A model that cannot tell them apart
+    // will report the record as silent when the search was simply broken.
+    for (const [kind, reason] of failed) {
+        lines.push(`${KIND_LABELS[kind] ?? kind} search did not answer (${reason}). Nothing from that corpus is in this list — do not conclude it holds nothing.`);
+    }
+    return lines.join("\n").trim();
+}

package/dist/server.d.ts

@@ -19,7 +19,7 @@ export interface ServerDeps {
     fetchImpl: FetchImpl;
 }
 export declare const PACKAGE_NAME = "@bli-cockpit/mcp";
-export declare const PACKAGE_VERSION = "0.1.2";
+export declare const PACKAGE_VERSION = "0.1.4";
 export declare const emitEventInput: {
     ticket_id: z.ZodString;
     event_type: z.ZodString;

package/dist/server.js

@@ -6,11 +6,21 @@
  */
 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 { registerJarvisTools } from "./jarvis-tools.js";
+import { registerNotesTools } from "./notes-tools.js";
+import { registerNotesWriteTools } from "./notes-write-tools.js";
+import { registerOpsTools } from "./ops-tools.js";
+import { registerPagesTools } from "./pages-tools.js";
+import { registerSearchTool } from "./search-tool.js";
+import { registerSettingsTools } from "./settings-tools.js";
+import { registerSettingsWriteTools } from "./settings-write-tools.js";
+import { registerTeamWriteTools } from "./team-write-tools.js";
 import { registerWorkTools } from "./work-tools.js";
 export const PACKAGE_NAME = "@bli-cockpit/mcp";
-export const PACKAGE_VERSION = "0.1.2";
+export const PACKAGE_VERSION = "0.1.4";
 // ---- input schemas (Zod raw shapes) -----------------------------------------
 export const emitEventInput = {
     ticket_id: z
@@ -380,5 +390,28 @@ export function createServer(deps) {
     // as the three families above, over the doors `cockpit jarvis` already
     // calls. It is the last Tower surface that had a CLI door and no MCP one.
     registerJarvisTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-3756 batch 1: the READS the CLI already had and this server did not —
+    // the daily page, the meeting-notes library, the ops board, Slack coverage,
+    // settings/team/model, Scout and the workbook. Same doors, same device
+    // token, same refusal words; `verb-census.test.ts` is what says the list is
+    // complete.
+    registerBriefTools(server, { fetchImpl: deps.fetchImpl });
+    registerNotesTools(server, { fetchImpl: deps.fetchImpl });
+    registerOpsTools(server, { fetchImpl: deps.fetchImpl });
+    registerSettingsTools(server, { fetchImpl: deps.fetchImpl });
+    registerPagesTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-3756 batch 2: the WRITES. Same doors, same device token, same refusal
+    // words — and one rule the reads never needed: an act that cannot be undone
+    // (share, delete, revoke, role change) is refused without `confirm: true`,
+    // because `--yes` or a person at a keyboard is the CLI's gate and a client
+    // has no keyboard. `verb-census.test.ts` is what says the list is complete;
+    // `AWAITING_TWIN` is empty as of this batch.
+    registerBriefWriteTools(server, { fetchImpl: deps.fetchImpl });
+    registerNotesWriteTools(server, { fetchImpl: deps.fetchImpl });
+    registerSettingsWriteTools(server, { fetchImpl: deps.fetchImpl });
+    registerTeamWriteTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-3728: one search over documents, messages, issues, meeting notes and
+    // memory. Same door, same ranking, same snippets the browser bar shows.
+    registerSearchTool(server, { fetchImpl: deps.fetchImpl });
     return server;
 }

package/dist/settings-tools.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `settings_*` / `team_*` / `model_show` MCP tools (BLI-3756) — the settings
+ * surface read by an agent, over the same `/api/settings/*` and `/api/team/*`
+ * doors `cockpit settings`, `cockpit team` and `cockpit model` call with the
+ * same device token.
+ *
+ * One file because the dashboard has one owner for all of it (`lib/settings/`
+ * behind `settings-gate.ts`, which the team directory and the model shorthand
+ * both sit behind), and because the reads share the rule below.
+ *
+ * **"Admin only" is not an error.** A 403 on a section is the system working;
+ * `settings_show` renders it as one line saying so and keeps every other
+ * section, exactly as the CLI does. Returning `isError` for the whole call
+ * would teach an agent that the surface is broken when in fact it is simply
+ * not this caller's to see.
+ *
+ * **A secret never comes back.** `settings_list` lists env-blob NAMES, sizes
+ * and stamps — the server cannot return a value and nothing here asks for one.
+ * Writing content is stdin-only by rule and stays in batch 2.
+ */
+import { type ToolDeps } from "./tool-result.js";
+export type SettingsDeps = ToolDeps;
+/** The sections `cockpit settings [section]` reads, plus the all-at-once view. */
+export declare const SETTINGS_SECTIONS: readonly ["overview", "personal", "switches", "models", "cli-floor"];
+export declare function registerSettingsTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: SettingsDeps): void;
+/** `provider:model`, or `unset`. The same rendering `cockpit model show` prints. */
+export declare function modelKeyOf(value: unknown): string;