@bli-cockpit/mcp 0.1.1 → 0.1.3

package/dist/jarvis-tools.js

@@ -0,0 +1,248 @@
+/**
+ * `jarvis_*` MCP tools (BLI-3732) — JARVIS on the `bli-tower` server, over the
+ * exact doors `cockpit jarvis` calls with this machine's device token.
+ *
+ * The point of this file in one sentence: an agent on Codex or Claude Code
+ * should be able to ask JARVIS a question, read how it answered, and spend a
+ * human's coding-arm approval, without a browser and without a second
+ * vocabulary. Four tools, three doors, no new server-side surface:
+ *
+ *   jarvis_ask       POST /api/jarvis/cli      one turn, the same one
+ *                                              `cockpit jarvis` takes
+ *   jarvis_trace     GET  /api/ops/trace/<id>  that turn's step tree, rendered
+ *                                              SERVER-side and printed verbatim
+ *   jarvis_dispatch  POST /api/jarvis/cli      a coding-arm turn, carrying the
+ *   jarvis_check                               person's own approval code
+ *
+ * The wire mechanics they share — the session gate, the request the dashboard
+ * actually receives, the envelope it becomes, and what `last` resolves to —
+ * live in `jarvis-door.ts`, so this file reads as four tool descriptions,
+ * which is the part a person and a model both have to understand.
+ *
+ * ## The one contract
+ *
+ * `jarvis_ask` answers with `jarvis-answer-envelope.ts` — the same object
+ * `cockpit jarvis --json` prints. A script and an agent read one shape.
+ *
+ * ## The approval code, and what this surface can and cannot prove
+ *
+ * The coding arm's gate (BLI-2981) has two locks: the code is an HMAC over the
+ * exact plan folded with the asking account, and it must have come out of the
+ * HUMAN's own message. Lock 1 is untouched here — this server holds no secret
+ * and cannot compute a code for any plan, so an invented code is refused by
+ * the dashboard exactly as it always was.
+ *
+ * Lock 2 is weaker on THIS surface than it is in a terminal, and saying so is
+ * the honest thing to do. In a terminal the person types the code themselves.
+ * Through MCP the code arrives as a tool argument, and the dashboard cannot
+ * tell a code a person handed their agent from one the agent lifted out of the
+ * previous answer by itself. So: this tool takes the code as a parameter, it
+ * NEVER derives, guesses or fabricates one, its description tells the model in
+ * plain words that the code must come from the person, and every relay is
+ * logged (presence and length only, never the code). Anything stronger — a
+ * per-code single use, an out-of-band confirmation — is a server-side change
+ * to the gate itself and belongs with the gate, not here.
+ */
+import { z } from "zod";
+import { callAgentDoor } from "./agent-door.js";
+import { APPROVAL_CODE, defaultLog, doorFailureText, errorResult, READ_TIMEOUT_MS, resolveLastTurn, TAG, takeTurn, textResult, withSession, } from "./jarvis-door.js";
+export function registerJarvisTools(server, deps) {
+    const register = server.registerTool.bind(server);
+    // The newest turn this SERVER took, so `jarvis_trace last` works in a fresh
+    // process that has asked something but never opened a terminal. It is only
+    // ever read here; the collector's own bookmark file is read as a fallback
+    // and deliberately never written, so a background agent cannot clobber the
+    // turn a person is in the middle of tracing.
+    let lastTurn = { turnId: null, traceThreadId: null };
+    const remember = (turn) => {
+        if (turn.turnId || turn.traceThreadId)
+            lastTurn = turn;
+    };
+    register("jarvis_ask", {
+        title: "Ask JARVIS",
+        description: "Asks JARVIS one question and returns its answer, the Source: lines behind it, this turn's "
+            + "turn_id and the conversation's thread_id. Same JARVIS, same tool belt and same evidence "
+            + "rules as Tower web chat, the Slack DM and `cockpit jarvis`. Pass thread to continue an "
+            + "earlier conversation; pass the returned turn_id to jarvis_trace to see how the answer was "
+            + "reached. JARVIS speaks as the person this machine is paired to and cannot be made to "
+            + "speak as anyone else.",
+        inputSchema: {
+            question: z.string().min(1).max(50_000).describe("What to ask, in plain words."),
+            thread: z
+                .string()
+                .min(1)
+                .max(200)
+                .optional()
+                .describe('The conversation to continue. Omit for "main", the default terminal thread.'),
+            subject: z
+                .string()
+                .min(1)
+                .max(200)
+                .optional()
+                .describe("Whose person page the question is ABOUT (a name or email). Never who is authenticated — "
+                + "the server decides what this caller may read about them."),
+            date: z
+                .string()
+                .min(1)
+                .max(20)
+                .optional()
+                .describe('YYYY-MM-DD, "today" or "yesterday" — binds that day\'s page. Sent verbatim.'),
+            model: z
+                .string()
+                .min(1)
+                .max(120)
+                .optional()
+                .describe("A provider:model key to request. An unknown key is refused by the dashboard."),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const { result } = await takeTurn(deps, session, "jarvis_ask", {
+            question: String(args.question ?? ""),
+            thread: typeof args.thread === "string" ? args.thread : "main",
+            ...(typeof args.subject === "string" ? { subject: args.subject } : {}),
+            ...(typeof args.date === "string" ? { date: args.date } : {}),
+            ...(typeof args.model === "string" ? { model: args.model } : {}),
+        }, remember);
+        return result;
+    }));
+    register("jarvis_trace", {
+        title: "How JARVIS answered",
+        description: "The step tree of one JARVIS turn — every model step, tool call and server-side memory step, "
+            + "with how long each took, which model ran it, what it spent and what failed. This is the "
+            + "same tree `cockpit jarvis --trace` prints, rendered by the server and relayed verbatim. "
+            + 'Metadata only: no prompt, no answer, no tool argument. Pass "last" for the newest turn '
+            + "this server asked, or the turn_id jarvis_ask returned.",
+        inputSchema: {
+            turn_id: z
+                .string()
+                .min(1)
+                .max(200)
+                .describe('A turn_id from jarvis_ask, or "last".'),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const log = deps.log ?? defaultLog;
+        const requested = String(args.turn_id ?? "");
+        let traceId = requested;
+        let resolvedFrom = "argument";
+        if (requested.toLowerCase() === "last") {
+            const resolved = await resolveLastTurn(deps, session, lastTurn);
+            if (!resolved.ok) {
+                log(`${TAG} trace unavailable ${JSON.stringify({ reason: resolved.reason })}`);
+                return errorResult(resolved.message);
+            }
+            traceId = resolved.traceId;
+            resolvedFrom = resolved.from;
+        }
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/ops/trace/${encodeURIComponent(traceId)}`, undefined, READ_TIMEOUT_MS);
+        if (!response.ok)
+            return errorResult(doorFailureText("jarvis_trace", response));
+        const body = response.body;
+        if (body.ok === false) {
+            log(`${TAG} trace unavailable ${JSON.stringify({ reason: body.error ?? "trace_unavailable" })}`);
+            return errorResult(`Tower has no step tree for that turn (${body.error ?? "trace_unavailable"}). `
+                + (body.message ?? "Traces are kept for 30 days."));
+        }
+        const lines = body.lines ?? [];
+        log(`${TAG} trace read ${JSON.stringify({
+            resolved_from: resolvedFrom,
+            lines: lines.length,
+            truncated: body.truncated ?? false,
+        })}`);
+        const rendered = [
+            `Turn ${traceId}`,
+            ...(body.headline ? [body.headline] : []),
+            "",
+            ...(lines.length > 0 ? lines : ["That turn recorded no steps."]),
+            ...(body.truncated ? ["", "Only the first 1000 spans of this turn are shown."] : []),
+        ].join("\n");
+        return textResult(rendered, {
+            turn_id: traceId,
+            resolved_from: resolvedFrom,
+            headline: body.headline ?? null,
+            lines,
+            truncated: body.truncated ?? false,
+            ...(body.trace ? { trace: body.trace } : {}),
+        });
+    }));
+    register("jarvis_dispatch", {
+        title: "Dispatch a coding task to JARVIS's coding arm",
+        description: "Asks JARVIS to run a coding task on the runner: it clones the repo, works, pushes a branch "
+            + "and opens a pull request. It never merges. TWO CALLS, always. Call this once WITHOUT "
+            + "approval_code to get the plan and the 8-character confirmation code back; show both to the "
+            + "person; call it again with the code THEY give you and the same instruction. Never derive, "
+            + "guess, or reuse a code the person has not just handed you — a code you produce yourself is "
+            + "exactly what the approval gate exists to refuse.",
+        inputSchema: {
+            instruction: z
+                .string()
+                .min(1)
+                .max(50_000)
+                .describe("What the coding task should do, in full. This is the birth prompt the arm runs."),
+            repo: z
+                .string()
+                .min(1)
+                .max(200)
+                .optional()
+                .describe("Which repo, if the instruction does not already name one. Server-side allowlist applies."),
+            approval_code: z
+                .string()
+                .min(1)
+                .max(64)
+                .optional()
+                .describe("The 8-character hex confirmation code THE PERSON read back to you from the previous "
+                + "call's plan. Omit it on the first call."),
+            thread: z.string().min(1).max(200).optional().describe('Defaults to "main".'),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const log = deps.log ?? defaultLog;
+        const code = typeof args.approval_code === "string" ? args.approval_code.trim() : "";
+        if (code.length > 0 && !APPROVAL_CODE.test(code)) {
+            // Refused HERE rather than relayed: a malformed code cannot be the
+            // one JARVIS issued, and pasting it into the question would put
+            // unvalidated text where the server scans for approvals.
+            log(`${TAG} dispatch refused ${JSON.stringify({ reason: "approval_code_malformed", chars: code.length })}`);
+            return errorResult("That approval code is not a confirmation code (it must be exactly 8 hex characters, "
+                + "e.g. 3f9c1a02). Ask the person for the code JARVIS printed with the plan — do not "
+                + "construct one.");
+        }
+        log(`${TAG} dispatch relay ${JSON.stringify({
+            approval_code_present: code.length > 0,
+            instruction_chars: String(args.instruction ?? "").length,
+            repo_named: typeof args.repo === "string",
+        })}`);
+        const question = [
+            code.length > 0
+                ? "Dispatch this coding task to the coding arm now."
+                : "Propose a coding task for the coding arm. Do not dispatch it yet — read back the plan and the confirmation code so the person can approve it.",
+            ...(typeof args.repo === "string" ? [`Repo: ${args.repo}`] : []),
+            "",
+            String(args.instruction ?? ""),
+            ...(code.length > 0
+                ? ["", `The person approved this plan. Confirmation code: ${code.toLowerCase()}`]
+                : []),
+        ].join("\n");
+        const { result } = await takeTurn(deps, session, "jarvis_dispatch", { question, thread: typeof args.thread === "string" ? args.thread : "main" }, remember);
+        return result;
+    }));
+    register("jarvis_check", {
+        title: "Check a dispatched coding task",
+        description: "Asks JARVIS where a coding task it dispatched has got to — queued, running, pushed, or "
+            + "failed, and the pull request when there is one. Takes no approval: reading a task's state "
+            + "starts nothing.",
+        inputSchema: {
+            task: z
+                .string()
+                .min(1)
+                .max(200)
+                .optional()
+                .describe("The task id JARVIS named when it dispatched. Omit to ask about the recent ones."),
+            thread: z.string().min(1).max(200).optional().describe('Defaults to "main".'),
+        },
+    }, async (args) => withSession(deps, async (session) => {
+        const task = typeof args.task === "string" ? args.task.trim() : "";
+        const question = task.length > 0
+            ? `Check the coding task ${task} and tell me its status, its branch and its pull request if it has one.`
+            : "Check the coding tasks dispatched for me recently and tell me the status of each.";
+        const { result } = await takeTurn(deps, session, "jarvis_check", { question, thread: typeof args.thread === "string" ? args.thread : "main" }, remember);
+        return result;
+    }));
+}

package/dist/jarvis-turn-bookmark.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The turn `cockpit jarvis --trace last` would open, read from the same
+ * bookmark the collector writes (BLI-3560, read here for BLI-3732).
+ *
+ * `jarvis_trace last` prefers the turn THIS server just took. This file is the
+ * fallback for the other case: a fresh MCP process that has asked nothing yet,
+ * on a machine where the person has been talking to JARVIS in a terminal. Both
+ * surfaces then mean the same turn by "last", which is the whole point.
+ *
+ * READ ONLY, deliberately. A background agent asking questions must not
+ * overwrite the bookmark a person is in the middle of tracing, so this server
+ * never writes the file — only `cockpit jarvis` does.
+ *
+ * The file holds two opaque ids and a timestamp. No question, no answer, no
+ * name. Nothing here ever throws: a missing or unreadable bookmark is "nothing
+ * is remembered", which is a real answer and the caller says so in a sentence.
+ */
+/** The collector's own name for it — `jarvis-trace.ts` `LAST_TURN_FILE`. */
+export declare const LAST_TURN_FILE = "last-turn-trace.json";
+export interface CollectorTurnBookmark {
+    traceId: string | null;
+    threadId: string | null;
+}
+export declare function collectorTurnBookmarkPath(homeDir?: string): string;
+export declare function readCollectorTurnBookmark(homeDir?: string): Promise<CollectorTurnBookmark | null>;

package/dist/jarvis-turn-bookmark.js

@@ -0,0 +1,43 @@
+/**
+ * The turn `cockpit jarvis --trace last` would open, read from the same
+ * bookmark the collector writes (BLI-3560, read here for BLI-3732).
+ *
+ * `jarvis_trace last` prefers the turn THIS server just took. This file is the
+ * fallback for the other case: a fresh MCP process that has asked nothing yet,
+ * on a machine where the person has been talking to JARVIS in a terminal. Both
+ * surfaces then mean the same turn by "last", which is the whole point.
+ *
+ * READ ONLY, deliberately. A background agent asking questions must not
+ * overwrite the bookmark a person is in the middle of tracing, so this server
+ * never writes the file — only `cockpit jarvis` does.
+ *
+ * The file holds two opaque ids and a timestamp. No question, no answer, no
+ * name. Nothing here ever throws: a missing or unreadable bookmark is "nothing
+ * is remembered", which is a real answer and the caller says so in a sentence.
+ */
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { getUserLocalCockpitPaths } from "@bli-cockpit/telemetry-core";
+/** The collector's own name for it — `jarvis-trace.ts` `LAST_TURN_FILE`. */
+export const LAST_TURN_FILE = "last-turn-trace.json";
+export function collectorTurnBookmarkPath(homeDir = os.homedir()) {
+    return path.join(getUserLocalCockpitPaths(homeDir).state_dir, LAST_TURN_FILE);
+}
+export async function readCollectorTurnBookmark(homeDir) {
+    try {
+        const raw = await readFile(collectorTurnBookmarkPath(homeDir), "utf8");
+        const parsed = JSON.parse(raw);
+        const traceId = typeof parsed.traceId === "string" ? parsed.traceId : null;
+        const threadId = typeof parsed.threadId === "string" ? parsed.threadId : null;
+        if (!traceId && !threadId)
+            return null;
+        return { traceId, threadId };
+    }
+    catch {
+        // Missing, unreadable, or not JSON — all three mean the same thing to the
+        // one caller, which names it (`no_remembered_turn`) rather than printing
+        // nothing.
+        return null;
+    }
+}

package/dist/notes-tools.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `notes_*` MCP tools (BLI-3756) — the meeting-notes library, read by an
+ * agent, over the same `/api/notes/**` doors `cockpit notes` calls with the
+ * same device token.
+ *
+ * **The narrowing is always said out loud.** `lib/notes/api-doors.ts` gives a
+ * caller with no signed-in browser session a NARROWER read and names it in the
+ * answer's own `scope`/`degradedBecause` — a device token is exactly such a
+ * caller, so an agent reading this library is routinely seeing less than a
+ * person would in a browser. Every tool here appends that reason to its text.
+ * Swallowing it would let an agent conclude a note was never taken when in
+ * fact it simply was not this caller's to read, which is a fact invented out
+ * of a permission.
+ *
+ * Reads only. `notes move|share|unshare|paste|upload` are batch 2 — sharing is
+ * a deliberate act and the paste door takes a body on stdin by rule.
+ */
+import { type ToolDeps } from "./tool-result.js";
+export type NotesDeps = ToolDeps;
+interface ScopedBody {
+    scope?: string;
+    degradedBecause?: string | null;
+    degradedNote?: string;
+}
+/**
+ * The door's own words for "this answer is narrower than the browser's", or
+ * "" when it was not narrowed. Never rephrased here.
+ */
+export declare function narrowingNote(body: ScopedBody): string;
+export declare function registerNotesTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: NotesDeps): void;
+export {};

package/dist/notes-tools.js

@@ -0,0 +1,143 @@
+/**
+ * `notes_*` MCP tools (BLI-3756) — the meeting-notes library, read by an
+ * agent, over the same `/api/notes/**` doors `cockpit notes` calls with the
+ * same device token.
+ *
+ * **The narrowing is always said out loud.** `lib/notes/api-doors.ts` gives a
+ * caller with no signed-in browser session a NARROWER read and names it in the
+ * answer's own `scope`/`degradedBecause` — a device token is exactly such a
+ * caller, so an agent reading this library is routinely seeing less than a
+ * person would in a browser. Every tool here appends that reason to its text.
+ * Swallowing it would let an agent conclude a note was never taken when in
+ * fact it simply was not this caller's to read, which is a fact invented out
+ * of a permission.
+ *
+ * Reads only. `notes move|share|unshare|paste|upload` are batch 2 — sharing is
+ * a deliberate act and the paste door takes a body on stdin by rule.
+ */
+import { z } from "zod";
+import { callAgentDoor } from "./agent-door.js";
+import { 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.
+ */
+export function narrowingNote(body) {
+    if (!body.degradedBecause)
+        return "";
+    return `\n\n(scope: ${body.scope ?? "unknown"} — ${body.degradedBecause}. `
+        + `${body.degradedNote ?? "This answer is narrower than the browser's."})`;
+}
+function libraryQuery(args) {
+    const params = new URLSearchParams();
+    if (args.shelf)
+        params.set("series", String(args.shelf));
+    if (args.kind)
+        params.set("kind", String(args.kind));
+    if (args.since)
+        params.set("since", String(args.since));
+    if (args.until)
+        params.set("until", String(args.until));
+    if (typeof args.limit === "number")
+        params.set("limit", String(args.limit));
+    return params;
+}
+const LIBRARY_FILTERS = {
+    shelf: z.string().min(1).max(200).optional().describe("Only this shelf (the library calls it a series)."),
+    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(),
+};
+export function registerNotesTools(server, deps) {
+    const register = registrarFor(server);
+    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. "
+            + "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))}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("notes_list", response));
+        const body = response.body;
+        const series = body.series ?? [];
+        const lines = series
+            .map((shelf) => {
+            const notes = shelf.notes
+                .map((note) => {
+                const who = note.participants.length > 0 ? ` — ${note.participants.join(", ")}` : "";
+                return `  ${note.meetingDate}  ${note.id}  ${note.fileName}${who}`;
+            })
+                .join("\n");
+            return `${shelf.heading} (${shelf.notes.length})\n${notes}`;
+        })
+            .join("\n\n");
+        return textResult(`${body.count ?? 0} note(s)${body.more ? ", and more exist beyond the limit" : ""}.`
+            + `${lines ? `\n\n${lines}` : ""}${narrowingNote(body)}`, { scope: body.scope ?? null, count: body.count ?? 0, more: body.more ?? false, series });
+    }));
+    register("notes_show", {
+        title: "Read one Tower meeting note",
+        description: "One note's title, date, shelf, participants and full text, by its id (notes_list returns ids).",
+        inputSchema: { id: z.string().min(1).max(200).describe("A note id.") },
+    }, async (args) => withSession(deps, async (session) => {
+        const ref = String(args.id ?? "");
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/notes/library/${encodeURIComponent(ref)}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("notes_show", response));
+        const body = response.body;
+        const note = body.note;
+        if (!note) {
+            return errorResult(`Tower answered notes_show without a note for "${ref}".${narrowingNote(body)}`);
+        }
+        const room = note.participants.length > 0 ? `\nIn the room: ${note.participants.join(", ")}` : "";
+        return textResult(`${note.title}\n${note.meetingDate}  ·  ${note.shelf}  ·  ${note.fileName}  ·  ${note.lineCount} lines`
+            + `${room}\n${note.visibility}\n\n${note.content}${narrowingNote(body)}`, { scope: body.scope ?? null, note });
+    }));
+    register("notes_shelf", {
+        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() },
+    }, async (args) => withSession(deps, async (session) => {
+        const params = new URLSearchParams();
+        if (typeof args.limit === "number")
+            params.set("limit", String(args.limit));
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/notes/shelf${queryString(params)}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("notes_shelf", response));
+        const body = response.body;
+        const notes = body.notes ?? [];
+        const lines = notes
+            .map((note) => {
+            const counts = note.countsKnown
+                ? `${note.statements} statements, ${note.openToTheTeam} open to the team, ${note.keptBack} kept back`
+                : "counts unknown on this server";
+            return `${note.meetingDate}  ${note.id}  ${note.shared ? "shared" : "yours"}  ${note.name}\n    ${counts}`;
+        })
+            .join("\n");
+        return textResult(`${notes.length} note(s) on your shelf.${lines ? `\n${lines}` : ""}${narrowingNote(body)}`, { scope: body.scope ?? null, notes });
+    }));
+    register("notes_shelves", {
+        title: "List Tower note shelves",
+        description: "The shelves the library is grouped into and how many notes are on each — a shelf somebody typed is marked "
+            + "as such, one implied by the meeting kind is not. Pass a heading to notes_list's `shelf`.",
+        inputSchema: LIBRARY_FILTERS,
+    }, async (args) => withSession(deps, async (session) => {
+        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/notes/library${queryString(libraryQuery(args))}`);
+        if (!response.ok)
+            return errorResult(doorFailureText("notes_shelves", response));
+        const body = response.body;
+        // The same derivation `commands/notes-reads.ts` does, kept identical on
+        // purpose: a shelf is free text, so only the typed ones are marked.
+        const shelves = (body.series ?? []).map((one) => ({
+            shelf: one.heading,
+            notes: one.notes.length,
+            custom: (body.categories ?? []).includes(one.heading),
+        }));
+        const lines = shelves
+            .map((shelf) => `${String(shelf.notes).padStart(4)}  ${shelf.shelf}${shelf.custom ? "" : "  (from the meeting kind)"}`)
+            .join("\n");
+        return textResult(`${shelves.length} shelf/shelves.${lines ? `\n${lines}` : ""}${narrowingNote(body)}`, { scope: body.scope ?? null, shelves });
+    }));
+}

package/dist/ops-tools.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `ops_status` / `slack_*` MCP tools (BLI-3756) — the `/api/ops/**` board an
+ * agent can open, over the same doors `cockpit ops` and `cockpit slack` call
+ * with the same device token.
+ *
+ * These three share a file because they share a door family and a gate, not
+ * because they share a noun. `lib/ops/pipeline-status.ts` is the one place
+ * that knows a job's EXPECTED INTERVAL — written next to its reader, so a
+ * once-daily job quiet for 18 hours reads healthy (BLI-3276) — and no verdict
+ * is computed here. This surface reports the server's verdicts and counts the
+ * unhealthy ones so an agent does not have to know the vocabulary to notice a
+ * red board.
+ *
+ * `ops recompile` stays out: it spends a model call and wants its own gate on
+ * this surface (batch 2).
+ */
+import { type ToolDeps } from "./tool-result.js";
+export type OpsDeps = ToolDeps;
+/**
+ * The verdicts that mean something is wrong, verbatim from `commands/ops.ts`.
+ * `failing` is its own word and not a shade of `stale` (BLI-3723): a failing
+ * reader's input is CURRENT and its answer is bad.
+ */
+export declare const UNHEALTHY_VERDICTS: Set<string>;
+export declare function registerOpsTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: OpsDeps): void;