@bli-cockpit/mcp 0.1.63 → 0.1.66

package/dist/docs-msg-helpers.d.ts

@@ -53,6 +53,7 @@ export declare function docListLine(row: DocRow): string;
 export declare function docsListPath(args: {
     parent_id?: unknown;
     query?: unknown;
+    word?: unknown;
     limit?: unknown;
 }): string;
 export declare function resolveDocumentId(deps: DocsMsgDeps, session: {

package/dist/docs-msg-helpers.js

@@ -67,8 +67,12 @@ export function docsListPath(args) {
     const params = new URLSearchParams();
     if (typeof args.parent_id === "string" && args.parent_id.length > 0)
         params.set("parent_id", args.parent_id);
-    if (typeof args.query === "string" && args.query.trim().length > 0)
+    const hasQuery = typeof args.query === "string" && args.query.trim().length > 0;
+    if (hasQuery)
         params.set("query", args.query);
+    // BLI-10451: whole words, the same `word=1` the CLI's `--word` sends.
+    if (hasQuery && args.word === true)
+        params.set("word", "1");
     if (typeof args.limit === "number" && Number.isInteger(args.limit))
         params.set("limit", String(args.limit));
     // No limit named: one page plus one row, so "more exist" is read off the
@@ -102,5 +106,5 @@ export async function resolveChannelId(deps, session, ref) {
 /** One message as a line: id (msg_thread's `thread_parent_id`), time, author, text. */
 export function messageLine(message) {
     return `${String(message.id ?? "?")}  ${String(message.created_at ?? "?")}  `
-        + `${String(message.agent_label ?? message.user_id ?? "?")}  ${String(message.content ?? "")}`;
+        + `${String(message.agent_label ?? message.user_id ?? message.slack_author_label ?? "?")}  ${String(message.content ?? "")}`;
 }

package/dist/docs-msg-tools.js

@@ -13,6 +13,7 @@ import { z } from "zod";
 import { callAgentDoor } from "./agent-door.js";
 import { DEFAULT_LIST_LIMIT, doorFailureText, errorResult, moreNote, registrarFor, textResult, withSession, } from "./tool-result.js";
 import { DOCS_LIST_MAX, slimTree, renderDocTree, countTree, docListRow, docListLine, resolveDocumentId, resolveChannelId, messageLine, docsListPath } from "./docs-msg-helpers.js";
+import { runDocsReadTool } from "./docs-read-tool.js";
 export { docsListPath } from "./docs-msg-helpers.js";
 export function registerDocsMsgTools(server, deps) {
     const register = registrarFor(server);
@@ -20,11 +21,13 @@ export function registerDocsMsgTools(server, deps) {
         title: "List Tower documents",
         description: "Every document you may read: id, slug, title, visibility, source, parent_id and body_chars (how long the body is). "
             + "Never a document's body — call docs_read for that. Narrow before reading: parent_id (a document id, or \"root\" for the "
-            + "top of the tree), query (a case-insensitive substring matched in the database over title AND body, never fuzzy), "
+            + "top of the tree), query (a case-insensitive substring matched in the database over title AND body, never fuzzy; "
+            + "word: true matches it as whole words, so \"ott\" stops matching \"bottom\"), "
             + `limit (1-1000, default ${DEFAULT_LIST_LIMIT}; the answer says when more exist).`,
         inputSchema: {
             parent_id: z.string().min(1).max(64).optional().describe('A document id to list under, or "root" for the top of the tree.'),
             query: z.string().min(1).max(200).optional().describe("Keep only documents whose title or body contains this text."),
+            word: z.boolean().optional().describe("Match query as whole words rather than a substring. Needs query."),
             limit: z.number().int().min(1).max(1000).optional().describe(`At most this many documents. Default ${DEFAULT_LIST_LIMIT}.`),
         },
     }, async (args) => withSession(deps, async (session) => {
@@ -52,21 +55,25 @@ export function registerDocsMsgTools(server, deps) {
     }));
     register("docs_read", {
         title: "Read a Tower document",
-        description: "One document's title and full body, by its id or slug (docs_list returns both).",
-        inputSchema: { id: z.string().min(1).max(200).describe("A document id, or its slug.") },
-    }, async (args) => withSession(deps, async (session) => {
-        const ref = String(args.id ?? "");
-        const resolved = await resolveDocumentId(deps, session, ref);
-        if (resolved.status === "list_failed")
-            return errorResult(resolved.text);
-        if (resolved.status === "not_found")
-            return errorResult(`No document matches "${ref}" — check docs_list for the id or slug.`);
-        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/docs/documents/${encodeURIComponent(resolved.id)}`);
-        if (!response.ok)
-            return errorResult(doorFailureText("docs_read", response));
-        const document = response.body.document;
-        return textResult(`${document?.title ?? ""}\n\n${document?.body_markdown ?? ""}`, { document });
-    }));
+        description: "A document's title and body, by id or slug (docs_list returns both). Three shapes (BLI-10450): "
+            + "`id` — one document, answers { document }. `ids` — several in one call (one shared list resolve, then "
+            + "one GET per document — no bulk body door exists), answers { documents: [{ ref, ok, document|error }] }, "
+            + "one bad ref never losing the rest. `parent_id` + `bodies: true` — every document filed directly under "
+            + "that parent, bodies included, in ONE call, answers { documents: [...] }. "
+            + "`section`/`offset`/`limit` narrow whatever body was fetched, in every shape: `section` slices from a "
+            + "matching Markdown heading (any level, case-insensitive) to the next heading at the same or shallower "
+            + "level, mirroring `cockpit workbook`'s own --section; `offset`/`limit` slice by character range — for a "
+            + "100-225 KB transcript, read it in parts instead of whole.",
+        inputSchema: {
+            id: z.string().min(1).max(200).optional().describe("A document id, or its slug. Omit when passing ids or parent_id."),
+            ids: z.array(z.string().min(1).max(200)).min(1).max(50).optional().describe("Several documents in one call."),
+            parent_id: z.string().min(1).max(64).optional().describe("With bodies: true, read every document filed directly under this one (or \"root\")."),
+            bodies: z.boolean().optional().describe("Only with parent_id: include each document's body_markdown."),
+            section: z.string().min(1).max(200).optional().describe("One section's heading text — slices from there to the next heading at the same or shallower level."),
+            offset: z.number().int().min(0).optional().describe("The body's character offset to start from; paired with limit."),
+            limit: z.number().int().min(1).optional().describe("With an explicit ref: at most this many characters. With parent_id + bodies: at most this many documents (1-50)."),
+        },
+    }, async (args) => runDocsReadTool(deps, args));
     register("docs_create", {
         title: "Create a Tower document",
         description: "Creates a new document. Omitting body creates an empty one, matching the browser's own default.",
@@ -179,7 +186,15 @@ export function registerDocsMsgTools(server, deps) {
         // which is what msg_thread takes. It used to say only "2 message(s)",
         // so a Claude-family client never saw one (BLI-10432).
         const lines = messages.map(messageLine).join("\n");
-        return textResult(`${messages.length} message(s) in ${ref}, newest first; each line is id, time, author, text.${lines ? `\n${lines}` : ""}`, { channelId: resolved.id, messages });
+        // BLI-10449: Tower's own channel, or a Slack snapshot and how fresh —
+        // the door's sentence, word for word, the same line the CLI prints.
+        const provenance = (response.body.provenance ?? null);
+        const limitApplied = typeof response.body.limitApplied === "number" ? response.body.limitApplied : null;
+        const header = [
+            provenance?.sentence ?? null,
+            limitApplied !== null ? `Showing the newest ${limitApplied}: one read returns at most ${limitApplied} messages.` : null,
+        ].filter(Boolean).join("\n");
+        return textResult(`${header ? `${header}\n` : ""}${messages.length} message(s) in ${ref}, newest first; each line is id, time, author, text.${lines ? `\n${lines}` : ""}`, { channelId: resolved.id, provenance, limitApplied, messages });
     }));
     register("msg_thread", {
         title: "Read a Tower message thread",

package/dist/docs-read-tool.d.ts

@@ -0,0 +1,23 @@
+import { type DocsMsgDeps } from "./docs-msg-helpers.js";
+import { type ToolResult } from "./tool-result.js";
+/** Mirrors `commands/docs-read.ts` `sliceDocSection` exactly. */
+export declare function sliceDocSection(markdown: string, wanted: string): {
+    text: string;
+    headings: string[];
+} | null;
+/** Mirrors `commands/docs-read.ts` `sliceDocRange` exactly. */
+export declare function sliceDocRange(body: string, offset: number | undefined, limit: number | undefined): {
+    text: string;
+    truncated: boolean;
+    totalChars: number;
+};
+export interface DocsReadArgs {
+    id?: unknown;
+    ids?: unknown;
+    parent_id?: unknown;
+    bodies?: unknown;
+    section?: unknown;
+    offset?: unknown;
+    limit?: unknown;
+}
+export declare function runDocsReadTool(deps: DocsMsgDeps, args: DocsReadArgs): Promise<ToolResult>;

package/dist/docs-read-tool.js

@@ -0,0 +1,175 @@
+/**
+ * `docs_read` (BLI-10450) — the MCP twin of `cockpit docs read`'s three
+ * shapes, split out of `docs-msg-tools.ts` to keep it under the file-size
+ * ratchet:
+ *
+ * 1. `id` — unchanged: one document, `{ document }`.
+ * 2. `ids` — several references in one call. One shared list resolves every
+ *    ref (a uuid ref skips the list read entirely — `resolveDocumentIds`),
+ *    then one GET per document. `{ documents: [{ ref, ok, document|error }] }`.
+ * 3. `parent_id` + `bodies: true` — every document filed directly under that
+ *    parent, bodies included, in ONE call
+ *    (`GET /api/docs/documents?parent_id=...&bodies=true`).
+ *
+ * `section`/`offset`/`limit` narrow whatever body was fetched, in every
+ * shape above — the same slicing `commands/docs-read.ts` runs on the CLI.
+ */
+import { callAgentDoor } from "./agent-door.js";
+import { resolveDocumentId } from "./docs-msg-helpers.js";
+import { doorFailureText, errorResult, textResult, withSession } from "./tool-result.js";
+function headingsOf(markdown) {
+    return markdown
+        .split("\n")
+        .map((line, lineIndex) => ({ lineIndex, line }))
+        .map(({ lineIndex, line }) => {
+        const match = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+        return match?.[1] && match[2] ? { lineIndex, level: match[1].length, title: match[2] } : null;
+    })
+        .filter((heading) => heading !== null);
+}
+/** Mirrors `commands/docs-read.ts` `sliceDocSection` exactly. */
+export function sliceDocSection(markdown, wanted) {
+    const headings = headingsOf(markdown);
+    const target = headings.find((heading) => heading.title.toLowerCase() === wanted.trim().toLowerCase());
+    if (!target)
+        return null;
+    const lines = markdown.split("\n");
+    const next = headings.find((heading) => heading.lineIndex > target.lineIndex && heading.level <= target.level);
+    const endLine = next ? next.lineIndex : lines.length;
+    return { text: lines.slice(target.lineIndex, endLine).join("\n").trim(), headings: headings.map((h) => h.title) };
+}
+/** Mirrors `commands/docs-read.ts` `sliceDocRange` exactly. */
+export function sliceDocRange(body, offset, limit) {
+    const totalChars = body.length;
+    if (offset === undefined && limit === undefined)
+        return { text: body, truncated: false, totalChars };
+    const start = Math.min(offset ?? 0, totalChars);
+    const end = limit === undefined ? totalChars : Math.min(start + limit, totalChars);
+    return { text: body.slice(start, end), truncated: end < totalChars, totalChars };
+}
+/**
+ * `applyCharRange` is false in `parent_id` + `bodies: true` mode: there,
+ * `limit` already picked the DOCUMENT COUNT (mirrors `commands/docs-read.ts`
+ * — a live-fire probe against production caught this exact overload
+ * silently truncating every body to a handful of characters when `limit`
+ * was passed meaning "N documents").
+ */
+function narrowBody(document, section, offset, limit, applyCharRange) {
+    let body = typeof document.body_markdown === "string" ? document.body_markdown : "";
+    if (section) {
+        const sliced = sliceDocSection(body, section);
+        if (!sliced) {
+            const known = headingsOf(body).map((heading) => heading.title);
+            return { ok: false, text: `No section "${section}" in ${document.id} (${known.join(", ") || "none"}).` };
+        }
+        body = sliced.text;
+    }
+    if (applyCharRange && (offset !== undefined || limit !== undefined))
+        body = sliceDocRange(body, offset, limit).text;
+    document.body_markdown = body;
+    return { ok: true };
+}
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+/** One shared list read for every non-uuid ref, never one per ref. */
+async function resolveDocumentIds(deps, session, refs) {
+    const ids = new Map();
+    const needsList = refs.filter((ref) => !UUID_PATTERN.test(ref));
+    for (const ref of refs)
+        if (UUID_PATTERN.test(ref))
+            ids.set(ref, ref);
+    if (needsList.length === 0)
+        return { status: "ok", ids };
+    const response = await callAgentDoor(session, deps.fetchImpl, "GET", "/api/docs/documents");
+    if (!response.ok)
+        return { status: "list_failed", text: doorFailureText("docs_list", response) };
+    const documents = (Array.isArray(response.body.documents) ? response.body.documents : []);
+    for (const ref of needsList) {
+        const match = documents.find((doc) => doc.id === ref || doc.slug === ref);
+        if (match)
+            ids.set(ref, match.id);
+    }
+    return { status: "ok", ids };
+}
+async function fetchOneDocument(deps, session, ref, id) {
+    if (!id)
+        return { ref, ok: false, text: `No document matches "${ref}" — check docs_list for the id or slug.` };
+    const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/docs/documents/${encodeURIComponent(id)}`);
+    if (!response.ok)
+        return { ref, ok: false, text: doorFailureText("docs_read", response) };
+    const document = (response.body.document ?? { id });
+    return { ref, ok: true, document };
+}
+export async function runDocsReadTool(deps, args) {
+    return withSession(deps, async (session) => {
+        const section = typeof args.section === "string" ? args.section : undefined;
+        const offset = typeof args.offset === "number" ? args.offset : undefined;
+        const limit = typeof args.limit === "number" ? args.limit : undefined;
+        // Shape 3: --parent + --bodies. Built by hand rather than through
+        // `docsListPath`: that helper defaults a missing limit to
+        // DEFAULT_LIST_LIMIT + 1 for the METADATA list's "more exist" check,
+        // which would overshoot the door's own DOCUMENT_BODIES_MAX_LIMIT (50)
+        // here and turn an unset limit into a refusal.
+        if (typeof args.parent_id === "string" && args.parent_id && args.bodies === true) {
+            const params = new URLSearchParams({ parent_id: args.parent_id, bodies: "true" });
+            if (limit !== undefined)
+                params.set("limit", String(limit));
+            const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/docs/documents?${params.toString()}`);
+            if (!response.ok)
+                return errorResult(doorFailureText("docs_read", response));
+            const documents = (Array.isArray(response.body.documents) ? response.body.documents : []);
+            const misses = [];
+            for (const document of documents) {
+                // `limit` already picked the DOCUMENT COUNT above; `false` keeps it
+                // from being reapplied as a character count.
+                const narrowed = narrowBody(document, section, offset, limit, false);
+                if (!narrowed.ok)
+                    misses.push(narrowed.text);
+            }
+            return textResult(`${documents.length} document(s) under ${String(args.parent_id)}.${misses.length ? `\n${misses.join("\n")}` : ""}`, { documents });
+        }
+        // Shapes 1/2: id, or ids (several).
+        const refs = Array.isArray(args.ids) && args.ids.length > 0
+            ? args.ids.map(String)
+            : [String(args.id ?? "")];
+        if (refs.length === 1 && refs[0] === "") {
+            return errorResult("docs_read needs id, ids, or parent_id + bodies: true.");
+        }
+        const resolved = refs.length === 1
+            ? await (async () => {
+                const one = await resolveDocumentId(deps, session, refs[0]);
+                if (one.status === "list_failed")
+                    return { status: "list_failed", text: one.text };
+                const ids = new Map();
+                if (one.status === "ok")
+                    ids.set(refs[0], one.id);
+                return { status: "ok", ids };
+            })()
+            : await resolveDocumentIds(deps, session, refs);
+        if (resolved.status === "list_failed")
+            return errorResult(resolved.text);
+        const results = await Promise.all(refs.map((ref) => fetchOneDocument(deps, session, ref, resolved.ids.get(ref))));
+        for (const result of results) {
+            if (result.ok) {
+                // Not `--parent --bodies` mode: `limit` here is a CHARACTER count.
+                const narrowed = narrowBody(result.document, section, offset, limit, true);
+                if (!narrowed.ok)
+                    Object.assign(result, { ok: false, text: narrowed.text });
+            }
+        }
+        if (refs.length === 1) {
+            const [result] = results;
+            if (!result?.ok)
+                return errorResult(result?.text ?? "docs_read could not read that document.");
+            return textResult(`${result.document.title ?? ""}\n\n${result.document.body_markdown ?? ""}`, { document: result.document });
+        }
+        const failed = results.filter((result) => !result.ok);
+        const lines = results
+            .map((result) => (result.ok ? `${result.document.title ?? result.ref}\n\n${result.document.body_markdown ?? ""}` : `${result.ref}: ${result.text}`))
+            .join("\n\n---\n\n");
+        return textResult(`${results.length - failed.length}/${results.length} document(s) read.\n\n${lines}`, {
+            documents: results.map((result) => result.ok
+                ? { ref: result.ref, ok: true, document: result.document }
+                : { ref: result.ref, ok: false, error: result.text }),
+        });
+    });
+}

package/dist/notes-meeting-docs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * BLI-10449: the notes library door's pointer at meeting records that live in
+ * Docs, not Notes (`apps/dashboard/src/lib/notes/meeting-docs.ts` decides what
+ * counts and which copy is canonical). `notes_list` prints these lines under
+ * the notes; the CLI's twin is `meetingDocumentLines` in the collector's
+ * `commands/notes-reads.ts`, and the two print the same words.
+ */
+export interface MeetingDocuments {
+    count: number;
+    copies: number;
+    truncated: boolean;
+    items: Array<{
+        id: string;
+        slug: string | null;
+        title: string;
+        meetingDate: string | null;
+        visibility: string;
+        source: string;
+        bodyChars: number;
+        parts: string[];
+        canonical: boolean;
+        duplicateOf: string | null;
+        canonicalReason: string | null;
+    }>;
+}
+export declare function meetingDocumentLines(meeting: MeetingDocuments | null | undefined, readVerb: string): string[];

package/dist/notes-meeting-docs.js

@@ -0,0 +1,26 @@
+/**
+ * BLI-10449: the notes library door's pointer at meeting records that live in
+ * Docs, not Notes (`apps/dashboard/src/lib/notes/meeting-docs.ts` decides what
+ * counts and which copy is canonical). `notes_list` prints these lines under
+ * the notes; the CLI's twin is `meetingDocumentLines` in the collector's
+ * `commands/notes-reads.ts`, and the two print the same words.
+ */
+export function meetingDocumentLines(meeting, readVerb) {
+    if (!meeting || meeting.count === 0)
+        return [];
+    const refOf = new Map(meeting.items.map((item) => [item.id, item.slug ?? item.id]));
+    const copies = meeting.copies > 0 ? `, ${meeting.copies} of them ${meeting.copies === 1 ? "a copy" : "copies"}` : "";
+    const lines = [
+        `Meeting records in Docs, not in Notes (${meeting.count}${copies}). Read one with \`${readVerb} <ref>\`:`,
+    ];
+    for (const item of meeting.items) {
+        const size = `${Math.max(1, Math.round(item.bodyChars / 1000))} KB${item.parts.length > 0 ? ` in ${item.parts.length + 1} parts` : ""}`;
+        const mark = item.canonical
+            ? item.canonicalReason && item.canonicalReason !== "only_copy" ? ` · canonical (${item.canonicalReason})` : ""
+            : ` · copy of ${refOf.get(item.duplicateOf ?? "") ?? item.duplicateOf}`;
+        lines.push(`  ${item.meetingDate ?? "undated   "}  ${refOf.get(item.id)}  ${item.title}  ${item.visibility} · ${item.source} · ${size}${mark}`);
+    }
+    if (meeting.truncated)
+        lines.push("  (the read hit its cap, so there may be more)");
+    return lines;
+}

package/dist/notes-tools.js

@@ -18,6 +18,7 @@ import { registerNoteFolderTools } from "./note-folder-tools.js";
  */
 import { z } from "zod";
 import { callAgentDoor } from "./agent-door.js";
+import { meetingDocumentLines } from "./notes-meeting-docs.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
@@ -82,8 +83,16 @@ export function registerNotesTools(server, deps) {
             return `${shelf.heading} (${shelf.notes.length})\n${notes}`;
         })
             .join("\n\n");
+        const inDocs = meetingDocumentLines(body.meetingDocuments, "docs_read").join("\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 });
+            + `${lines ? `\n\n${lines}` : ""}${inDocs ? `\n\n${inDocs}` : ""}${narrowingNote(body)}`, {
+            scope: body.scope ?? null,
+            count: body.count ?? 0,
+            more: body.more ?? false,
+            series,
+            meetingDocuments: body.meetingDocuments ?? null,
+            meetingDocumentsSkipped: body.meetingDocumentsSkipped ?? null,
+        });
     }));
     register("notes_show", {
         title: "Read one Tower meeting note",

package/dist/ops-tools.js

@@ -193,11 +193,15 @@ export function registerOpsTools(server, deps) {
         inputSchema: {
             workspace: z.string().min(1).max(100).optional().describe("One workspace key instead of all of them."),
             stale_only: z.boolean().optional().describe("Report only the stale channels, not the whole breakdown."),
+            // BLI-10450: counts alone could not answer "is there a Kaiben channel?".
+            list: z.boolean().optional().describe("Name every channel and its readable state, not only counts."),
         },
     }, async (args) => withSession(deps, async (session) => {
         const params = new URLSearchParams();
         if (args.workspace)
             params.set("workspace", String(args.workspace));
+        if (args.list)
+            params.set("list", "1");
         const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/ops/slack/coverage${queryString(params)}`);
         if (!response.ok)
             return errorResult(doorFailureText("slack_coverage", response));
@@ -214,7 +218,13 @@ export function registerOpsTools(server, deps) {
                 ? `  no channel is over ${staleAfter}h since its last sync`
                 : `  ${stale} channel(s) over ${staleAfter}h since last sync`;
             const cursor = args.stale_only ? "" : `\n  newest cursor: ${String(workspace["newestCursorIso"] ?? "never")}`;
-            return `${head}\n${staleLine}${cursor}`;
+            const channels = Array.isArray(workspace["channels"])
+                ? workspace["channels"]
+                : [];
+            const channelLines = channels.length > 0
+                ? `\n${channels.map((channel) => `  #${String(channel["name"] ?? "?")}  ${String(channel["meaning"] ?? "?")}`).join("\n")}`
+                : "";
+            return `${head}\n${staleLine}${cursor}${channelLines}`;
         })
             .join("\n\n");
         return textResult(`${workspaces.length} workspace(s), ${staleTotal} stale channel(s).${lines ? `\n\n${lines}` : ""}`
@@ -227,7 +237,8 @@ export function registerOpsTools(server, deps) {
         inputSchema: {
             person: z.string().min(1).max(200).optional().describe("A person — name, email or Slack member id."),
             channel: z.string().min(1).max(200).optional().describe("One channel name."),
-            query: z.string().min(1).max(500).optional().describe("Text to look for."),
+            query: z.string().min(1).max(500).optional().describe("Text to look for, as a substring."),
+            word: z.boolean().optional().describe("Match query as whole words, so \"excel\" stops matching \"Excellent\"."),
             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().describe("At most this many messages, newest first."),
@@ -240,6 +251,9 @@ export function registerOpsTools(server, deps) {
         }
         if (typeof args.limit === "number")
             body["limit"] = args.limit;
+        // BLI-10451: the same `word: true` the CLI's `--word` sends.
+        if (args.query && args.word === true)
+            body["word"] = true;
         const response = await callAgentDoor(session, deps.fetchImpl, "POST", "/api/ops/slack/read", body);
         if (!response.ok) {
             // The CLI names the open door beside the closed one on a 403; an
@@ -256,9 +270,14 @@ export function registerOpsTools(server, deps) {
             .map((message) => `#${String(message["channel"] ?? "?")}  ${String(message["author"] ?? "?")}  ${String(message["messageTs"] ?? "?")}`
             + `\n  ${String(message["text"] ?? "")}`)
             .join("\n");
-        // The server's own summary first and verbatim: it is the sentence that
-        // keeps an empty answer from reading as "nobody said anything".
-        const summary = typeof read["summary"] === "string" ? read["summary"] : `${messages.length} message(s).`;
+        // BLI-10450: `summary` is built for the JARVIS chat tool, which needs
+        // ONE self-contained string, so it already embeds a bullet line per
+        // message AND the note (tools-slack-render.ts renderSummary). Only
+        // the header (summary's first line) is printed here — it is the
+        // sentence that keeps an empty answer from reading as "nobody said
+        // anything" — and the messages/note print exactly once, not twice.
+        const rawSummary = typeof read["summary"] === "string" ? read["summary"] : `${messages.length} message(s).`;
+        const summary = rawSummary.split("\n")[0] ?? rawSummary;
         const note = typeof read["note"] === "string" && read["note"] ? `\n\n${read["note"]}` : "";
         return textResult(`${summary}${lines ? `\n\n${lines}` : ""}${note}`, {
             status: read["status"] ?? null,

package/dist/work-directory.d.ts

@@ -0,0 +1,15 @@
+import type { DoorSession, ToolDeps } from "./tool-result.js";
+export interface AssigneeIdentity {
+    name: string;
+    email: string | null;
+}
+export declare function resolveAssigneeDirectory(deps: ToolDeps, session: DoorSession, assigneeIds: Array<string | null | undefined>): Promise<Map<string, AssigneeIdentity>>;
+/** `assignee_name`/`assignee_email` alongside the bare id, for structuredContent. */
+export declare function withAssigneeIdentity<T extends {
+    assignee_id?: string | null;
+}>(row: T, directory: Map<string, AssigneeIdentity>): T & {
+    assignee_name: string | null;
+    assignee_email: string | null;
+};
+/** The text-line assignee phrase: a name (and email) when resolved, the bare id otherwise. */
+export declare function assigneeLabel(assigneeId: string | null | undefined, directory: Map<string, AssigneeIdentity>): string;

package/dist/work-directory.js

@@ -0,0 +1,39 @@
+/**
+ * BLI-10450: `work_list_issues`/`work_get_issue` carried only `assignee_id`
+ * (a uuid) — answering "who owns what" needed a second `work_list_projects`-
+ * shaped call to `/api/team/members` and a join done by hand. One call per
+ * tool invocation (never per row), the same door `cockpit team members`
+ * calls, mirroring `commands/issue-directory.ts` on the CLI.
+ */
+import { callAgentDoor } from "./agent-door.js";
+export async function resolveAssigneeDirectory(deps, session, assigneeIds) {
+    const wanted = new Set(assigneeIds.filter((id) => Boolean(id)));
+    const directory = new Map();
+    if (wanted.size === 0)
+        return directory;
+    const response = await callAgentDoor(session, deps.fetchImpl, "GET", "/api/team/members");
+    if (!response.ok)
+        return directory;
+    const people = (Array.isArray(response.body.people) ? response.body.people : []);
+    for (const person of people) {
+        const userId = person.account?.userId;
+        if (!userId || !wanted.has(userId))
+            continue;
+        directory.set(userId, { name: person.name ?? userId, email: person.email ?? null });
+    }
+    return directory;
+}
+/** `assignee_name`/`assignee_email` alongside the bare id, for structuredContent. */
+export function withAssigneeIdentity(row, directory) {
+    const identity = row.assignee_id ? directory.get(row.assignee_id) : undefined;
+    return { ...row, assignee_name: identity?.name ?? null, assignee_email: identity?.email ?? null };
+}
+/** The text-line assignee phrase: a name (and email) when resolved, the bare id otherwise. */
+export function assigneeLabel(assigneeId, directory) {
+    if (!assigneeId)
+        return "none";
+    const identity = directory.get(assigneeId);
+    if (!identity)
+        return assigneeId;
+    return identity.email ? `${identity.name} <${identity.email}>` : identity.name;
+}

package/dist/work-issue-rows.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The row shapes the `work_*` tools read off `/api/work/**`, and the pure
+ * functions that turn them into what a tool answers with: the trimmed list
+ * row, the completeness and outside-project notes, one issue's text, one
+ * history line.
+ *
+ * Split out of `work-tools.ts` (BLI-10445) when that file crossed the
+ * 500-line readability ratchet. The seam: `work-tools.ts` registers the tools
+ * and calls the doors; nothing here calls a door or knows a session, so this
+ * module changes when a door's row shape or a rendered sentence does, and can
+ * be read without the registration code around it.
+ *
+ * Every string moved verbatim.
+ */
+import { type AssigneeIdentity } from "./work-directory.js";
+export interface IssueRow {
+    id: string;
+    identifier: string;
+    title: string;
+    state: string;
+    priority?: number | null;
+    assignee_id?: string | null;
+    project_id?: string | null;
+    parent_id?: string | null;
+    updated_at?: string | null;
+}
+/**
+ * The fields `work_list_issues` promises. The door's row carries the whole
+ * description and a dozen bookkeeping columns; with no limit that was 1,000
+ * issues and 4.2 MB, 3.3 MB of it descriptions the tool said it never
+ * returned (BLI-10432). work_get_issue reads one issue in full.
+ */
+export interface IssueListRow {
+    id: string;
+    identifier: string;
+    title: string;
+    state: string;
+    priority: number | null;
+    assignee_id: string | null;
+    project_id: string | null;
+    parent_id: string | null;
+    updated_at: string | null;
+}
+export declare function issueListRow(row: IssueRow): IssueListRow;
+export interface ListCompleteness {
+    status: "complete" | "partial" | "unknown";
+    total: number | null;
+}
+export declare function listCompleteness(value: unknown): ListCompleteness | null;
+export interface OutsideProject {
+    status: string;
+    issues: {
+        identifier: string;
+        title: string;
+        project_id: string | null;
+        parent_identifier: string | null;
+    }[];
+}
+export declare function outsideProject(value: unknown): OutsideProject | null;
+/** BLI-10447: sub-issues of the listed issues that live in no project or another one. */
+export declare function outsideNote(outside: OutsideProject | null): string;
+export interface OneIssueOk {
+    ref: string;
+    ok: true;
+    issue?: IssueRow & {
+        description?: string | null;
+    };
+    comments: Array<{
+        body_markdown?: string;
+        created_at?: string;
+    }>;
+    commentsUnread?: boolean;
+}
+export interface OneIssueFailure {
+    ref: string;
+    ok: false;
+    text: string;
+}
+export declare function renderOneIssue(result: OneIssueOk, directory: Map<string, AssigneeIdentity>): string;
+export interface HistoryRow {
+    occurred_at?: string;
+    change_type?: string;
+    from_value?: string | null;
+    to_value?: string | null;
+    actor_name?: string | null;
+    source?: string;
+}
+/**
+ * A row the Linear import could not give state names to says which it is.
+ * Printing "(none) -> (none)" is honest and useless; naming the gap keeps
+ * nobody reading a real gap as a broken tool (`commands/issue.ts` says the
+ * same thing in the same words).
+ */
+export declare function historyChange(row: HistoryRow): string;

package/dist/work-issue-rows.js

@@ -0,0 +1,75 @@
+/**
+ * The row shapes the `work_*` tools read off `/api/work/**`, and the pure
+ * functions that turn them into what a tool answers with: the trimmed list
+ * row, the completeness and outside-project notes, one issue's text, one
+ * history line.
+ *
+ * Split out of `work-tools.ts` (BLI-10445) when that file crossed the
+ * 500-line readability ratchet. The seam: `work-tools.ts` registers the tools
+ * and calls the doors; nothing here calls a door or knows a session, so this
+ * module changes when a door's row shape or a rendered sentence does, and can
+ * be read without the registration code around it.
+ *
+ * Every string moved verbatim.
+ */
+import { assigneeLabel } from "./work-directory.js";
+export function issueListRow(row) {
+    return {
+        id: row.id,
+        identifier: row.identifier,
+        title: row.title,
+        state: row.state,
+        priority: row.priority ?? null,
+        assignee_id: row.assignee_id ?? null,
+        project_id: row.project_id ?? null,
+        parent_id: row.parent_id ?? null,
+        updated_at: row.updated_at ?? null,
+    };
+}
+export function listCompleteness(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    const status = record["status"];
+    if (status !== "complete" && status !== "partial" && status !== "unknown")
+        return null;
+    return { status, total: typeof record["total"] === "number" ? record["total"] : null };
+}
+export function outsideProject(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (!Array.isArray(record["issues"]))
+        return null;
+    return { status: String(record["status"] ?? "complete"), issues: record["issues"] };
+}
+/** BLI-10447: sub-issues of the listed issues that live in no project or another one. */
+export function outsideNote(outside) {
+    if (!outside)
+        return "";
+    const named = outside.issues.map((issue) => `${issue.identifier} (under ${issue.parent_identifier ?? "?"}, ${issue.project_id ? `project ${issue.project_id}` : "no project"})`);
+    const found = named.length > 0 ? ` ${named.length} sub-issue(s) of these sit outside the project: ${named.join(", ")}.` : "";
+    const gap = outside.status === "failed" ? " The outside-project check failed (read_failed)."
+        : outside.status === "capped" ? " The outside-project check was capped; more may exist." : "";
+    return found + gap;
+}
+export function renderOneIssue(result, directory) {
+    const { issue, comments } = result;
+    const commentText = comments.map((comment) => `[${comment.created_at ?? ""}] ${comment.body_markdown ?? ""}`).join("\n\n");
+    return `${issue?.identifier ?? result.ref} ${issue?.title ?? ""} (${issue?.state ?? "?"})  ·  assignee ${assigneeLabel(issue?.assignee_id, directory)}`
+        + `\n\n${issue?.description ?? "(no description)"}`
+        + (commentText ? `\n\n--- comments ---\n${commentText}` : "")
+        + (result.commentsUnread ? "\n\n(comments could not be read on this call)" : "");
+}
+/**
+ * A row the Linear import could not give state names to says which it is.
+ * Printing "(none) -> (none)" is honest and useless; naming the gap keeps
+ * nobody reading a real gap as a broken tool (`commands/issue.ts` says the
+ * same thing in the same words).
+ */
+export function historyChange(row) {
+    if (row.from_value === null && row.to_value === null) {
+        return `(no state names recorded — imported from ${row.source ?? "elsewhere"})`;
+    }
+    return `${row.from_value ?? "(none)"} -> ${row.to_value ?? "(none)"}`;
+}

package/dist/work-tools.js

@@ -17,6 +17,8 @@
 import { z } from "zod";
 import { callAgentDoor } from "./agent-door.js";
 import { DEFAULT_LIST_LIMIT, doorFailureText, errorResult, moreNote, registrarFor, textResult, withSession, } from "./tool-result.js";
+import { assigneeLabel, resolveAssigneeDirectory, withAssigneeIdentity } from "./work-directory.js";
+import { historyChange, issueListRow, listCompleteness, outsideNote, outsideProject, renderOneIssue, } from "./work-issue-rows.js";
 /** The closed state vocabulary, verbatim from `lib/work/api-doors.ts` `WORK_ISSUE_STATES`. */
 export const WORK_ISSUE_STATES = [
     "backlog",
@@ -28,37 +30,24 @@ export const WORK_ISSUE_STATES = [
 ];
 /** `/api/work/issues`' own ceiling, and the most a caller may ask for here. */
 const ISSUE_LIST_MAX = 1000;
-/**
- * The fields `work_list_issues` promises. The door's row carries the whole
- * description and a dozen bookkeeping columns; with no limit that was 1,000
- * issues and 4.2 MB, 3.3 MB of it descriptions the tool said it never
- * returned (BLI-10432). work_get_issue reads one issue in full.
- */
-function issueListRow(row) {
+/** One issue plus its comments — a comment read that fails does not lose the issue already in hand. */
+async function fetchOneIssue(deps, session, ref) {
+    const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/work/issues/${encodeURIComponent(ref)}`);
+    if (!response.ok)
+        return { ref, ok: false, text: doorFailureText("work_get_issue", response) };
+    const issue = response.body.issue;
+    const commentsResponse = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/work/issues/${encodeURIComponent(issue?.id ?? ref)}/comments`);
+    const comments = commentsResponse.ok
+        ? (commentsResponse.body.comments ?? [])
+        : [];
     return {
-        id: row.id,
-        identifier: row.identifier,
-        title: row.title,
-        state: row.state,
-        priority: row.priority ?? null,
-        assignee_id: row.assignee_id ?? null,
-        project_id: row.project_id ?? null,
-        parent_id: row.parent_id ?? null,
-        updated_at: row.updated_at ?? null,
+        ref,
+        ok: true,
+        issue,
+        comments,
+        ...(commentsResponse.ok ? {} : { commentsUnread: true }),
     };
 }
-/**
- * A row the Linear import could not give state names to says which it is.
- * Printing "(none) -> (none)" is honest and useless; naming the gap keeps
- * nobody reading a real gap as a broken tool (`commands/issue.ts` says the
- * same thing in the same words).
- */
-function historyChange(row) {
-    if (row.from_value === null && row.to_value === null) {
-        return `(no state names recorded — imported from ${row.source ?? "elsewhere"})`;
-    }
-    return `${row.from_value ?? "(none)"} -> ${row.to_value ?? "(none)"}`;
-}
 /** A project id from a project NAME or a uuid — exact after case-folding, never fuzzy. */
 async function resolveProjectId(deps, session, ref) {
     const response = await callAgentDoor(session, deps.fetchImpl, "GET", "/api/work/projects?include_archived=true");
@@ -111,33 +100,72 @@ export function registerWorkTools(server, deps) {
         if (!response.ok)
             return errorResult(doorFailureText("work_list_issues", response));
         const all = (Array.isArray(response.body.issues) ? response.body.issues : []);
-        const more = args.limit === undefined && all.length > DEFAULT_LIST_LIMIT;
-        const issues = more ? all.slice(0, DEFAULT_LIST_LIMIT) : all;
+        // BLI-10447: the door says whether a full read was every match; a named
+        // limit that filled up used to answer "more: false" regardless.
+        const completeness = listCompleteness(response.body.completeness);
+        const more = args.limit === undefined
+            ? all.length > DEFAULT_LIST_LIMIT
+            : completeness?.status === "partial" || completeness?.status === "unknown";
+        const issues = args.limit === undefined && more ? all.slice(0, DEFAULT_LIST_LIMIT) : all;
+        const outside = outsideProject(response.body.outside_project);
+        // BLI-10450: one directory call for the whole page, never one per row.
+        const directory = await resolveAssigneeDirectory(deps, session, issues.map((issue) => issue.assignee_id));
         const lines = issues
             .map((issue) => `${issue.identifier}  ${issue.state}  ${issue.title}`
-            + `  [p${issue.priority ?? 0}, assignee ${issue.assignee_id ?? "none"}, project ${issue.project_id ?? "none"}]`)
+            + `  [p${issue.priority ?? 0}, assignee ${assigneeLabel(issue.assignee_id, directory)}, project ${issue.project_id ?? "none"}]`)
             .join("\n");
-        return textResult(`${issues.length} issue(s).${moreNote(more, ISSUE_LIST_MAX)}${lines ? `\n${lines}` : ""}`, { issues: issues.map(issueListRow), more });
+        const totalNote = completeness?.total != null && completeness.total > issues.length ? ` ${completeness.total} match in all.` : "";
+        return textResult(`${issues.length} issue(s).${totalNote}${moreNote(more, ISSUE_LIST_MAX)}${outsideNote(outside)}${lines ? `\n${lines}` : ""}`, {
+            issues: issues.map((issue) => withAssigneeIdentity(issueListRow(issue), directory)),
+            more,
+            ...(completeness ? { total: completeness.total } : {}),
+            ...(outside ? { outside_project: outside } : {}),
+        });
     }));
     register("work_get_issue", {
         title: "Read a Tower issue",
-        description: "One issue's title, state, priority, assignee, description and every comment on it.",
-        inputSchema: { id: ISSUE_REF },
+        description: "One issue's title, state, priority, assignee (name and email, not just its id), description and every "
+            + "comment on it. `ids` reads several in one call — still one request per issue plus its comments, "
+            + "no bulk door exists yet. A single id answers `{ issue, comments }`; several answer "
+            + "`{ issues: [{ ref, ok, issue, comments } | { ref, ok: false, error, detail }] }` so one bad id never "
+            + "loses the rest.",
+        inputSchema: {
+            id: ISSUE_REF.optional().describe("A single issue. Omit when passing ids."),
+            ids: z.array(ISSUE_REF).min(1).max(50).optional().describe("Several issues in one call. Omit when passing id."),
+        },
     }, async (args) => withSession(deps, async (session) => {
-        const ref = String(args.id ?? "");
-        const response = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/work/issues/${encodeURIComponent(ref)}`);
-        if (!response.ok)
-            return errorResult(doorFailureText("work_get_issue", response));
-        const issue = response.body.issue;
-        // A comment read that fails does not lose the issue already in hand.
-        const commentsResponse = await callAgentDoor(session, deps.fetchImpl, "GET", `/api/work/issues/${encodeURIComponent(issue?.id ?? ref)}/comments`);
-        const comments = commentsResponse.ok ? (commentsResponse.body.comments ?? []) : [];
-        const commentText = comments
-            .map((comment) => `[${comment.created_at ?? ""}] ${comment.body_markdown ?? ""}`)
-            .join("\n\n");
-        return textResult(`${issue?.identifier ?? ref} ${issue?.title ?? ""} (${issue?.state ?? "?"})\n\n${issue?.description ?? "(no description)"}`
-            + (commentText ? `\n\n--- comments ---\n${commentText}` : "")
-            + (commentsResponse.ok ? "" : "\n\n(comments could not be read on this call)"), { issue, comments, ...(commentsResponse.ok ? {} : { comments_unread: true }) });
+        const refs = Array.isArray(args.ids) && args.ids.length > 0
+            ? args.ids.map(String)
+            : [String(args.id ?? "")];
+        if (refs.length === 1 && refs[0] === "")
+            return errorResult("work_get_issue needs id or ids.");
+        const results = await Promise.all(refs.map((ref) => fetchOneIssue(deps, session, ref)));
+        const directory = await resolveAssigneeDirectory(deps, session, results.filter((result) => result.ok).map((result) => result.issue?.assignee_id));
+        if (refs.length === 1) {
+            const [result] = results;
+            if (!result?.ok)
+                return errorResult(result?.text ?? "work_get_issue could not read that issue.");
+            return textResult(renderOneIssue(result, directory), {
+                issue: withAssigneeIdentity(result.issue ?? {}, directory),
+                comments: result.comments,
+                ...(result.commentsUnread ? { comments_unread: true } : {}),
+            });
+        }
+        const failed = results.filter((result) => !result.ok);
+        const lines = results
+            .map((result) => (result.ok ? renderOneIssue(result, directory) : `${result.ref}: ${result.text}`))
+            .join("\n\n---\n\n");
+        return textResult(`${results.length - failed.length}/${results.length} issue(s) read.\n\n${lines}`, {
+            issues: results.map((result) => result.ok
+                ? {
+                    ref: result.ref,
+                    ok: true,
+                    issue: withAssigneeIdentity(result.issue ?? {}, directory),
+                    comments: result.comments,
+                    ...(result.commentsUnread ? { comments_unread: true } : {}),
+                }
+                : { ref: result.ref, ok: false, error: result.text }),
+        });
     }));
     register("work_create_issue", {
         title: "File a Tower issue",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/mcp",
-  "version": "0.1.63",
+  "version": "0.1.66",
   "private": false,
   "description": "bli-tower: an MCP server over BLI Cockpit's agent doors: JARVIS (jarvis_*), documents (docs_*), channels (msg_*), issues (work_*), the daily page (brief_*), meeting notes (notes_*), the ops board (ops_status/slack_*), settings/team/model, Scout and the workbook, plus the legacy event-stream tools (emit_event, get_ticket_timeline, get_active_tickets).",
   "type": "module",