@bli-cockpit/mcp 0.1.0 → 0.1.2

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/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.0";
+export declare const PACKAGE_VERSION = "0.1.2";
 export declare const emitEventInput: {
     ticket_id: z.ZodString;
     event_type: z.ZodString;

package/dist/server.js

@@ -7,8 +7,10 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { registerDocsMsgTools } from "./docs-msg-tools.js";
+import { registerJarvisTools } from "./jarvis-tools.js";
+import { registerWorkTools } from "./work-tools.js";
 export const PACKAGE_NAME = "@bli-cockpit/mcp";
-export const PACKAGE_VERSION = "0.1.0";
+export const PACKAGE_VERSION = "0.1.2";
 // ---- input schemas (Zod raw shapes) -----------------------------------------
 export const emitEventInput = {
     ticket_id: z
@@ -370,5 +372,13 @@ 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-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.
+    registerWorkTools(server, { fetchImpl: deps.fetchImpl });
+    // BLI-3732: `jarvis_*` — the assistant itself, on the same device-token path
+    // 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 });
     return server;
 }

package/dist/verb-census.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Every `cockpit <noun> <verb>` that talks to Tower, read off the collector's
+ * own decision tables (BLI-3732).
+ *
+ * This is a test helper with no runtime consumer, kept out of the suite file
+ * so the census itself — the three lists a person actually reviews — reads as
+ * a list and not as a parser. It reads SOURCE TEXT rather than importing the
+ * collector, because this package declares no dependency on it (the same
+ * reason `agent-door-session.ts` copies a session reader instead of importing
+ * one).
+ *
+ * ## Where each half comes from
+ *
+ * - The NOUNS are the `parse<Noun>Args` functions `local-args-tower.ts`
+ *   re-exports. That file is the authoritative "these are the commands that
+ *   talk to Tower" table — its siblings are a filing decision, not a contract.
+ * - The VERBS are each noun's `action:` union in `LocalCommand`
+ *   (`local-args.ts`), with an `XAction` alias resolved from whichever
+ *   `local-args-tower-*.ts` declares it. A noun with no `action` field is one
+ *   verb wearing the noun's own name (`jarvis`, `correct`, `workbook`).
+ *
+ * ## What it deliberately does NOT see
+ *
+ * Mode FLAGS. `cockpit jarvis --trace`, `--threads` and `--history` are three
+ * different acts behind one noun, and no decision table calls them verbs, so
+ * the mechanical rule cannot find them. They are covered by hand in the
+ * census's own twin map (`jarvis --trace` → `jarvis_trace`); a flag that grows
+ * into a verb will show up here the moment it becomes an `action`.
+ */
+export declare const COLLECTOR_COMMANDS_DIR: string;
+export interface TowerVerb {
+    noun: string;
+    /** The action word, or "" for a noun that is its own single verb. */
+    action: string;
+    /** How a person types it: `docs read`, or just `jarvis`. */
+    spelling: string;
+}
+/** `parseJarvisArgs` → `jarvis`. The re-export table IS the noun list. */
+export declare function towerNouns(): string[];
+/** Every Tower verb a person may type today. */
+export declare function towerVerbs(): TowerVerb[];

package/dist/verb-census.js

@@ -0,0 +1,108 @@
+/**
+ * Every `cockpit <noun> <verb>` that talks to Tower, read off the collector's
+ * own decision tables (BLI-3732).
+ *
+ * This is a test helper with no runtime consumer, kept out of the suite file
+ * so the census itself — the three lists a person actually reviews — reads as
+ * a list and not as a parser. It reads SOURCE TEXT rather than importing the
+ * collector, because this package declares no dependency on it (the same
+ * reason `agent-door-session.ts` copies a session reader instead of importing
+ * one).
+ *
+ * ## Where each half comes from
+ *
+ * - The NOUNS are the `parse<Noun>Args` functions `local-args-tower.ts`
+ *   re-exports. That file is the authoritative "these are the commands that
+ *   talk to Tower" table — its siblings are a filing decision, not a contract.
+ * - The VERBS are each noun's `action:` union in `LocalCommand`
+ *   (`local-args.ts`), with an `XAction` alias resolved from whichever
+ *   `local-args-tower-*.ts` declares it. A noun with no `action` field is one
+ *   verb wearing the noun's own name (`jarvis`, `correct`, `workbook`).
+ *
+ * ## What it deliberately does NOT see
+ *
+ * Mode FLAGS. `cockpit jarvis --trace`, `--threads` and `--history` are three
+ * different acts behind one noun, and no decision table calls them verbs, so
+ * the mechanical rule cannot find them. They are covered by hand in the
+ * census's own twin map (`jarvis --trace` → `jarvis_trace`); a flag that grows
+ * into a verb will show up here the moment it becomes an `action`.
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const COLLECTOR_COMMANDS_DIR = resolve(HERE, "../../cockpit-local-collector/src/commands");
+function read(file) {
+    return readFileSync(join(COLLECTOR_COMMANDS_DIR, file), "utf8");
+}
+/** Every `local-args-tower*.ts` in the collector, so a new sibling is read too. */
+function towerFiles() {
+    return readdirSync(COLLECTOR_COMMANDS_DIR).filter((name) => name.startsWith("local-args-tower") && name.endsWith(".ts") && !name.includes(".test."));
+}
+/** `parseJarvisArgs` → `jarvis`. The re-export table IS the noun list. */
+export function towerNouns() {
+    const source = read("local-args-tower.ts");
+    const nouns = new Set();
+    for (const match of source.matchAll(/\bparse([A-Z][A-Za-z]*)Args\b/g)) {
+        nouns.add(match[1].replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase());
+    }
+    return [...nouns].sort();
+}
+/** `export type NotesAction = "list" | "show" | …` across every tower sibling. */
+function actionAliases() {
+    const aliases = new Map();
+    for (const file of towerFiles()) {
+        const source = read(file);
+        for (const match of source.matchAll(/export type (\w+Action)\s*=\s*([\s\S]*?);/g)) {
+            aliases.set(match[1], [...match[2].matchAll(/"([a-z-]+)"/g)].map((m) => m[1]));
+        }
+    }
+    return aliases;
+}
+/**
+ * The `LocalCommand` variants, split the way the union is written: one chunk
+ * per `  | {` at the top level of the type.
+ */
+function commandVariants() {
+    const source = readFileSync(join(COLLECTOR_COMMANDS_DIR, "local-args.ts"), "utf8");
+    const start = source.indexOf("export type LocalCommand =");
+    if (start < 0)
+        throw new Error("LocalCommand union not found in local-args.ts");
+    const end = source.indexOf("\nexport ", start + 10);
+    return source.slice(start, end < 0 ? undefined : end).split(/\n\s{2}\|\s/);
+}
+/** Every Tower verb a person may type today. */
+export function towerVerbs() {
+    const nouns = new Set(towerNouns());
+    const aliases = actionAliases();
+    const verbs = [];
+    const seenNouns = new Set();
+    for (const variant of commandVariants()) {
+        const kind = /kind:\s*"([a-z-]+)"/.exec(variant)?.[1];
+        if (!kind || !nouns.has(kind) || seenNouns.has(kind))
+            continue;
+        seenNouns.add(kind);
+        const action = /\n\s*action:\s*([^;]+);/.exec(variant)?.[1]?.trim();
+        if (!action) {
+            verbs.push({ noun: kind, action: "", spelling: kind });
+            continue;
+        }
+        const words = action.endsWith("Action")
+            ? (aliases.get(action) ?? [])
+            : [...action.matchAll(/"([a-z-]+)"/g)].map((m) => m[1]);
+        if (words.length === 0) {
+            throw new Error(`No action vocabulary found for cockpit ${kind} (read "${action}")`);
+        }
+        for (const word of words) {
+            verbs.push({ noun: kind, action: word, spelling: `${kind} ${word}` });
+        }
+    }
+    const missing = [...nouns].filter((noun) => !seenNouns.has(noun));
+    if (missing.length > 0) {
+        // A parser with no `LocalCommand` variant means the extraction has drifted
+        // from the source, and a census that quietly reads fewer verbs than exist
+        // is worse than no census at all.
+        throw new Error(`Tower nouns with no LocalCommand variant: ${missing.join(", ")}`);
+    }
+    return verbs.sort((a, b) => a.spelling.localeCompare(b.spelling));
+}

package/dist/work-tools.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `work_*` MCP tools (BLI-3716) — Tower's issue tracker on the `bli-tower`
+ * server, over the same `/api/work/**` doors `cockpit issue` and the browser
+ * call, authenticated with this machine's collector device token.
+ *
+ * The point of this file, in one sentence: a Claude Code or Codex session
+ * should be able to file and move a TOWER issue exactly the way it files and
+ * moves a Linear one — no browser, no uuid archaeology, no second vocabulary.
+ * So every tool takes `BLI-####` wherever an issue is named (the SERVER
+ * resolves it, `lib/work/issue-ref.ts`), and `work_create_issue` answers with
+ * the identifier it minted.
+ *
+ * Same session discipline as `docs-msg-tools.ts`: the session is loaded fresh
+ * per call, so a machine with no `cockpit login` pairing still serves this
+ * server's other tools and only a `work_` call fails, by name.
+ */
+import { loadAgentDoorSession } from "./agent-door-session.js";
+import { type FetchImpl } from "./agent-door.js";
+export interface WorkDeps {
+    fetchImpl: FetchImpl;
+    /** Injectable for tests; defaults to reading `~/.config/bli-cockpit/session.json`. */
+    loadSession?: typeof loadAgentDoorSession;
+}
+/** The closed state vocabulary, verbatim from `lib/work/api-doors.ts` `WORK_ISSUE_STATES`. */
+export declare const WORK_ISSUE_STATES: readonly ["backlog", "todo", "in_progress", "in_review", "done", "canceled"];
+export declare function registerWorkTools(server: {
+    registerTool: (...args: never[]) => unknown;
+}, deps: WorkDeps): void;