@bli-cockpit/cli 0.2.57 → 0.2.59

package/dist/commands/login.js

@@ -1,6 +1,9 @@
-import { writeLine } from "./cli-io.js";
+import { openInBrowser } from "./browser-open.js";
+import { errorMessage, writeLine } from "./cli-io.js";
 import { pairLocalCollectorWithAuthFallback, requestPairingAccessToken, resolveInteractiveLoginEmail, } from "./local-auth.js";
 import { ensureLocalCollectorConfig } from "../local-state.js";
+import { pairLocalCollectorViaLink, } from "../local-state-pairing-code.js";
+const TAG = "[login]";
 export async function runLogin(command, io) {
     // Standalone `cockpit login` must work on a fresh machine: bootstrap a
     // minimal rootless config when onboard/install has not run yet, instead of
@@ -13,6 +16,23 @@ export async function runLogin(command, io) {
     if (created && !command.json) {
         writeLine(io.stdout, `First login on this machine; wrote collector config: ${paths.config_file}`);
     }
+    if (!command.legacyPair) {
+        const linked = await tryOneLinkLogin(command, dashboardUrl, io);
+        if (linked) {
+            reportPaired(command, io, {
+                email: linked.session.email ?? linked.session.auth_subject_id,
+                deviceName: linked.session.device_name ?? linked.session.device_id ?? "unknown",
+                sessionFile: linked.session_file,
+                json: linked,
+            });
+            writeNextStep(command, io, config.default_repo_paths.length > 0);
+            return 0;
+        }
+        // `--pair <code>` is a code somebody minted on purpose; falling back to a
+        // second sign-in ceremony would be answering a different question.
+        if (command.pairCode)
+            return 1;
+    }
     const claimedOwnerEmail = await resolveInteractiveLoginEmail(command, io);
     const pairingAccessToken = await requestPairingAccessToken({
         dashboardUrl,
@@ -38,16 +58,79 @@ export async function runLogin(command, io) {
                 writeLine(io.stdout, "Waiting for dashboard approval...");
             },
     }, io);
+    reportPaired(command, io, {
+        email: result.session.email ?? result.session.auth_subject_id,
+        deviceName: result.session.device_name ?? result.session.device_id ?? "unknown",
+        sessionFile: result.session_file,
+        json: result,
+    });
+    writeNextStep(command, io, config.default_repo_paths.length > 0);
+    return 0;
+}
+/**
+ * The one-link ceremony. Returns null when it could not finish, having already
+ * said why — the caller then runs the legacy arm rather than stopping, because
+ * a machine that cannot pair is worse than a machine that pairs the old way.
+ */
+async function tryOneLinkLogin(command, dashboardUrl, io) {
+    try {
+        return await pairLocalCollectorViaLink({
+            homeDir: command.homeDir,
+            dashboardUrl,
+            deviceName: command.deviceName,
+            claimedOwnerEmail: command.claimedOwnerEmail,
+            pairCode: command.pairCode,
+            pollIntervalMs: command.pollIntervalMs,
+            timeoutMs: command.timeoutMs,
+            fetch: io.fetch,
+            onLinkReady: command.json
+                ? undefined
+                : (link) => announceLink(command, io, link),
+        });
+    }
+    catch (error) {
+        const reason = error && typeof error === "object" && "reason" in error
+            ? String(error.reason)
+            : "pair_link_failed";
+        console.error(`${TAG} one-link pairing did not finish`, JSON.stringify({ reason, falling_back: !command.pairCode }));
+        writeLine(io.stderr, `Sign-in link did not finish: ${errorMessage(error)}`);
+        writeLine(io.stderr, command.pairCode
+            ? "That code was minted in a browser; run `cockpit login` with no flags to start over."
+            : "Falling back to the email-code sign-in.");
+        return null;
+    }
+}
+/** Print the link, then try to open it. Printing first is what makes the open optional. */
+function announceLink(command, io, link) {
+    writeLine(io.stdout, "Sign in to Tower once, and this machine is connected.");
+    writeLine(io.stdout, `Open: ${link.connect_url}`);
+    writeLine(io.stdout, "Waiting for that sign-in...");
+    if (command.noBrowser) {
+        console.error(`${TAG} browser not opened`, JSON.stringify({ reason: "no_browser_flag" }));
+        return;
+    }
+    const opened = openInBrowser(link.connect_url);
+    console.error(`${TAG} browser open attempted`, JSON.stringify(opened.ok
+        ? { reason: opened.reason, program: opened.program }
+        : { reason: opened.reason }));
+    if (!opened.ok) {
+        writeLine(io.stdout, `(${opened.detail} The link above still works.)`);
+    }
+}
+function reportPaired(command, io, paired) {
     if (command.json) {
-        writeLine(io.stdout, JSON.stringify(result, null, 2));
-        return 0;
+        writeLine(io.stdout, JSON.stringify(paired.json, null, 2));
+        return;
     }
     writeLine(io.stdout, "Tower collector paired.");
-    writeLine(io.stdout, `Session: ${result.session_file}`);
-    writeLine(io.stdout, `User: ${result.session.email ?? result.session.auth_subject_id}`);
-    writeLine(io.stdout, `Device: ${result.session.device_name ?? result.session.device_id ?? "unknown"}`);
-    writeLine(io.stdout, config.default_repo_paths.length > 0
+    writeLine(io.stdout, `Session: ${paired.sessionFile}`);
+    writeLine(io.stdout, `User: ${paired.email}`);
+    writeLine(io.stdout, `Device: ${paired.deviceName}`);
+}
+function writeNextStep(command, io, hasRepoPaths) {
+    if (command.json)
+        return;
+    writeLine(io.stdout, hasRepoPaths
         ? "Next: run `cockpit start` inside the repo."
         : "Next: run `cockpit onboard` from your repo root so Tower knows which repos to collect.");
-    return 0;
 }

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

@@ -185,13 +185,21 @@ export function mcpServerMatches(root, config) {
  * Claude Code's hook shape, verbatim: `hooks.<Event>` is an ARRAY of matcher
  * groups, each `{ matcher?, hooks: [{ type: "command", command, timeout? }] }`.
  * The matcher is omitted on purpose — all three events want every source.
+ *
+ * Exported for `memory-install-codex-hooks.ts` (BLI-3729): Codex's own
+ * `hooks.json` uses THE SAME three levels, the same event names and the same
+ * `type: "command"` handler (learn.chatgpt.com/docs/hooks, read 2026-09-05), so
+ * the merge that keeps a person's own hooks and replaces exactly ours has one
+ * owner rather than two copies that drift.
  */
-function applyHooksAndPermissions(root, config) {
+export function applyHookGroups(root, hookSpecs) {
     const hooks = asRecord(root["hooks"]) ?? {};
-    for (const spec of config.hooks) {
+    for (const spec of hookSpecs) {
         const groups = Array.isArray(hooks[spec.event])
             ? hooks[spec.event].slice()
             : [];
+        // Somebody else's Stop hook survives untouched; only OUR entries — matched
+        // by bin name plus `hook`, wherever the bin ended up — are replaced.
         const survivors = groups.filter((group) => !groupIsOurs(group));
         survivors.push({
             hooks: [
@@ -205,6 +213,26 @@ function applyHooksAndPermissions(root, config) {
         hooks[spec.event] = survivors;
     }
     root["hooks"] = hooks;
+    return root;
+}
+/** Exported for `memory-install-codex-hooks.ts` — see `applyHookGroups`. */
+export function hookGroupsMatch(root, hookSpecs) {
+    const hooks = asRecord(root["hooks"]);
+    if (!hooks)
+        return false;
+    for (const spec of hookSpecs) {
+        const groups = Array.isArray(hooks[spec.event]) ? hooks[spec.event] : [];
+        const ours = groups.filter(groupIsOurs);
+        if (ours.length !== 1)
+            return false;
+        const commands = hookCommands(ours[0]);
+        if (commands.length !== 1 || commands[0] !== spec.command)
+            return false;
+    }
+    return true;
+}
+function applyHooksAndPermissions(root, config) {
+    applyHookGroups(root, config.hooks);
     if (config.permissions_allow.length > 0) {
         const permissions = asRecord(root["permissions"]) ?? {};
         const allow = Array.isArray(permissions["allow"])
@@ -220,23 +248,14 @@ function applyHooksAndPermissions(root, config) {
     return root;
 }
 function hooksAndPermissionsMatch(root, config) {
-    const hooks = asRecord(root["hooks"]);
-    if (!hooks)
+    if (!hookGroupsMatch(root, config.hooks))
         return false;
-    for (const spec of config.hooks) {
-        const groups = Array.isArray(hooks[spec.event]) ? hooks[spec.event] : [];
-        const ours = groups.filter(groupIsOurs);
-        if (ours.length !== 1)
-            return false;
-        const commands = hookCommands(ours[0]);
-        if (commands.length !== 1 || commands[0] !== spec.command)
-            return false;
-    }
     const allow = asRecord(root["permissions"])?.["allow"];
     const allowed = Array.isArray(allow) ? allow : [];
     return config.permissions_allow.every((rule) => allowed.includes(rule));
 }
-function ourHookCount(root) {
+/** Exported for `memory-install-codex-hooks.ts` — see `applyHookGroups`. */
+export function ourHookCount(root) {
     const hooks = asRecord(root["hooks"]);
     if (!hooks)
         return 0;
@@ -262,7 +281,8 @@ function hookCommands(group) {
 function failure(target, file, reason, detail) {
     return { target, status: "failed", reason, path: file, detail };
 }
-function parseJsonRecord(raw) {
+/** Exported for `memory-install-codex-hooks.ts` — one JSON-record parser, not two. */
+export function parseJsonRecord(raw) {
     try {
         const parsed = JSON.parse(raw);
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))

package/dist/commands/memory-install-codex-hooks.js

@@ -0,0 +1,200 @@
+/**
+ * CODEX HOOK PARITY (BLI-3729) — recall on every prompt and save on every turn
+ * for Codex, the way Claude Code has had since BLI-3580.
+ *
+ * ## What the platform actually offers, fact-checked
+ *
+ * Source: OpenAI's own hooks reference, <https://learn.chatgpt.com/docs/hooks>,
+ * read 2026-09-05, against `codex-cli 0.144.1`. Four findings, all of which
+ * changed the shape of this module:
+ *
+ *  1. **User-scope hooks exist.** Codex discovers hooks "next to active config
+ *     layers", and names `~/.codex/hooks.json` as one of the four useful
+ *     locations. "In untrusted projects, Codex still loads user and system
+ *     hooks from their own active config layers." So this installs ONE file in
+ *     the person's home directory — it does NOT walk their collection roots
+ *     writing a `.codex/hooks.json` into every repo, which would put an
+ *     untracked file in somebody's working tree and need trusting once per
+ *     repo forever.
+ *  2. **The file shape is Claude Code's, verbatim.** Event → array of matcher
+ *     groups → `hooks: [{ type: "command", command, timeout }]`, with the same
+ *     event NAMES: `SessionStart`, `UserPromptSubmit`, `Stop`. That is why the
+ *     merge here is `applyHookGroups` from `memory-install-claude.ts` and not
+ *     a second copy: same contract, one owner.
+ *  3. **Hooks are on by default now.** `[features] hooks = false` turns them
+ *     off; `codex_hooks` is a DEPRECATED ALIAS for the same key. The premise
+ *     that a person must first opt in with `codex_hooks = true` is stale — it
+ *     was true of the version whose trust rows are still sitting in Edward's
+ *     `config.toml`, and it is not true of 0.144.1.
+ *  4. **Trust is per hook definition, and it is the whole catch.** "Before a
+ *     non-managed command hook can run, Codex requires you to review and trust
+ *     the exact hook definition. Codex records trust against the hook's current
+ *     hash, so new or changed hooks are marked for review and skipped until
+ *     trusted." `/hooks` in the CLI is that surface. So a machine can be
+ *     perfectly installed and running nothing, which is exactly the state
+ *     `needs_trust` exists to name — and it is the one step an intern has to
+ *     do by hand.
+ *
+ * ## What is NOT verified
+ *
+ * Nobody has yet trusted these hooks on a real machine, so the wiring past the
+ * write is unproven end to end: the file shape, the event names and the trust
+ * mechanism come from the vendor's current documentation and from trust rows
+ * this repo's owner's own machine already carries, not from a green run. The
+ * receipt is built so that failure is visible rather than assumed away — an
+ * untrusted machine reads `needs_trust`, never `ok`.
+ *
+ * ## The trust read is a FLOOR, deliberately
+ *
+ * A trust row is `[hooks.state."<source>:<event>:<group>:<hook>"]` carrying
+ * `trusted_hash` and sometimes `enabled`. This module cannot recompute Codex's
+ * hash, so it cannot prove the stored hash still matches the file we just
+ * wrote. It counts rows for OUR hooks file that are not explicitly disabled,
+ * and reports `ok` only when there are at least as many as we installed hooks.
+ * That can understate (a trusted machine whose row keys we failed to match
+ * reads `needs_trust`, and the fix is one `/hooks` visit) and cannot overstate.
+ * A gauge that can only be too pessimistic is the right way round for this one.
+ */
+import path from "node:path";
+import { applyHookGroups, applyJsonTarget, hookGroupsMatch, inspectJsonTarget, ourHookCount, } from "./memory-install-claude.js";
+export function codexHooksFile(homeDir) {
+    return path.join(homeDir, ".codex", "hooks.json");
+}
+export function codexConfigTomlFile(homeDir) {
+    return path.join(homeDir, ".codex", "config.toml");
+}
+export async function installCodexMemoryHooks(options) {
+    return applyJsonTarget({
+        target: "codex_hooks",
+        file: codexHooksFile(options.homeDir),
+        options,
+        apply: (root) => applyHookGroups(root, options.config.hooks),
+        matches: (root) => hookGroupsMatch(root, options.config.hooks),
+    });
+}
+export async function inspectCodexMemoryHooks(options) {
+    return inspectJsonTarget({
+        target: "codex_hooks",
+        file: codexHooksFile(options.homeDir),
+        io: options.io,
+        present: (root) => ourHookCount(root) > 0,
+        matches: (root) => hookGroupsMatch(root, options.config.hooks),
+    });
+}
+/**
+ * Reads the trust state out of `~/.codex/config.toml` WITHOUT parsing the
+ * whole file.
+ *
+ * That file is a person's own configuration — model, approval policy, sandbox,
+ * their other servers — and this module has no business understanding all of
+ * it. It walks lines, tracks the current table header, and looks at exactly
+ * two things: the `hooks` feature key, and `[hooks.state."…"]` headers whose
+ * quoted source is our hooks file. Nothing is written here, ever.
+ *
+ * The trust key's event segment is matched case-INSENSITIVELY and by prefix
+ * only: an older Codex spelled the events `user_prompt_submit`, the current
+ * one spells them `UserPromptSubmit`, and a reader that insisted on one
+ * spelling would report a trusted machine as untrusted the day the vendor
+ * changed its mind again.
+ */
+export function readCodexHookTrust(raw, hooksFilePath) {
+    if (raw === null) {
+        // No config.toml at all. Hooks are on by default, and nothing has been
+        // trusted, which is exactly `enabled` + zero rows.
+        return { feature: "enabled", trustedRows: 0, disabledRows: 0 };
+    }
+    const wanted = normalizeTrustSource(hooksFilePath);
+    let feature = "enabled";
+    let currentTable = "";
+    let inOurTrustTable = false;
+    let sawTrustedHash = false;
+    let sawDisabled = false;
+    let trustedRows = 0;
+    let disabledRows = 0;
+    const flushTrustRow = () => {
+        if (!inOurTrustTable || !sawTrustedHash)
+            return;
+        if (sawDisabled)
+            disabledRows += 1;
+        else
+            trustedRows += 1;
+    };
+    for (const line of raw.split("\n")) {
+        const header = /^\s*\[+([^\]]+)\]+\s*$/u.exec(line);
+        if (header) {
+            flushTrustRow();
+            currentTable = (header[1] ?? "").trim();
+            inOurTrustTable = trustTableNamesOurFile(currentTable, wanted);
+            sawTrustedHash = false;
+            sawDisabled = false;
+            continue;
+        }
+        const assignment = /^\s*([A-Za-z0-9_-]+)\s*=\s*(.+?)\s*$/u.exec(line);
+        if (!assignment)
+            continue;
+        const key = (assignment[1] ?? "").toLowerCase();
+        const value = (assignment[2] ?? "").toLowerCase();
+        // `[features] hooks = false`, and its deprecated alias `codex_hooks`.
+        if (currentTable === "features" && (key === "hooks" || key === "codex_hooks")) {
+            if (value.startsWith("false"))
+                feature = "disabled";
+            continue;
+        }
+        if (!inOurTrustTable)
+            continue;
+        if (key === "trusted_hash")
+            sawTrustedHash = true;
+        if (key === "enabled" && value.startsWith("false"))
+            sawDisabled = true;
+    }
+    flushTrustRow();
+    return { feature, trustedRows, disabledRows };
+}
+/** Reads the person's `config.toml` through the injected io and judges trust. */
+export async function readCodexHookTrustFromDisk(options) {
+    const file = codexConfigTomlFile(options.homeDir);
+    try {
+        const raw = await options.io.readText(file);
+        return readCodexHookTrust(raw, codexHooksFile(options.homeDir));
+    }
+    catch {
+        // An unreadable config is not an untrusted machine, and must not be
+        // reported as one — `config_unreadable` says which question could not be
+        // answered rather than answering it wrongly.
+        return { feature: "config_unreadable", trustedRows: 0, disabledRows: 0 };
+    }
+}
+/**
+ * `"/Users/x/.codex/hooks.json"` → the same string, case-folded on Windows
+ * only and with separators normalized, so the header we scan for compares
+ * equal to the path we wrote whichever way either was spelled.
+ */
+function normalizeTrustSource(value) {
+    const unquoted = value.replace(/^["']|["']$/gu, "");
+    const slashed = unquoted.replace(/\\/gu, "/");
+    return process.platform === "win32" ? slashed.toLowerCase() : slashed;
+}
+/**
+ * `hooks.state."<source>:<event>:<group>:<hook>"` — is `<source>` our file?
+ *
+ * The key is split on the LAST three colons, because a Windows source is
+ * `C:/Users/…` and carries one of its own.
+ */
+function trustTableNamesOurFile(tableHeader, wantedSource) {
+    const match = /^hooks\.state\.\s*["']([\s\S]+)["']\s*$/u.exec(tableHeader.trim());
+    if (!match)
+        return false;
+    const key = match[1] ?? "";
+    const segments = key.split(":");
+    if (segments.length < 4)
+        return false;
+    const source = segments.slice(0, segments.length - 3).join(":");
+    return normalizeTrustSource(source) === wantedSource;
+}
+/**
+ * How many hook entries a trusted machine should have rows for. One per event,
+ * which is what `applyHookGroups` writes.
+ */
+export function expectedCodexTrustRows(config) {
+    return config.hooks.length;
+}

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

@@ -1,13 +1,19 @@
 /**
  * The Codex half of `cockpit memory install` (BLI-3580).
  *
- * TWO targets:
+ * THREE targets:
  *
  *   ~/.codex/config.toml            one table, `[mcp_servers.bli-memory]`.
  *   ~/.codex/skills/bli-memory/     the skill that teaches Codex when to
  *                                   recall, save, update and forget — taking
  *                                   over the job the four `supermemory-*`
  *                                   skills did on Edward's machine.
+ *   ~/.codex/hooks.json             the same three lifecycle hooks Claude Code
+ *                                   gets, at USER scope (BLI-3729). Owned by
+ *                                   `memory-install-codex-hooks.ts`, which
+ *                                   carries the vendor citation and the
+ *                                   per-hook TRUST story — the one step this
+ *                                   installer cannot do for a person.
  *
  * **`config.toml` is somebody's own configuration and is treated that way.**
  * The standing rule for that file is "never change HIS settings"; this respects
@@ -25,6 +31,7 @@ import path from "node:path";
 import { MEMORY_MCP_SERVER_ID, } from "./memory-install-contract.js";
 import { findTomlTableSpan, readTomlTable, renderTomlTable, upsertTomlTable, } from "./memory-install-toml.js";
 import { memoryCodexSkillFiles } from "./memory-install-skills.js";
+import { installCodexMemoryHooks, inspectCodexMemoryHooks, } from "./memory-install-codex-hooks.js";
 const MEMORY_TOML_PATH = ["mcp_servers", MEMORY_MCP_SERVER_ID];
 export function codexConfigFile(homeDir) {
     return path.join(homeDir, ".codex", "config.toml");
@@ -36,6 +43,9 @@ export async function installCodexMemoryIntegration(options) {
     return [
         await applyCodexMcpTable(options),
         await applyCodexSkills(options),
+        // BLI-3729. Independent of the two above: a machine with the MCP table and
+        // no hooks is a real machine, and it is the common one today.
+        await installCodexMemoryHooks(options),
     ];
 }
 export async function inspectCodexMemoryIntegration(options) {
@@ -72,7 +82,7 @@ export async function inspectCodexMemoryIntegration(options) {
                 path: directory,
                 detail: `${current} of ${total} skill files current`,
             };
-    return [mcp, skills];
+    return [mcp, skills, await inspectCodexMemoryHooks(options)];
 }
 async function applyCodexMcpTable(options) {
     const file = codexConfigFile(options.homeDir);

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;
+    }
+}