@bli-cockpit/cli 0.2.57 → 0.2.58

package/dist/commands/local-help.js

@@ -42,6 +42,8 @@ export const rootCommandNames = new Set([
     "clean",
     "docs",
     "msg",
+    "issue",
+    "project",
     "release",
 ]);
 export function localCommandHelp(command) {
@@ -82,6 +84,8 @@ export function localCommandHelp(command) {
         "  cockpit clean [--dry-run] [--all-committed] [--reconcile] [--dashboard-url <url>] [--json]",
         "  cockpit docs [list|tree|read <id|slug>|create --title <t>|update <id>] [--parent <id>|--clear-parent] [--visibility org|private] [--file <path>|--body-stdin] [--dashboard-url <url>] [--json]",
         "  cockpit msg [channels|read <channel>|send <channel>|thread <id> --channel <channel>] [--thread <id>] [--limit <n>] [--dashboard-url <url>] [--json]",
+        "  cockpit issue [list|show <BLI-id>|create --title <t>|update <BLI-id>|move <BLI-id> <state>|comment <BLI-id>|history <BLI-id>] [--state <s>] [--assignee me|unassigned|<uuid>] [--project <name|id>] [--limit <n>] [--priority 0-4] [--parent <BLI-id>] [--file <path>|--body-stdin] [--dashboard-url <url>] [--json]",
+        "  cockpit project [list] [--archived] [--dashboard-url <url>] [--json]",
         "  cockpit release [--dry-run] [--skip-checks] [--no-floor] [--tag <tag>] [--access <public|restricted>] [--otp <code>]",
         "",
         `Default dashboard: ${DEFAULT_DASHBOARD_URL}. Omit --dashboard-url for normal production use; pass it only for staging/custom dashboards or to force a different pairing.`,
@@ -616,6 +620,36 @@ function localSubcommandHelp(command) {
                 "The command uses the existing paired device identity. Run `cockpit login` first if this machine is not paired.",
             ],
         ],
+        [
+            "issue",
+            [
+                "Usage: cockpit issue [list|show <id>|create|update <id>|move <id> <state>|comment <id>|history <id>] [flags]",
+                "",
+                "Tower's issue tracker. <id> is a BLI-#### identifier (BLI-3654) or an issue's uuid — both work everywhere an issue is named.",
+                "list [--state <s>] [--assignee me|unassigned|<uuid>] [--project <name|id>] [--limit <n>] — the issues you may see, most recently updated first.",
+                "show <id> — one issue: title, state, priority, assignee, description, and every comment on it.",
+                "create --title \"<title>\" [--project <name|id>] [--priority 0-4] [--assignee me|<uuid>] [--parent <id>] [--file <path>] — the DESCRIPTION comes from --file or stdin (`cat plan.md | cockpit issue create --title \"...\"`); neither means no description.",
+                "update <id> [--title \"<t>\"] [--priority 0-4] [--assignee me|<uuid>] [--project <name|id>] [--parent <id>] [--file <path>|--body-stdin] — only the fields you pass change. State does NOT move here; use move.",
+                "move <id> <state> — moves an issue and records the move. States: backlog, todo, in_progress, in_review, done, canceled.",
+                "comment <id> — posts a comment. The body is never taken on the command line: `echo \"shipped\" | cockpit issue comment BLI-3654`.",
+                "history <id> [--limit <n>] — every recorded state move and reassignment, oldest first.",
+                "A project may be named instead of id'd; the name is matched exactly (case-insensitively) against `cockpit project list`.",
+                "--json writes one machine-readable object to stdout; every reason and receipt line stays on stderr.",
+                "A refusal keeps Tower's own reason label — needs_rls_client, issue_not_found_or_unreadable, issue_not_writable, invalid_state, comment_too_long, and so on.",
+                "The command uses the existing paired device identity. Run `cockpit login` first if this machine is not paired.",
+            ],
+        ],
+        [
+            "project",
+            [
+                "Usage: cockpit project [list] [--archived] [--json]",
+                "",
+                "The projects issues are filed under. Bare `cockpit project` lists them.",
+                "list [--archived] — id, active/archived, name. --archived includes archived projects.",
+                "There is no create/update/delete verb: `GET /api/work/projects` is the whole of Tower's project door today.",
+                "--json writes one machine-readable object to stdout; every reason and receipt line stays on stderr.",
+            ],
+        ],
         [
             "release",
             [

package/dist/commands/local.js

@@ -34,6 +34,8 @@ import { runMemoryInstall } from "./memory-install.js";
 import { runClean } from "./clean.js";
 import { runDocs } from "./docs.js";
 import { runMsg } from "./msg.js";
+import { runIssue } from "./issue.js";
+import { runProject } from "./project.js";
 import { parseLocalArgs } from "./local-args.js";
 // `./local.js` is the published entry point for this command surface: the
 // public CLI's generated root, commands/root.ts, doctor.ts and the test suite
@@ -137,6 +139,10 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runDocs(command, io);
             case "msg":
                 return await runMsg(command, io);
+            case "issue":
+                return await runIssue(command, io);
+            case "project":
+                return await runProject(command, io);
             case "release":
                 return await runRelease(command, io);
         }

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

@@ -0,0 +1,140 @@
+import { builtinMemoryInstallConfig, isUnsafeBinPath, MEMORY_MCP_BIN, parsePrintedMemoryInstallConfig, withResolvedBinPath, } from "./memory-install-contract.js";
+import { resolveMcpBin } from "./mcp-bin-resolve.js";
+import { resolveDashboardUrl } from "./memory-install-report.js";
+import { envWithNodeRuntimeOnPath } from "../scheduled-self-update.js";
+/**
+ * `bli-memory-mcp` ships as a DEPENDENCY of `@bli-cockpit/cli` — see
+ * `mcp-bin-resolve.ts` (BLI-3706's generalisation of this BLI-3580 lookup,
+ * shared with `bli-tower`'s registration) for the full two-step walk and the
+ * BLI-3580 story of why it starts at that module's own file rather than
+ * `process.argv[1]`.
+ */
+export async function resolveMemoryMcpBin(options) {
+    return resolveMcpBin({ ...options, binName: MEMORY_MCP_BIN });
+}
+/**
+ * **`no_bin_no_write`.** When `bli-memory-mcp` cannot be resolved, this command
+ * writes NOTHING — not the MCP entry, not the hooks, not the Codex table, not
+ * the skills.
+ *
+ * An earlier revision wrote the registration anyway, on the reasoning that a
+ * correct shape waiting for the package is better than nothing. It is not:
+ * Claude Code RUNS a registered hook. Three hooks pointing at a binary that
+ * does not exist would print a hook failure on every SessionStart, every
+ * prompt and every Stop, on every intern machine, until the package shipped —
+ * a self-inflicted outage in the one surface people look at all day.
+ *
+ * So an absent bin is `skipped bin_missing`: a receipt, not a write. The daily
+ * self-heal retries tomorrow, and the first tick after the package lands does
+ * the whole registration at once.
+ */
+export async function resolveMemoryConfig(command, io, platform, deps) {
+    const dashboardUrl = await resolveDashboardUrl(command, deps);
+    const found = await resolveMemoryMcpBin({
+        env: envWithNodeRuntimeOnPath(io.env ?? process.env),
+        platform,
+        fileExists: deps.fileExists,
+        cliEntryPoint: deps.cliEntryPoint,
+        realpath: deps.realpath,
+    });
+    if (!found) {
+        return {
+            config: null,
+            source: "none",
+            binTarget: {
+                target: "bin",
+                status: "skipped",
+                reason: "bin_missing",
+                detail: `${MEMORY_MCP_BIN} is not installed beside this CLI or on PATH; nothing was written, and the next daily run will try again`,
+            },
+        };
+    }
+    if (isUnsafeBinPath(found.path)) {
+        // A hook command is a shell string by the platform's design. A path that
+        // cannot be quoted safely is not escaped cleverly, and it is not swapped
+        // for a bare name that may resolve to something else either — the install
+        // refuses and says why.
+        return {
+            config: null,
+            source: "none",
+            binTarget: {
+                target: "bin",
+                status: "failed",
+                reason: "bin_path_unsafe",
+                detail: "the resolved bin path contains characters that cannot appear in a hook command; nothing was written",
+            },
+            bin_source: found.source,
+        };
+    }
+    const printed = await printedMemoryConfig(io, found.path);
+    if (printed) {
+        // The bin prints a BARE command name — it cannot know where it was
+        // installed, and it is nested inside the CLI's node_modules rather than on
+        // PATH. Path-qualifying it here is what makes the registration runnable at
+        // all; see `withResolvedBinPath`.
+        const qualified = withResolvedBinPath(printed, {
+            binPath: found.path,
+            platform,
+            dashboardUrl,
+        });
+        if (qualified) {
+            return {
+                config: qualified,
+                source: "bin",
+                binTarget: { target: "bin", status: "already", reason: "bin_printed_config" },
+                bin_source: found.source,
+            };
+        }
+        // A printed hook command this installer cannot re-point. The template is
+        // always path-qualified, so it is the safe answer — and the reason says
+        // which of the two fallbacks happened.
+        return {
+            config: builtinMemoryInstallConfig({ binPath: found.path, platform, dashboardUrl }),
+            source: "template",
+            binTarget: {
+                target: "bin",
+                status: "already",
+                reason: "bin_printed_config_unqualifiable",
+                detail: "the bin printed a hook command this installer could not re-point at the resolved path; the built-in shape was used",
+            },
+            bin_source: found.source,
+        };
+    }
+    return {
+        config: builtinMemoryInstallConfig({
+            binPath: found.path,
+            platform,
+            dashboardUrl,
+        }),
+        source: "template",
+        binTarget: {
+            target: "bin",
+            status: "already",
+            reason: "bin_present_template_used",
+            detail: "the bin did not print a usable --print-config; the built-in shape was used",
+        },
+        bin_source: found.source,
+    };
+}
+/**
+ * Asks the server for its own shape. Arguments go as an ARRAY — nothing is
+ * interpolated into a command line — and on Windows the captured runner routes
+ * a `.cmd` shim through ComSpec with its own escaping (process-runner.ts).
+ */
+async function printedMemoryConfig(io, binPath) {
+    const exec = io.exec;
+    if (!exec)
+        return null;
+    try {
+        const result = await exec(binPath, ["--print-config", "--claude"]);
+        if (result.code !== 0)
+            return null;
+        return parsePrintedMemoryInstallConfig(result.stdout);
+    }
+    catch {
+        // Deliberately silent here: the caller reports
+        // `bin_present_template_used`, which is the same information with a name
+        // on it, and this path is reached on every machine that has an older bin.
+        return null;
+    }
+}

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

@@ -0,0 +1,89 @@
+import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
+export async function resolveDashboardUrl(command, deps) {
+    if (command.dashboardUrl)
+        return command.dashboardUrl;
+    const paths = getCollectorRuntimePaths(deps.homeDir ?? command.homeDir);
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    return config?.dashboard_url ?? DEFAULT_DASHBOARD_URL;
+}
+export function aggregate(targets) {
+    const failed = targets.filter((target) => target.status === "failed");
+    if (failed.length > 0) {
+        return {
+            status: "failed",
+            // The first named reason, not a count: an operator needs the reason, and
+            // the per-target list beside it carries the rest.
+            reason: failed[0]?.reason ?? "unknown_failure",
+        };
+    }
+    if (targets.some((target) => target.status === "would_install")) {
+        return { status: "would_install", reason: "dry_run" };
+    }
+    if (targets.some((target) => target.status === "installed")) {
+        return { status: "installed", reason: "wrote_entry" };
+    }
+    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
+        // the next daily run will try again. `bin_missing` is the only one today.
+        return { status: "skipped", reason: skipped.reason };
+    }
+    return { status: "already", reason: "already_current" };
+}
+/**
+ * Both branches log, and neither carries a path — a home directory names a
+ * person, and this line ends up in `sync.err.log` on every machine.
+ */
+export function logMemoryOutcome(outcome, platform) {
+    const fields = {
+        status: outcome.status,
+        reason: outcome.reason,
+        config_source: outcome.config_source,
+        bin_found: outcome.bin_found,
+        platform,
+        installed_count: outcome.targets.filter((target) => target.status === "installed").length,
+        already_count: outcome.targets.filter((target) => target.status === "already").length,
+        failed: outcome.targets
+            .filter((target) => target.status === "failed")
+            .map((target) => `${target.target}:${target.reason}`),
+    };
+    // stderr on both branches: launchd captures it to sync.err.log, and stdout is
+    // reserved for `--json`.
+    console.error(outcome.status === "failed"
+        ? "[memory-install] BLI Memory is not fully registered on this machine"
+        : "[memory-install] BLI Memory registration converged", JSON.stringify(fields));
+}
+export function memoryOutcomeLines(outcome) {
+    const headline = outcome.status === "installed"
+        ? "BLI Memory registered on this machine."
+        : outcome.status === "already"
+            ? "BLI Memory is already registered on this machine."
+            : outcome.status === "would_install"
+                ? "BLI Memory would be registered (dry run; nothing was written)."
+                : outcome.status === "missing"
+                    ? "BLI Memory is not registered on this machine."
+                    : outcome.status === "skipped"
+                        ? "BLI Memory was not registered and nothing was written: the bli-memory-mcp server is not on this machine yet."
+                        : `BLI Memory is not fully registered: ${outcome.reason}.`;
+    const lines = [headline];
+    for (const target of outcome.targets) {
+        const where = target.path ? ` ${target.path}` : "";
+        const detail = target.detail ? ` — ${target.detail}` : "";
+        lines.push(`  ${target.target}: ${target.status} (${target.reason})${where}${detail}`);
+    }
+    return lines;
+}

package/dist/commands/memory-install.js

@@ -13,37 +13,43 @@
  *   memory-install-claude.ts   ~/.claude.json (user-scope MCP) + ~/.claude/settings.json (hooks, allow-list)
  *   memory-install-codex.ts    ~/.codex/config.toml (one table) + ~/.codex/skills/bli-memory/
  *
- * What this module owns is the decisions around them:
+ * What this module owns is the top-level decision sequence
+ * (BLI-3717 readability pass, 629 lines to a table of contents). Every other
+ * responsibility lives in a `memory-install-*.ts` sibling:
+ *
+ *  - `memory-install-config.ts` — finding `bli-memory-mcp` on this machine
+ *    (`resolveMemoryMcpBin`, over the shared `mcp-bin-resolve.ts` walk) and
+ *    deciding which config shape to write (`resolveMemoryConfig`). **No
+ *    server, no write.** If the bin does not resolve, not one file is opened
+ *    and the outcome is `skipped bin_missing` — see `no_bin_no_write` there
+ *    for why a written-but-inert registration is the worse option.
+ *    `--print-config --claude` wins when the bin answers it; the built-in
+ *    template of the same shape is the fallback for an older server, and it
+ *    is only ever used with a bin that actually resolved.
+ *  - `memory-install-report.ts` — the dashboard URL, aggregating per-target
+ *    results into one outcome, and rendering it for a log line or a
+ *    terminal.
+ *
+ * Two rules bind the whole sequence:
  *
- * - **Where the server is.** `bli-memory-mcp` ships as a DEPENDENCY of
- *   `@bli-cockpit/cli`, so the canonical lookup is the `node_modules/.bin` on
- *   the way up from THIS MODULE's own file — realpath-ed first, because a
- *   global `cockpit` is a symlink and walking up from the symlink finds
- *   nothing; PATH is the fallback. Nobody ever installs a second global
- *   package. See `resolveMemoryMcpBin`, which carries the receipt.
- * - **No server, no write.** If the bin does not resolve, not one file is
- *   opened and the outcome is `skipped bin_missing` — see `no_bin_no_write`
- *   below for why a written-but-inert registration is the worse option.
- * - **Which config shape.** `bli-memory-mcp --print-config --claude` wins when
- *   the bin answers it; the built-in template of the same shape is the
- *   fallback for an older server, and it is only ever used with a bin that
- *   actually resolved.
  * - **Never throw at the caller.** The sync tick calls this. A failure is a
  *   named receipt, never an exception that could cost a machine its
  *   collection tick.
  * - **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.
+ *
+ * Every public name is still importable from this file.
  */
 import os from "node:os";
 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";
 import { installCodexMemoryIntegration, inspectCodexMemoryIntegration, } from "./memory-install-codex.js";
-import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
-import { envWithNodeRuntimeOnPath } from "../scheduled-self-update.js";
+import { resolveMemoryConfig } from "./memory-install-config.js";
+import { aggregate, logMemoryOutcome, memoryOutcomeLines, resolveDashboardUrl } from "./memory-install-report.js";
+export { resolveMemoryMcpBin } from "./memory-install-config.js";
+export { memoryOutcomeLines, resolveDashboardUrl } from "./memory-install-report.js";
 export async function runMemoryInstall(command, io, deps = {}) {
     const outcome = command.action === "status"
         ? await inspectMemoryIntegration(command, io, deps)
@@ -145,261 +151,4 @@ export async function inspectMemoryIntegration(command, io, deps = {}) {
         ...(resolved.bin_source ? { bin_source: resolved.bin_source } : {}),
         targets,
     };
-}
-/**
- * **`no_bin_no_write`.** When `bli-memory-mcp` cannot be resolved, this command
- * writes NOTHING — not the MCP entry, not the hooks, not the Codex table, not
- * the skills.
- *
- * An earlier revision wrote the registration anyway, on the reasoning that a
- * correct shape waiting for the package is better than nothing. It is not:
- * Claude Code RUNS a registered hook. Three hooks pointing at a binary that
- * does not exist would print a hook failure on every SessionStart, every
- * prompt and every Stop, on every intern machine, until the package shipped —
- * a self-inflicted outage in the one surface people look at all day.
- *
- * So an absent bin is `skipped bin_missing`: a receipt, not a write. The daily
- * self-heal retries tomorrow, and the first tick after the package lands does
- * the whole registration at once.
- */
-async function resolveMemoryConfig(command, io, platform, deps) {
-    const dashboardUrl = await resolveDashboardUrl(command, deps);
-    const found = await resolveMemoryMcpBin({
-        env: envWithNodeRuntimeOnPath(io.env ?? process.env),
-        platform,
-        fileExists: deps.fileExists,
-        cliEntryPoint: deps.cliEntryPoint,
-        realpath: deps.realpath,
-    });
-    if (!found) {
-        return {
-            config: null,
-            source: "none",
-            binTarget: {
-                target: "bin",
-                status: "skipped",
-                reason: "bin_missing",
-                detail: `${MEMORY_MCP_BIN} is not installed beside this CLI or on PATH; nothing was written, and the next daily run will try again`,
-            },
-        };
-    }
-    if (isUnsafeBinPath(found.path)) {
-        // A hook command is a shell string by the platform's design. A path that
-        // cannot be quoted safely is not escaped cleverly, and it is not swapped
-        // for a bare name that may resolve to something else either — the install
-        // refuses and says why.
-        return {
-            config: null,
-            source: "none",
-            binTarget: {
-                target: "bin",
-                status: "failed",
-                reason: "bin_path_unsafe",
-                detail: "the resolved bin path contains characters that cannot appear in a hook command; nothing was written",
-            },
-            bin_source: found.source,
-        };
-    }
-    const printed = await printedMemoryConfig(io, found.path);
-    if (printed) {
-        // The bin prints a BARE command name — it cannot know where it was
-        // installed, and it is nested inside the CLI's node_modules rather than on
-        // PATH. Path-qualifying it here is what makes the registration runnable at
-        // all; see `withResolvedBinPath`.
-        const qualified = withResolvedBinPath(printed, {
-            binPath: found.path,
-            platform,
-            dashboardUrl,
-        });
-        if (qualified) {
-            return {
-                config: qualified,
-                source: "bin",
-                binTarget: { target: "bin", status: "already", reason: "bin_printed_config" },
-                bin_source: found.source,
-            };
-        }
-        // A printed hook command this installer cannot re-point. The template is
-        // always path-qualified, so it is the safe answer — and the reason says
-        // which of the two fallbacks happened.
-        return {
-            config: builtinMemoryInstallConfig({ binPath: found.path, platform, dashboardUrl }),
-            source: "template",
-            binTarget: {
-                target: "bin",
-                status: "already",
-                reason: "bin_printed_config_unqualifiable",
-                detail: "the bin printed a hook command this installer could not re-point at the resolved path; the built-in shape was used",
-            },
-            bin_source: found.source,
-        };
-    }
-    return {
-        config: builtinMemoryInstallConfig({
-            binPath: found.path,
-            platform,
-            dashboardUrl,
-        }),
-        source: "template",
-        binTarget: {
-            target: "bin",
-            status: "already",
-            reason: "bin_present_template_used",
-            detail: "the bin did not print a usable --print-config; the built-in shape was used",
-        },
-        bin_source: found.source,
-    };
-}
-/**
- * Asks the server for its own shape. Arguments go as an ARRAY — nothing is
- * interpolated into a command line — and on Windows the captured runner routes
- * a `.cmd` shim through ComSpec with its own escaping (process-runner.ts).
- */
-async function printedMemoryConfig(io, binPath) {
-    const exec = io.exec;
-    if (!exec)
-        return null;
-    try {
-        const result = await exec(binPath, ["--print-config", "--claude"]);
-        if (result.code !== 0)
-            return null;
-        return parsePrintedMemoryInstallConfig(result.stdout);
-    }
-    catch {
-        // Deliberately silent here: the caller reports
-        // `bin_present_template_used`, which is the same information with a name
-        // on it, and this path is reached on every machine that has an older bin.
-        return null;
-    }
-}
-/**
- * Two steps, in this order, and the first is the canonical one.
- *
- * **1. Beside the CLI that is running.** `bli-memory-mcp` ships as a DEPENDENCY
- * of `@bli-cockpit/cli`, so installing the CLI installs the server, and npm
- * links its bin into a `node_modules/.bin` on the path from this package up to
- * the install root — `…/@bli-cockpit/cli/node_modules/.bin` when it is nested,
- * `…/lib/node_modules/.bin` when npm hoists it. It is the ONLY lookup that
- * cannot find somebody else's `bli-memory-mcp`. Nobody ever runs `npm i -g` for
- * a second package.
- *
- * **2. PATH, as a fallback**, for a linked checkout or a hand-installed server.
- * Done in this process rather than through `which`/`where`: it spawns nothing,
- * behaves the same on both host families, and is testable without a fixture
- * binary. The npm global bin sits beside the running node binary in the
- * standard layouts, which is why the caller passes a PATH that already includes
- * it (`envWithNodeRuntimeOnPath`) — the launchd tick's PATH is otherwise
- * `/usr/bin:/bin:/usr/sbin:/sbin` and would find nothing.
- *
- * **What step 1 got wrong on the first real machine** (BLI-3580, CLI 0.2.50):
- * it walked up from `process.argv[1]`, resolved with `path.resolve` and no
- * symlink following. For a global install `argv[1]` is the SHIM — on Edward's
- * Mac `/opt/homebrew/bin/cockpit`, a symlink into
- * `/opt/homebrew/lib/node_modules/@bli-cockpit/cli/dist/cli.js`. The walk
- * therefore started in `/opt/homebrew/bin`, went up through `/opt` to `/`, and
- * never came within reach of the nested `.bin` that was sitting right there.
- * Every machine reported `skipped bin_missing` with the server installed.
- *
- * Two changes, both in `besideAnchors` / `resolveBesideCli`:
- *
- *  - The anchor is **this module's own file** first (`import.meta.url`), which
- *    is inside the installed package by construction and is never a shim. The
- *    entry point (injected, or `argv[1]`) stays as a second anchor for a build
- *    layout where this module has been bundled somewhere else.
- *  - Every anchor is **realpath-ed** before the walk, so a symlinked entry
- *    lands in the real tree. A path that will not resolve is used as given —
- *    the same bounded silence `container-tag.ts` uses, because a path that
- *    cannot be realpath-ed still identifies a directory well enough to look in.
- */
-export async function resolveMemoryMcpBin(options) {
-    return resolveMcpBin({ ...options, binName: MEMORY_MCP_BIN });
-}
-/** 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);
-    const config = await readLocalCollectorConfig(paths).catch(() => null);
-    return config?.dashboard_url ?? DEFAULT_DASHBOARD_URL;
-}
-function aggregate(targets) {
-    const failed = targets.filter((target) => target.status === "failed");
-    if (failed.length > 0) {
-        return {
-            status: "failed",
-            // The first named reason, not a count: an operator needs the reason, and
-            // the per-target list beside it carries the rest.
-            reason: failed[0]?.reason ?? "unknown_failure",
-        };
-    }
-    if (targets.some((target) => target.status === "would_install")) {
-        return { status: "would_install", reason: "dry_run" };
-    }
-    if (targets.some((target) => target.status === "installed")) {
-        return { status: "installed", reason: "wrote_entry" };
-    }
-    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
-        // the next daily run will try again. `bin_missing` is the only one today.
-        return { status: "skipped", reason: skipped.reason };
-    }
-    return { status: "already", reason: "already_current" };
-}
-/**
- * Both branches log, and neither carries a path — a home directory names a
- * person, and this line ends up in `sync.err.log` on every machine.
- */
-function logMemoryOutcome(outcome, platform) {
-    const fields = {
-        status: outcome.status,
-        reason: outcome.reason,
-        config_source: outcome.config_source,
-        bin_found: outcome.bin_found,
-        platform,
-        installed_count: outcome.targets.filter((target) => target.status === "installed").length,
-        already_count: outcome.targets.filter((target) => target.status === "already").length,
-        failed: outcome.targets
-            .filter((target) => target.status === "failed")
-            .map((target) => `${target.target}:${target.reason}`),
-    };
-    // stderr on both branches: launchd captures it to sync.err.log, and stdout is
-    // reserved for `--json`.
-    console.error(outcome.status === "failed"
-        ? "[memory-install] BLI Memory is not fully registered on this machine"
-        : "[memory-install] BLI Memory registration converged", JSON.stringify(fields));
-}
-export function memoryOutcomeLines(outcome) {
-    const headline = outcome.status === "installed"
-        ? "BLI Memory registered on this machine."
-        : outcome.status === "already"
-            ? "BLI Memory is already registered on this machine."
-            : outcome.status === "would_install"
-                ? "BLI Memory would be registered (dry run; nothing was written)."
-                : outcome.status === "missing"
-                    ? "BLI Memory is not registered on this machine."
-                    : outcome.status === "skipped"
-                        ? "BLI Memory was not registered and nothing was written: the bli-memory-mcp server is not on this machine yet."
-                        : `BLI Memory is not fully registered: ${outcome.reason}.`;
-    const lines = [headline];
-    for (const target of outcome.targets) {
-        const where = target.path ? ` ${target.path}` : "";
-        const detail = target.detail ? ` — ${target.detail}` : "";
-        lines.push(`  ${target.target}: ${target.status} (${target.reason})${where}${detail}`);
-    }
-    return lines;
 }