@bli-cockpit/cli 0.2.55 → 0.2.57

package/dist/commands/memory-install-claude.js

@@ -77,7 +77,13 @@ export async function inspectClaudeMemoryIntegration(options) {
         }),
     ];
 }
-async function applyJsonTarget(input) {
+/**
+ * Exported for `tower-mcp-claude.ts` (BLI-3706): the read/refuse-if-unparseable
+ * /apply/dry-run/write/read-back-verify sequence is identical for a SECOND
+ * server's `mcpServers` entry — only which target id and which `apply`/
+ * `matches` pair runs differs, both already parameters here.
+ */
+export async function applyJsonTarget(input) {
     const { file, options } = input;
     const raw = await input.options.io.readText(file);
     let root;
@@ -120,7 +126,8 @@ async function applyJsonTarget(input) {
     }
     return { target: input.target, status: "installed", reason: "wrote_entry", path: file };
 }
-async function inspectJsonTarget(input) {
+/** Exported for `tower-mcp-claude.ts` (BLI-3706) — see `applyJsonTarget`'s note. */
+export async function inspectJsonTarget(input) {
     const raw = await input.io.readText(input.file);
     if (raw === null || !raw.trim()) {
         return { target: input.target, status: "missing", reason: "file_absent", path: input.file };
@@ -140,7 +147,8 @@ async function inspectJsonTarget(input) {
         path: input.file,
     };
 }
-function applyMcpServer(root, config) {
+/** Exported for `tower-mcp-claude.ts` (BLI-3706) — the `mcpServers` shape has nothing memory-specific about it. */
+export function applyMcpServer(root, config) {
     const servers = asRecord(root["mcpServers"]) ?? {};
     servers[config.server_id] = {
         command: config.mcp_server.command,
@@ -152,13 +160,13 @@ function applyMcpServer(root, config) {
     root["mcpServers"] = servers;
     return root;
 }
-function readMcpServer(root, serverId) {
+export function readMcpServer(root, serverId) {
     const servers = asRecord(root["mcpServers"]);
     if (!servers)
         return null;
     return asRecord(servers[serverId]);
 }
-function mcpServerMatches(root, config) {
+export function mcpServerMatches(root, config) {
     const entry = readMcpServer(root, config.server_id);
     if (!entry)
         return false;

package/dist/commands/memory-install.js

@@ -34,11 +34,10 @@
  * - **Never claim an install it did not read back** (BLI-2541). Both halves
  *   re-read and re-parse; this module only aggregates what they proved.
  */
-import fs from "node:fs";
 import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { writeLine } from "./cli-io.js";
+import { resolveMcpBin } from "./mcp-bin-resolve.js";
+import { installTowerIntegration, inspectTowerIntegration } from "./tower-mcp-install.js";
 import { builtinMemoryInstallConfig, isUnsafeBinPath, MEMORY_MCP_BIN, parsePrintedMemoryInstallConfig, withResolvedBinPath, } from "./memory-install-contract.js";
 import { defaultMemoryFileIo, } from "./memory-install-files.js";
 import { installClaudeMemoryIntegration, inspectClaudeMemoryIntegration, } from "./memory-install-claude.js";
@@ -80,6 +79,21 @@ export async function installMemoryIntegration(command, io, deps = {}) {
             io: fileIo,
         })));
     }
+    // BLI-3706: `bli-tower` (docs_*/msg_* over the collector device token)
+    // registers beside `bli-memory` on the SAME command — see
+    // tower-mcp-install.ts's header for why this rides here rather than a
+    // separate, un-invoked verb. Independent of the memory outcome above: a
+    // machine with one server but not the other is a real machine.
+    targets.push(...(await installTowerIntegration({
+        io: fileIo,
+        platform,
+        homeDir,
+        dashboardUrl: await resolveDashboardUrl(command, deps),
+        env: io.env ?? process.env,
+        fileExists: deps.fileExists,
+        cliEntryPoint: deps.cliEntryPoint,
+        realpath: deps.realpath,
+    }, command.dryRun)));
     const outcome = {
         action: "install",
         ...aggregate(targets),
@@ -112,6 +126,17 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
             io: fileIo,
         })));
     }
+    // BLI-3706: see the matching note in `installMemoryIntegration`.
+    targets.push(...(await inspectTowerIntegration({
+        io: fileIo,
+        platform,
+        homeDir,
+        dashboardUrl: await resolveDashboardUrl(command, deps),
+        env: io.env ?? process.env,
+        fileExists: deps.fileExists,
+        cliEntryPoint: deps.cliEntryPoint,
+        realpath: deps.realpath,
+    })));
     return {
         action: "status",
         ...aggregate(targets),
@@ -287,106 +312,10 @@ async function printedMemoryConfig(io, binPath) {
  *    cannot be realpath-ed still identifies a directory well enough to look in.
  */
 export async function resolveMemoryMcpBin(options) {
-    const exists = options.fileExists ?? defaultFileExists;
-    const beside = await resolveBesideCli(options, exists);
-    if (beside)
-        return { path: beside, source: "cli_dependency" };
-    const onPath = await resolveOnPath(options, exists);
-    return onPath ? { path: onPath, source: "path" } : null;
+    return resolveMcpBin({ ...options, binName: MEMORY_MCP_BIN });
 }
-/**
- * Where to start walking, in order of trustworthiness. This module's own
- * location first: it is inside the installed package and cannot be a shim.
- */
-function besideAnchors(options) {
-    const anchors = [];
-    const own = currentModulePath();
-    if (own)
-        anchors.push(own);
-    const entry = options.cliEntryPoint ?? process.argv[1];
-    if (entry)
-        anchors.push(entry);
-    return anchors;
-}
-function currentModulePath() {
-    try {
-        return fileURLToPath(import.meta.url);
-    }
-    catch {
-        // A bundler that dropped `import.meta` support. The entry-point anchor
-        // still covers it, so this is a narrowing rather than a failure.
-        return null;
-    }
-}
-async function resolveBesideCli(options, exists) {
-    const platformPath = options.platform === "win32" ? path.win32 : path.posix;
-    const extensions = binExtensions(options.platform);
-    const realpath = options.realpath ?? defaultRealpath;
-    for (const anchor of besideAnchors(options)) {
-        let directory = platformPath.dirname(realpath(platformPath.resolve(anchor)));
-        // Bounded walk: deep enough for `…/node_modules/@scope/pkg/dist/cli.js`
-        // plus a hoisted root above it, and it stops at the filesystem root anyway.
-        for (let depth = 0; depth < 12; depth += 1) {
-            for (const extension of extensions) {
-                const candidate = platformPath.join(directory, "node_modules", ".bin", `${MEMORY_MCP_BIN}${extension}`);
-                if (await exists(candidate))
-                    return candidate;
-            }
-            const parent = platformPath.dirname(directory);
-            if (parent === directory)
-                break;
-            directory = parent;
-        }
-    }
-    return null;
-}
-/**
- * `realpathSync.native` follows the symlink npm writes for a global bin. A
- * path that does not resolve — a Windows path being reasoned about from a Mac
- * in a test, a directory that has since moved — comes back unchanged rather
- * than throwing, because the walk above can still look inside it.
- */
-function defaultRealpath(value) {
-    try {
-        return fs.realpathSync.native(value);
-    }
-    catch {
-        return value;
-    }
-}
-async function resolveOnPath(options, exists) {
-    // The TARGET platform's path rules, not the running one's. On a real machine
-    // they are the same; asking for them explicitly is what lets the Windows
-    // lookup be tested from a Mac, which is the only Windows proof this repo
-    // gets before a release (AGENTS.md, supported fleet).
-    const platformPath = options.platform === "win32" ? path.win32 : path.posix;
-    const entries = (options.env["PATH"] ?? options.env["Path"] ?? "")
-        .split(platformPath.delimiter)
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    for (const entry of entries) {
-        for (const extension of binExtensions(options.platform)) {
-            const candidate = platformPath.join(entry, `${MEMORY_MCP_BIN}${extension}`);
-            if (await exists(candidate))
-                return candidate;
-        }
-    }
-    return null;
-}
-/** npm writes `.cmd` (and `.ps1`) shims on Windows; POSIX gets the bare name. */
-function binExtensions(platform) {
-    return platform === "win32" ? [".cmd", ".exe", ".bat", ""] : [""];
-}
-async function defaultFileExists(file) {
-    const { stat } = await import("node:fs/promises");
-    try {
-        return (await stat(file)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-async function resolveDashboardUrl(command, deps) {
+/** Exported for `tower-mcp-install.ts` (BLI-3706): the two registrations share this machine's one dashboard URL. */
+export async function resolveDashboardUrl(command, deps) {
     if (command.dashboardUrl)
         return command.dashboardUrl;
     const paths = getCollectorRuntimePaths(deps.homeDir ?? command.homeDir);
@@ -412,6 +341,17 @@ function aggregate(targets) {
     if (targets.some((target) => target.status === "mismatch" || target.status === "missing")) {
         return { status: "missing", reason: "entry_absent" };
     }
+    // BLI-3706: checked BEFORE `skipped`, not after. `bli-tower` registering
+    // beside `bli-memory` on this same command means a machine can be fully
+    // "already" registered for one server while the other's bin is not here
+    // yet — that machine's OWN state must not read as "skipped" (nothing is
+    // happening) when something plainly already is. `skipped` only wins the
+    // whole outcome when NOTHING on this machine has ever reached "already"
+    // either — the original one-server case (a fresh machine, bin missing,
+    // nothing written at all) still returns "skipped" via the fallback below.
+    if (targets.some((target) => target.status === "already")) {
+        return { status: "already", reason: "already_current" };
+    }
     const skipped = targets.find((target) => target.status === "skipped");
     if (skipped) {
         // Not a failure and not a success: nothing was written, on purpose, and

package/dist/commands/msg.js

@@ -0,0 +1,188 @@
+/**
+ * `cockpit msg` — channels and messages, typed (BLI-3706).
+ *
+ * Four verbs over `/api/msg/**` (BLI-3654 Wave 1a), which already accepts the
+ * collector device token through `resolveCaller({ allowDeviceToken: true })`
+ * on every route — no server-side door change was needed for this terminal.
+ *
+ * `<channel>` is a channel id, or its name with or without a leading `#`,
+ * resolved locally against `GET /api/msg/channels` — exact match only, never
+ * fuzzy, same discipline `docs.ts` uses for a slug.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
+import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+const TAG = "[msg cli]";
+const READ_DEADLINE_MS = 30_000;
+const WRITE_DEADLINE_MS = 30_000;
+const CONTENT_MAX_CHARS = 8_000;
+export async function runMsg(command, io) {
+    const door = await openAgentDoor("msg", command, io);
+    switch (command.action) {
+        case "channels":
+            return listChannels(door);
+        case "read":
+            return readChannel(command, door);
+        case "send":
+            return sendMessage(command, door);
+        case "thread":
+            return readThread(command, door);
+    }
+}
+async function fetchChannels(door) {
+    const answer = await askAgentDoor(door, {
+        path: "/api/msg/channels",
+        method: "GET",
+        label: "msg channels",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return { ok: false, reason: answer.reason, detail: answer.detail };
+    return { ok: true, channels: answer.body.channels ?? [] };
+}
+async function listChannels(door) {
+    const fetched = await fetchChannels(door);
+    if (!fetched.ok)
+        return failAgentDoor(door, TAG, fetched.reason, fetched.detail);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channels: fetched.channels });
+    if (fetched.channels.length === 0) {
+        writeLine(door.io.stdout, "No channels.");
+        return 0;
+    }
+    for (const channel of fetched.channels) {
+        const label = channel.is_dm ? "dm" : channel.is_private ? "private" : "public";
+        writeLine(door.io.stdout, `${channel.id}  ${label.padEnd(7)}  ${channel.name ?? "(unnamed)"}`);
+    }
+    return 0;
+}
+/** Exact id, or exact name with or without a leading `#`. Never fuzzy. */
+async function resolveChannelId(door, ref) {
+    const fetched = await fetchChannels(door);
+    if (!fetched.ok)
+        return { status: "list_failed", reason: fetched.reason, detail: fetched.detail };
+    const byId = fetched.channels.find((channel) => channel.id === ref);
+    if (byId)
+        return { status: "ok", id: byId.id };
+    const bare = ref.startsWith("#") ? ref.slice(1) : ref;
+    const byName = fetched.channels.find((channel) => channel.name === bare);
+    if (byName)
+        return { status: "ok", id: byName.id };
+    return { status: "not_found" };
+}
+function channelNotFound(door, ref) {
+    return failAgentDoor(door, TAG, "channel_not_found_or_unreadable", `That channel does not exist, or you cannot read it: ${ref}`);
+}
+async function readChannel(command, door) {
+    const ref = command.channelRef ?? "";
+    const resolved = await resolveChannelId(door, ref);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found")
+        return channelNotFound(door, ref);
+    const query = new URLSearchParams();
+    if (command.limit !== undefined)
+        query.set("limit", String(command.limit));
+    if (command.threadId)
+        query.set("thread_parent_id", command.threadId);
+    const rendered = query.toString();
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(resolved.id)}/messages${rendered ? `?${rendered}` : ""}`,
+        method: "GET",
+        label: "msg read",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const messages = answer.body.messages ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channelId: resolved.id, messages });
+    if (messages.length === 0) {
+        writeLine(door.io.stdout, "No messages.");
+        return 0;
+    }
+    for (const message of [...messages].reverse()) {
+        const who = message.agent_label ?? message.user_id;
+        writeLine(door.io.stdout, `${message.created_at}  ${who}  ${message.content ?? ""}`);
+    }
+    return 0;
+}
+async function readThread(command, door) {
+    if (!command.channelRef) {
+        return failAgentDoor(door, TAG, "invalid_body", "msg thread needs --channel <channel>.");
+    }
+    const resolved = await resolveChannelId(door, command.channelRef);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found")
+        return channelNotFound(door, command.channelRef);
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(resolved.id)}/messages?thread_parent_id=${encodeURIComponent(command.threadId ?? "")}`,
+        method: "GET",
+        label: "msg thread",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const messages = answer.body.messages ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, channelId: resolved.id, threadParentId: command.threadId, messages });
+    if (messages.length === 0) {
+        writeLine(door.io.stdout, "No replies.");
+        return 0;
+    }
+    for (const message of [...messages].reverse()) {
+        const who = message.agent_label ?? message.user_id;
+        writeLine(door.io.stdout, `${message.created_at}  ${who}  ${message.content ?? ""}`);
+    }
+    return 0;
+}
+async function readContent(io) {
+    if (isInteractiveStdin(io)) {
+        return {
+            ok: false,
+            reason: "nothing_piped",
+            detail: "Pipe the message in, e.g. `echo \"hello\" | cockpit msg send general`. A message never travels on the command line.",
+        };
+    }
+    try {
+        const text = await readPipedText(io.stdin, {
+            maxChars: CONTENT_MAX_CHARS,
+            overflowMessage: `A message is limited to ${CONTENT_MAX_CHARS} characters.`,
+        });
+        return { ok: true, text: text.trim() };
+    }
+    catch (error) {
+        return { ok: false, reason: "content_too_long", detail: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function sendMessage(command, door) {
+    const ref = command.channelRef ?? "";
+    const resolved = await resolveChannelId(door, ref);
+    if (resolved.status === "list_failed")
+        return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+    if (resolved.status === "not_found")
+        return channelNotFound(door, ref);
+    const content = await readContent(door.io);
+    if (!content.ok)
+        return failAgentDoor(door, TAG, content.reason, content.detail);
+    if (content.text === "")
+        return failAgentDoor(door, TAG, "invalid_body", "There was nothing to send. Nothing was sent.");
+    const answer = await askAgentDoor(door, {
+        path: `/api/msg/channels/${encodeURIComponent(resolved.id)}/messages`,
+        method: "POST",
+        label: "msg send",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            content: content.text,
+            ...(command.threadId ? { thread_parent_id: command.threadId } : {}),
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const message = answer.body.message ?? null;
+    writeLine(door.io.stderr, `${TAG} sent ${JSON.stringify({ channel_id: resolved.id, message_id: message?.id ?? null, chars: content.text.length })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, message });
+    writeLine(door.io.stdout, `Sent to ${ref} (${message?.id ?? "?"}).`);
+    return 0;
+}

package/dist/commands/ops-render.js

@@ -70,7 +70,12 @@ export function renderOpsStatus(payload, dim) {
         const verdict = verdictWord(row.verdict).padEnd(6);
         const id = (row.id ?? "?").padEnd(idWidth);
         const age = ageWord(row.ageHours).padStart(7);
-        lines.push(`${verdict} ${id}  ${age}  ${dim(intervalWord(row))}`);
+        // BLI-3722: name the device this age belongs to right in the row — a bare
+        // `STALE collector-fleet 11h` was already misread once (BLI-3699) as "the
+        // fleet", not "one machine in it", and the name is otherwise buried in
+        // `detail` below.
+        const staleName = row.verdict === "stale" && row.staleDeviceName ? ` ${dim(`(${row.staleDeviceName})`)}` : "";
+        lines.push(`${verdict} ${id}  ${age}${staleName}  ${dim(intervalWord(row))}`);
         if (row.verdict !== "healthy") {
             if (row.detail)
                 lines.push(dim(`       ${row.detail}`));

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.55");
+    writeLine(io?.stdout ?? process.stdout, "0.2.57");
     return 0;
   }
 

package/dist/commands/tower-mcp-claude.js

@@ -0,0 +1,30 @@
+/**
+ * The Claude Code half of `bli-tower`'s registration (BLI-3706) — one entry
+ * under `~/.claude.json`'s top-level `mcpServers`, beside `bli-memory`'s.
+ *
+ * Reuses `memory-install-claude.ts`'s generic JSON-target machinery
+ * (`applyJsonTarget`/`inspectJsonTarget`) and its `mcpServers` shape
+ * (`applyMcpServer`/`readMcpServer`/`mcpServerMatches`), none of which is
+ * memory-specific — see that file's own exports for why. `bli-tower` has no
+ * hooks (`tower-mcp-contract.ts`), so there is no `~/.claude/settings.json`
+ * half here at all, unlike BLI Memory's `claude_hooks` target.
+ */
+import { applyJsonTarget, applyMcpServer, claudeMcpConfigFile, inspectJsonTarget, mcpServerMatches, readMcpServer, } from "./memory-install-claude.js";
+export async function installClaudeTowerIntegration(options) {
+    return applyJsonTarget({
+        target: "tower_claude_mcp",
+        file: claudeMcpConfigFile(options.homeDir),
+        options,
+        apply: (root) => applyMcpServer(root, options.config),
+        matches: (root) => mcpServerMatches(root, options.config),
+    });
+}
+export async function inspectClaudeTowerIntegration(options) {
+    return inspectJsonTarget({
+        target: "tower_claude_mcp",
+        file: claudeMcpConfigFile(options.homeDir),
+        io: options.io,
+        present: (root) => readMcpServer(root, options.config.server_id) !== null,
+        matches: (root) => mcpServerMatches(root, options.config),
+    });
+}

package/dist/commands/tower-mcp-codex.js

@@ -0,0 +1,100 @@
+/**
+ * The Codex half of `bli-tower`'s registration (BLI-3706) — one table,
+ * `[mcp_servers.bli-tower]`, in `~/.codex/config.toml`.
+ *
+ * Deliberately narrower than `memory-install-codex.ts`: `bli-tower` has no
+ * Codex skill to teach (its tools are self-describing over MCP, same as any
+ * other server Codex discovers), so there is no `codex_skills` target here —
+ * only the one table, written the same byte-preserving way BLI Memory's own
+ * table is (`memory-install-toml.ts`'s line-span swap, never a
+ * parse-and-reserialise, so a person's model/approval/sandbox settings and
+ * every other MCP server come out untouched).
+ */
+import path from "node:path";
+import { TOWER_MCP_SERVER_ID } from "./tower-mcp-contract.js";
+import { findTomlTableSpan, readTomlTable, renderTomlTable, upsertTomlTable, } from "./memory-install-toml.js";
+const TOWER_TOML_PATH = ["mcp_servers", TOWER_MCP_SERVER_ID];
+export function codexConfigFile(homeDir) {
+    return path.join(homeDir, ".codex", "config.toml");
+}
+export async function installCodexTowerIntegration(options) {
+    const file = codexConfigFile(options.homeDir);
+    const raw = (await options.io.readText(file)) ?? "";
+    if (tableMatches(raw, options.config)) {
+        return { target: "tower_codex_mcp", status: "already", reason: "already_current", path: file };
+    }
+    const next = upsertTomlTable(raw, TOWER_TOML_PATH, renderTowerTable(options.config));
+    if (options.dryRun) {
+        return { target: "tower_codex_mcp", status: "would_install", reason: "dry_run", path: file };
+    }
+    try {
+        await options.io.writeText(file, next);
+    }
+    catch (error) {
+        return {
+            target: "tower_codex_mcp",
+            status: "failed",
+            reason: "write_failed",
+            path: file,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    // BLI-2541: parse the table back out of the stored bytes, same discipline
+    // as every other target this installer writes.
+    const stored = await options.io.readText(file);
+    if (stored === null || !tableMatches(stored, options.config)) {
+        return {
+            target: "tower_codex_mcp",
+            status: "failed",
+            reason: "read_back_mismatch",
+            path: file,
+            detail: "the table on disk does not parse back to the entry that was written",
+        };
+    }
+    return { target: "tower_codex_mcp", status: "installed", reason: "wrote_entry", path: file };
+}
+export async function inspectCodexTowerIntegration(options) {
+    const file = codexConfigFile(options.homeDir);
+    const raw = await options.io.readText(file);
+    if (raw === null) {
+        return { target: "tower_codex_mcp", status: "missing", reason: "file_absent", path: file };
+    }
+    if (tableMatches(raw, options.config)) {
+        return { target: "tower_codex_mcp", status: "installed", reason: "already_current", path: file };
+    }
+    return findTomlTableSpan(raw, TOWER_TOML_PATH)
+        ? { target: "tower_codex_mcp", status: "mismatch", reason: "entry_differs", path: file }
+        : { target: "tower_codex_mcp", status: "missing", reason: "entry_absent", path: file };
+}
+function renderTowerTable(config) {
+    const entries = [
+        ["command", config.mcp_server.command],
+        ["args", config.mcp_server.args],
+    ];
+    if (Object.keys(config.mcp_server.env).length > 0) {
+        entries.push(["env", config.mcp_server.env]);
+    }
+    return renderTomlTable(TOWER_TOML_PATH, entries);
+}
+function tableMatches(raw, config) {
+    const table = readTomlTable(raw, TOWER_TOML_PATH);
+    if (!table)
+        return false;
+    if (table["command"] !== config.mcp_server.command)
+        return false;
+    const args = table["args"];
+    if (!Array.isArray(args))
+        return config.mcp_server.args.length === 0;
+    if (args.length !== config.mcp_server.args.length)
+        return false;
+    if (!args.every((entry, index) => entry === config.mcp_server.args[index]))
+        return false;
+    const env = table["env"];
+    for (const [key, value] of Object.entries(config.mcp_server.env)) {
+        if (!env || Array.isArray(env) || typeof env === "string")
+            return false;
+        if (env[key] !== value)
+            return false;
+    }
+    return true;
+}

package/dist/commands/tower-mcp-contract.js

@@ -0,0 +1,39 @@
+/**
+ * The `bli-tower` MCP server's registration shape (BLI-3706).
+ *
+ * `bli-tower` is the server id `@bli-cockpit/mcp` (bin `bli-cockpit-mcp`)
+ * registers under — the `docs_*`/`msg_*` tools over the collector device
+ * token, beside `bli-memory` (BLI-3580). Unlike BLI Memory, this server has
+ * NO Claude Code hooks: it is tools only, so `hooks: []` and
+ * `permissions_allow: []` on every config this module builds — the shared
+ * `memory-install-claude.ts`/`memory-install-codex.ts` writers already treat
+ * an empty hooks array as "nothing to do" for that half (see their own
+ * `config.hooks` loops), so no server-specific hook-writing code exists here.
+ *
+ * `@bli-cockpit/mcp` does not (yet) print its own `--print-config`, unlike
+ * `bli-memory-mcp` — so `builtinTowerInstallConfig` is the ONLY source of the
+ * config today; there is no `parsePrintedTowerInstallConfig` counterpart to
+ * `memory-install-contract.ts`'s equivalent. Adding one there is a natural
+ * follow-up once the server ships its own printer, matching BLI Memory's own
+ * shape (see that file's header for why the bin's own answer should win when
+ * it can be asked).
+ */
+import { memoryMcpServerEntry } from "./memory-install-contract.js";
+/** The published bin name. Both hosts spawn this — `@bli-cockpit/mcp`'s package.json `bin`. */
+export const TOWER_MCP_BIN = "bli-cockpit-mcp";
+/** The MCP server id, as it appears in `mcp__<server>__<tool>`. */
+export const TOWER_MCP_SERVER_ID = "bli-tower";
+/** The one env var the server is handed. A URL, never a token — same contract as BLI Memory's. */
+export const TOWER_DASHBOARD_URL_ENV = "COCKPIT_DASHBOARD_URL";
+export function builtinTowerInstallConfig(options) {
+    return {
+        server_id: TOWER_MCP_SERVER_ID,
+        mcp_server: memoryMcpServerEntry(options),
+        // No hooks: bli-tower is tools-only. Left as an empty array rather than
+        // omitted so this is still a complete MemoryInstallConfig — the shared
+        // Claude/Codex writers are already generic over "a server with zero
+        // hooks" (see this file's own header).
+        hooks: [],
+        permissions_allow: [],
+    };
+}