@consiliency/agent-board-cli 1.25.0 → 1.27.0

package/dist/setup_writers.js

@@ -2,9 +2,11 @@
 // versions this cli build baked (IF-0-SETUP-1, IF-0-SETUP-4).
 //
 //   harness   how                                                  setup's own exact check
-//   claude    `claude plugin marketplace add …@<releaseTag>`       our plugin row's version = the
-//             + `install` (or `update` over an older one)           baked mcp version and its ref = the
-//                                                                   baked release tag
+//   claude    materialise the packaged marketplace into            our plugin row's version = the
+//             `claudeMarketplaceDir` (per user), then              baked mcp version, the scope's
+//             `claude plugin marketplace add <that dir>`           marketplace source is that
+//             + `install` (or `update` over an older one)           directory, and its content is
+//                                                                   byte-equal to the packaged copy
 //   pi        `pi install [-l] npm:@consiliency/agent-board-pi@<v>` exactly that spec, once
 //   opencode  `opencode plugin @consiliency/agent-board-opencode@<v> [-g]`   exactly that spec, once
 //   codex     `[mcp_servers.agent-board]` in config.toml (writer)  the stanza deep-equals ours
@@ -19,19 +21,20 @@
 // Every `reason` is an authored code. File content (a server name, a path) only reaches the
 // human `fix`, and a server name only when it is a plain token.
 import { spawn } from "node:child_process";
-import { constants as FS, accessSync, lstatSync, mkdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { constants as FS, accessSync, chmodSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import * as fsp from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, delimiter, dirname, isAbsolute, join } from "node:path";
 import { normalizeKeyReference } from "@consiliency/agent-board-client";
+import { resolveMarketplaceDir } from "./assets.js";
+import { MARKETPLACE_MANIFEST_KEY, claudeMarketplaceDir, compareVersions, describeTrustProblem, isOurMarketplacePath, pluginVersionIn, readTree, resolveTrustChain, sameTree, } from "./claude_marketplace.js";
 import { ConfigEditRefused, upsertJsonMember, upsertTomlTable } from "./config_edit.js";
 import { REPORTABLE_TOKEN } from "./doctor.js";
-import { CLAUDE_PLUGIN_ID, CLAUDE_PLUGIN_MARKETPLACE, CLAUDE_PLUGIN_MCP_PACKAGE, CLAUDE_PLUGIN_SERVER, HARNESS_CONFIG_SCOPES, OPENCODE_PLUGIN_PACKAGE, PI_PACKAGE, claudeProjectKey, judgeMcpEntry, nodeRegistrationFs, own, packageIdentity, parseRestrictedToml, readClaudePluginScopes, readScopes, } from "./doctor_scopes.js";
+import { CLAUDE_PLUGIN_ID, CLAUDE_PLUGIN_MARKETPLACE, CLAUDE_PLUGIN_MCP_PACKAGE, CLAUDE_PLUGIN_SERVER, HARNESS_CONFIG_SCOPES, OPENCODE_PLUGIN_PACKAGE, PI_PACKAGE, claudeMarketplaceDeclarations, claudeProjectKey, judgeMcpEntry, nodeRegistrationFs, own, packageIdentity, parseRestrictedToml, readClaudePluginScopes, readScopes, } from "./doctor_scopes.js";
 export const SETUP_SCOPES = Object.freeze(["user", "local"]);
 /** The server name setup writes; the same name the claude plugin registers. */
 export const BOARD_SERVER_NAME = CLAUDE_PLUGIN_SERVER;
-/** `Consiliency/message-board`: the marketplace source, pinned to the baked release tag. */
-export const CLAUDE_MARKETPLACE_REPO = "Consiliency/message-board";
 /**
  * What codex hands an MCP child and nothing else (`process_ancestry.ts`, measured 2026-09-18 on
  * codex 0.155.0, across three configurations including `shell_environment_policy.inherit=all`).
@@ -167,8 +170,8 @@ const OWNED_ENTRY_KEYS = new Set(["command", "args", "env"]);
 export const OWNED_ENV_NAMES = new Set([
     ...CODEX_PATH_INPUTS, ...KEYCHAIN_CHILD_INPUTS, "SSH_AUTH_SOCK", "MESSAGE_BOARD_AGENT_SOCKET_PATH",
 ]);
-function scopeContext(env, cwd, fs, claudeManagedDir) {
-    return { cwd, home: homeOf(env), env, fs, claudeManagedDir };
+function scopeContext(env, cwd, fs, claudeManagedDir, extra = {}) {
+    return { cwd, home: homeOf(env), env, fs, claudeManagedDir, ...extra };
 }
 const row = (harness, name) => {
     const found = HARNESS_CONFIG_SCOPES[harness].find((candidate) => candidate.name === name);
@@ -553,7 +556,11 @@ function claudeScopeInstall(ctx, scope) {
             && (scope === "user" || (typeof own(candidate, "projectPath") === "string" && real(own(candidate, "projectPath")) === real(ctx.cwd))))
         : undefined;
     const settings = json(cliWriteTargets("claude", scope, ctx)[0]);
-    const ref = own(own(own(own(settings, "extraKnownMarketplaces"), CLAUDE_PLUGIN_MARKETPLACE), "source"), "ref");
+    // This scope's declared source must be exactly our per-user directory (#549): a github ref (a
+    // fleet host installed before it) or any other directory is migrated by re-declaring it.
+    const source = own(own(own(settings, "extraKnownMarketplaces"), CLAUDE_PLUGIN_MARKETPLACE), "source");
+    const path = own(source, "path");
+    const directory = own(source, "source") === "directory" && isOurMarketplacePath(path, ctx.env, ctx.home);
     const version = own(row, "version");
     return {
         row: row !== undefined,
@@ -561,28 +568,242 @@ function claudeScopeInstall(ctx, scope) {
         enabled: own(own(settings, "enabledPlugins"), CLAUDE_PLUGIN_ID) === true,
         // The user turned it off at this scope (`claude plugin disable`): setup never turns it back on.
         disabled: own(own(settings, "enabledPlugins"), CLAUDE_PLUGIN_ID) === false,
-        ref: typeof ref === "string" ? ref : null,
+        directory,
     };
 }
 /**
- * Setup's exact check for claude: our plugin, at the baked version, from the baked release tag,
- * effective here AND installed and enabled at the REQUESTED scope from that tag.
+ * Setup's exact check for claude: our plugin, at the baked version, from our per-user directory,
+ * effective here AND installed and enabled at the REQUESTED scope from that directory, with no layer
+ * setup may write (user, local) still declaring the marketplace another way, and our directory
+ * judged sound by doctor's own reader. `rewrote`: setup has just rewritten the directory because its
+ * content differed from the packaged bytes, so what Claude Code installed from it is not what this
+ * build ships — never exact.
  */
-export function claudePluginExact(ctx, assets, scope) {
+export function claudePluginExact(ctx, assets, scope, rewrote = false) {
     const read = readClaudePluginScopes(ctx);
     const summary = read.summary;
     const atScope = claudeScopeInstall(ctx, scope);
-    const effective = summary.installed && summary.version === assets.mcpVersion && summary.sourceRef === assets.releaseTag && !read.failures.includes("plugin_stanza_mismatch");
+    const staleLayers = [...new Set(claudeMarketplaceDeclarations(ctx)
+            .filter((declaration) => !declaration.directory && (declaration.layer === "user" || declaration.layer === "local"))
+            .map((declaration) => declaration.layer))];
+    // Round 3 (C2): every row of ours setup can reach (user, and local for this cwd) must be at the baked
+    // version. A local row installed from the github ref is the FIRST applicable row in its project, so
+    // leaving it old leaves that project on the old plugin; setup updates it, and is not exact before.
+    const rowLayers = SETUP_SCOPES.filter((layer) => claudeScopeInstall(ctx, layer).row);
+    const staleRows = rowLayers.filter((layer) => claudeScopeInstall(ctx, layer).version !== assets.mcpVersion);
+    // The WINNING declaration must be our directory too: the disabled path returns on `pinned` alone.
+    const sourceSound = summary.sourceKind === "directory" && read.sourceUndetermined.length === 0
+        && !read.failures.some((failure) => failure.startsWith("plugin_source_"));
+    const effective = summary.installed && summary.version === assets.mcpVersion && !read.failures.includes("plugin_stanza_mismatch");
+    const pinned = atScope.row && atScope.version === assets.mcpVersion && atScope.directory && !rewrote && sourceSound && staleLayers.length === 0 && staleRows.length === 0;
     return {
-        exact: effective && atScope.row && atScope.version === assets.mcpVersion && atScope.enabled && atScope.ref === assets.releaseTag,
+        exact: effective && pinned && atScope.enabled,
         installedAtScope: atScope.row,
         enabledAtScope: atScope.row && atScope.enabled,
         disabledAtScope: atScope.row && atScope.disabled,
-        pinnedAtScope: atScope.row && atScope.version === assets.mcpVersion && atScope.ref === assets.releaseTag,
+        pinnedAtScope: pinned,
         foreign: read.failures.includes("foreign_board_plugin"),
         unparseable: read.unparseable.length > 0 || read.untrusted,
+        staleLayers,
+        rowLayers,
+        staleRows,
     };
 }
+const pinOf = (stats) => ({ dev: stats.dev, ino: stats.ino, uid: stats.uid });
+/** The path now, lstat'd: still the same real directory (same dev/ino/owner), never a symlink. */
+function samePin(path, pin) {
+    let stats;
+    try {
+        stats = lstatSync(path);
+    }
+    catch {
+        return pin === null;
+    }
+    return pin !== null && stats.isDirectory() && !stats.isSymbolicLink() && stats.dev === pin.dev && stats.ino === pin.ino && stats.uid === pin.uid;
+}
+/** The resolver's visited chain up to and including the parent: every directory entered, by identity. */
+const chainKey = (visited) => visited.filter((entry) => entry.role !== "dir").map((entry) => `${entry.path}\u0000${entry.dev}:${entry.ino}`).join("\n");
+const lstatOrNull = (path) => {
+    try {
+        return lstatSync(path);
+    }
+    catch {
+        return null;
+    }
+};
+const SIBLING = /^\.claude-marketplace\.(tmp|old)-/;
+/**
+ * Make `claudeMarketplaceDir` hold exactly the packaged marketplace. It must be permanent (a
+ * directory-sourced plugin whose directory is gone fails to load: measured), so it is never the
+ * npx cache.
+ *
+ * Trust (B3): `checkTrustChain`, shared with doctor, over every existing path from `/` down. Our own
+ * `agent-board` or `claude-marketplace` directory that is group/world-writable is TIGHTENED to 0700
+ * rather than refused: setup owns both, nothing else is meant to write there, and a refusal would
+ * only ask the user to run the chmod setup can run; anything else untrusted is refused
+ * (`plugin_dir_untrusted`, naming the path). After `mkdir` the chain is judged again, and the parent
+ * and directory are pinned by dev/ino/owner; the pins are re-checked before the swap and before the
+ * old copy is removed, so a path swapped after the check is refused rather than written through or
+ * deleted through.
+ *
+ * Swap (S1): a sibling temp directory is built and renamed in; the old one is renamed aside first
+ * (Node cannot exchange two directories atomically, so the path is briefly absent). If the second
+ * rename fails, the old copy is renamed back. A failed removal of the old copy is a warning, not a
+ * failure. Stale temp/old siblings of ours from a crashed run are removed first.
+ */
+function materializeMarketplace(ctx, scopeCtx) {
+    let packagedDir;
+    try {
+        packagedDir = ctx.marketplaceSource ?? resolveMarketplaceDir();
+    }
+    catch {
+        packagedDir = "";
+    }
+    const packaged = packagedDir === "" ? null : readTree(packagedDir);
+    // The key is `/`-separated on every OS (S5): `readTree` never uses the platform separator.
+    if (packaged === null || packaged.kind !== "ok" || !packaged.files.has(MARKETPLACE_MANIFEST_KEY)) {
+        return failed("marketplace_unpackaged", "this cli build carries no claude-marketplace/ (the build did not copy it): reinstall @consiliency/agent-board-cli, then re-run setup");
+    }
+    const dir = claudeMarketplaceDir(ctx.env, scopeCtx.home);
+    const parent = dirname(dir);
+    const uid = scopeCtx.fs.getuid();
+    // win32 has no uid (getuid() is -1) or POSIX mode: `checkTrustChain` then keeps only the symlink rule (S5).
+    const platform = process.platform;
+    const notes = [];
+    const untrusted = (detail) => failed("plugin_dir_untrusted", `${detail}; setup installs the Claude Code plugin from ${dir} and never follows or takes over what it did not make: fix or remove it (or set XDG_DATA_HOME to a directory you own), then re-run setup`);
+    let pinnedChain = "";
+    const trust = () => resolveTrustChain(dir, { ...ctx.marketplaceTrust, uid, platform });
+    const judge = () => {
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const { problem, visited } = trust();
+            if (problem === null) {
+                pinnedChain = chainKey(visited);
+                return null;
+            }
+            if (!problem.tightenable)
+                return untrusted(describeTrustProblem(problem));
+            chmodSync(problem.path, 0o700);
+            if (!notes.includes("marketplace_dir_tightened"))
+                notes.push("marketplace_dir_tightened");
+        }
+        return untrusted(`${parent} could not be made private`);
+    };
+    const first = judge();
+    if (first)
+        return first;
+    // Leftovers of a crashed run: ours (owner, a real directory) only.
+    if (platform !== "win32" && lstatOrNull(parent)?.isDirectory()) {
+        for (const name of readdirSync(parent)) {
+            const stats = SIBLING.test(name) ? lstatOrNull(join(parent, name)) : null;
+            if (!(stats && stats.isDirectory() && !stats.isSymbolicLink() && stats.uid === uid))
+                continue;
+            try {
+                rmSync(join(parent, name), { recursive: true, force: true });
+            }
+            catch {
+                // `force` suppresses only ENOENT. A copy holding another uid's entry (the tree round 5 rebuilds)
+                // or a 0500 subdirectory cannot be removed: a note, as when the swap's own cleanup fails, never a throw.
+                if (!notes.includes("marketplace_old_copy_left"))
+                    notes.push("marketplace_old_copy_left");
+            }
+        }
+    }
+    // Round 5: an entry inside that another uid owns or can write is NOT equal, however its bytes read:
+    // it is rewritten below through the same swap, with safe modes.
+    const current = readTree(dir, { uid, platform, lstat: ctx.marketplaceTrust?.lstat });
+    if (current.kind === "ok" && sameTree(current.files, packaged.files))
+        return { dir, rewrote: false, notes };
+    // Never a silent downgrade of a TRUSTED directory a newer cli wrote (round 4). An untrusted tree never
+    // reaches here as `ok` (round 5): its version is untrusted too, so it is rebuilt like any other.
+    const skew = current.kind === "ok" ? compareVersions(pluginVersionIn(current.files), pluginVersionIn(packaged.files)) : null;
+    if (skew !== null && skew > 0) {
+        return failed("plugin_dir_newer", `${dir} holds a newer agent-board plugin (${pluginVersionIn(current.kind === "ok" ? current.files : new Map()) ?? "?"}) than this cli ships (${pluginVersionIn(packaged.files) ?? "?"}); setup does not downgrade it: run the newer cli's setup (npx -y @consiliency/agent-board-cli@latest setup --harness claude)`);
+    }
+    const suffix = `${process.pid}-${randomBytes(4).toString("hex")}`;
+    const temp = join(parent, `.claude-marketplace.tmp-${suffix}`);
+    const old = join(parent, `.claude-marketplace.old-${suffix}`);
+    const paths = { parent, dir, temp, old };
+    try {
+        // Every directory setup creates is mkdir'd 0700; a umask can only narrow that, never widen it.
+        mkdirSync(parent, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        return failed("plugin_dir_unwritable", `setup could not create ${parent}: check that its parent is writable by you, then re-run setup`);
+    }
+    // Re-judge now that the parent exists, then pin it and the directory for the rest of the run.
+    const second = judge();
+    if (second)
+        return second;
+    // The pins: every directory the resolver entered up to the parent (round 4), and the directory.
+    const chainPin = pinnedChain;
+    const sameChain = () => {
+        const again = trust();
+        return again.problem === null && chainKey(again.visited) === chainPin;
+    };
+    const dirStats = lstatOrNull(dir);
+    const dirPin = dirStats ? pinOf(dirStats) : null;
+    const changed = () => untrusted(`${parent} or ${dir} changed while setup was writing it`);
+    try {
+        mkdirSync(temp, { mode: 0o700 });
+        for (const [path, file] of packaged.files) {
+            const target = join(temp, ...path.split("/"));
+            mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+            writeFileSync(target, file.bytes, { flag: "wx", mode: 0o600 });
+            // Private modes (round 5): 0700 or 0600 — the exec bit, which equality compares, is kept.
+            chmodSync(target, file.executable ? 0o700 : 0o600);
+        }
+    }
+    catch {
+        if (sameChain())
+            rmSync(temp, { recursive: true, force: true });
+        return failed("plugin_dir_unwritable", `setup could not write the Claude Code marketplace into ${parent}: check that it is writable by you, then re-run setup`);
+    }
+    ctx.marketplaceStep?.("prepared", paths);
+    if (!sameChain() || !samePin(dir, dirPin)) {
+        if (sameChain())
+            rmSync(temp, { recursive: true, force: true });
+        return changed();
+    }
+    let moved = false;
+    try {
+        if (dirPin !== null) {
+            renameSync(dir, old);
+            moved = true;
+            ctx.marketplaceStep?.("moved_old", paths);
+        }
+        renameSync(temp, dir);
+    }
+    catch {
+        // Put the old copy back (the plugin keeps loading), and drop the temp tree.
+        if (moved && sameChain() && lstatOrNull(dir) === null && samePin(old, dirPin)) {
+            try {
+                renameSync(old, dir);
+            }
+            catch {
+                /* reported below: the path may now be absent */
+            }
+        }
+        if (sameChain())
+            rmSync(temp, { recursive: true, force: true });
+        return failed("plugin_dir_unwritable", `setup could not swap the new Claude Code marketplace into ${dir}${lstatOrNull(dir) === null ? " and the directory is now absent" : "; the previous copy is still in place"}: check that ${parent} is writable by you, then re-run setup`);
+    }
+    ctx.marketplaceStep?.("swapped", paths);
+    if (moved) {
+        // Only what setup itself renamed aside, and only through the parent it pinned.
+        if (!sameChain() || !samePin(old, dirPin)) {
+            notes.push("marketplace_old_copy_left");
+        }
+        else {
+            try {
+                rmSync(old, { recursive: true });
+            }
+            catch {
+                notes.push("marketplace_old_copy_left");
+            }
+        }
+    }
+    return { dir, rewrote: true, notes };
+}
 async function installClaude(ctx, scopeCtx) {
     const cli = which("claude", ctx.env);
     if (cli === null)
@@ -597,23 +818,59 @@ async function installClaude(ctx, scopeCtx) {
         return failed("existing_board_plugin", "another Claude Code plugin already registers a board server or wake hook: disable it (claude plugin disable <id>), then re-run setup");
     if (before.unparseable)
         return failed("config_unparseable", "Claude Code's plugin records do not parse or name a path outside its cache: run `claude plugin list` and repair them, then re-run setup");
-    if (before.exact)
-        return { status: "already", reason: "exact" };
+    // B1: every layer that declares our marketplace. Setup re-declares it (our own entry only) in each
+    // layer it may write — the requested scope, and user or local if they still declare it another
+    // way (a github-ref install, the documented `--scope local` one included). A layer it must not
+    // write (a checked-in project `.claude/settings.json`, managed settings) that would still WIN is
+    // refused, naming the file and the command.
+    const dir = claudeMarketplaceDir(ctx.env, scopeCtx.home);
+    const rank = { user: 0, project: 1, local: 2, managed: 3 };
+    const declarations = claudeMarketplaceDeclarations(scopeCtx);
+    const addScopes = [ctx.scope, ...before.staleLayers.filter((layer) => layer !== ctx.scope)];
+    const winner = [...declarations.map((declaration) => ({ ...declaration, directory: declaration.directory || addScopes.includes(declaration.layer) })),
+        { layer: ctx.scope, path: cliWriteTargets("claude", ctx.scope, scopeCtx)[0], directory: true }]
+        .sort((x, y) => rank[x.layer] - rank[y.layer]).at(-1);
+    if (winner && !winner.directory) {
+        return failed("marketplace_declared_elsewhere", winner.layer === "project"
+            ? `${winner.path} (checked in) declares the message-board marketplace from another source, and it outranks the ${ctx.scope} scope setup writes; setup does not edit a project's shared settings: run \`claude plugin marketplace add ${dir} --scope project\` (then commit that file), or remove the declaration, then re-run setup`
+            : `${winner.path} (managed settings) declares the message-board marketplace from another source, and it outranks every scope setup writes: ask your administrator to point it at ${dir} or remove it, then re-run setup`);
+    }
+    // The directory next: whether it had to be rewritten decides whether the install is exact.
+    const materialized = materializeMarketplace(ctx, scopeCtx);
+    if ("status" in materialized)
+        return materialized;
+    const { rewrote, notes } = materialized;
+    const withNotes = (result) => (notes.length === 0 ? result : {
+        ...result,
+        reason: `${result.reason},${notes.join(",")}`,
+        fix: [result.fix, notes.includes("marketplace_dir_tightened") ? `setup made ${dirname(dir)} or ${dir} private (0700): other users could write to it` : "",
+            notes.includes("marketplace_old_copy_left") ? `setup could not remove the previous copy beside ${dir} (.claude-marketplace.old-*): remove it by hand` : ""].filter(Boolean).join("; "),
+    });
+    const current = claudePluginExact(scopeCtx, ctx.assets, ctx.scope, rewrote);
+    if (current.exact)
+        return withNotes({ status: "already", reason: "exact" });
     // A plugin the user disabled at this scope stays disabled, as an MCP harness's off switch does:
     // pinned already → `already`; otherwise upgraded in place (`update` keeps the enable state).
     const offFix = "the board plugin is disabled at this scope (claude plugin disable), and setup keeps your choice: `claude plugin enable agent-board@message-board` to turn it on; until then doctor reports no registration";
-    if (before.disabledAtScope && before.pinnedAtScope)
-        return { status: "already", reason: "exact,disabled_by_user", fix: offFix };
-    // readlink BEFORE `claude plugin … --scope` writes the settings file.
-    const links = symlinkCheck(ctx, cliWriteTargets("claude", ctx.scope, scopeCtx));
+    if (current.disabledAtScope && current.pinnedAtScope)
+        return withNotes({ status: "already", reason: "exact,disabled_by_user", fix: offFix });
+    // readlink BEFORE `claude plugin … --scope` writes a settings file.
+    const links = symlinkCheck(ctx, addScopes.flatMap((scope) => cliWriteTargets("claude", scope, scopeCtx)));
     if (links.refusal)
         return links.refusal;
+    // Re-declaring under the same name with another source REPLACES it in both files and keeps the
+    // installed row (measured, #549): the migration from a github-ref install is this same sequence.
+    const steps = addScopes.map((scope) => ["plugin", "marketplace", "add", dir, "--scope", scope]);
     const scopeArgs = ["--scope", ctx.scope];
-    const steps = [["plugin", "marketplace", "add", `${CLAUDE_MARKETPLACE_REPO}@${ctx.assets.releaseTag}`, ...scopeArgs]];
-    // An update only over OUR row at this scope; a plugin effective here from another scope is not it.
-    if (before.installedAtScope) {
+    // Update OUR rows only: at the requested scope, and (C2) at user or local wherever setup just
+    // re-declared the marketplace, rewrote the directory, or the row is not at the baked version — so a
+    // migration converges in one run. `update` keeps each scope's enable state (a user's disable too).
+    const updateScopes = before.rowLayers.filter((layer) => layer === ctx.scope || rewrote || addScopes.includes(layer) || before.staleRows.includes(layer));
+    if (updateScopes.length > 0)
         steps.push(["plugin", "marketplace", "update", CLAUDE_PLUGIN_MARKETPLACE]);
-        steps.push(["plugin", "update", CLAUDE_PLUGIN_ID, ...scopeArgs]);
+    for (const layer of updateScopes)
+        steps.push(["plugin", "update", CLAUDE_PLUGIN_ID, "--scope", layer]);
+    if (before.installedAtScope) {
         // Our row with NO enable at this scope (not a disable: that is the user's choice, kept above).
         if (!before.enabledAtScope && !before.disabledAtScope)
             steps.push(["plugin", "enable", CLAUDE_PLUGIN_ID, ...scopeArgs]);
@@ -627,21 +884,27 @@ async function installClaude(ctx, scopeCtx) {
             return cliFailure;
     }
     const after = claudePluginExact(scopeCtx, ctx.assets, ctx.scope);
+    // Name the file that still wins with another source, if one does: the fix is there.
+    const winning = claudeMarketplaceDeclarations(scopeCtx).at(-1);
+    const where = winning && !winning.directory ? `; ${winning.path} still declares the message-board marketplace from another source` : "";
     if (before.disabledAtScope) {
         if (!after.pinnedAtScope || !after.disabledAtScope) {
-            return failed("harness_install_unverified", `after the claude plugin update, the disabled plugin at this scope is not ${ctx.assets.mcpVersion} from ${ctx.assets.releaseTag} (or was re-enabled): run \`claude plugin list\``);
+            return failed("harness_install_unverified", `after the claude plugin update, the disabled plugin at this scope is not ${ctx.assets.mcpVersion} from ${dir} (or was re-enabled)${where}: run \`claude plugin list\``);
         }
-        return { status: "done", reason: `upgraded${links.followed ? ",symlink_followed" : ""},disabled_by_user`, fix: offFix };
+        return withNotes({ status: "done", reason: `upgraded${links.followed ? ",symlink_followed" : ""},disabled_by_user`, fix: offFix });
     }
     if (!after.exact) {
-        return failed("harness_install_unverified", `after the claude plugin install, the installed plugin is not ${ctx.assets.mcpVersion} from ${ctx.assets.releaseTag}: run \`claude plugin list\` and doctor --harness claude`);
+        return failed("harness_install_unverified", `after the claude plugin install, the installed plugin is not ${ctx.assets.mcpVersion} from ${dir}${where}: run \`claude plugin list\` and doctor --harness claude`);
     }
     const reason = before.installedAtScope ? "upgraded" : "installed";
-    return { status: "done", reason: links.followed ? `${reason},symlink_followed` : reason };
+    return withNotes({ status: "done", reason: links.followed ? `${reason},symlink_followed` : reason });
 }
 /** The `harness` step for one harness and scope. Never throws for a host condition. */
 export async function installHarness(ctx) {
-    const scopeCtx = scopeContext(ctx.env, ctx.cwd, ctx.fs ?? nodeRegistrationFs, ctx.claudeManagedDir ?? "/etc/claude-code");
+    const scopeCtx = scopeContext(ctx.env, ctx.cwd, ctx.fs ?? nodeRegistrationFs, ctx.claudeManagedDir ?? "/etc/claude-code", {
+        ...(ctx.marketplaceSource ? { claudeMarketplacePackaged: ctx.marketplaceSource } : {}),
+        ...(ctx.marketplaceTrust ? { claudeMarketplaceTrust: ctx.marketplaceTrust } : {}),
+    });
     const refusal = scopeRefusal(ctx.harness, ctx.scope, ctx);
     if (refusal)
         return failed(refusal.reason, refusal.fix);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@consiliency/agent-board-cli",
-  "version": "1.25.0",
+  "version": "1.27.0",
   "repository": "https://github.com/Consiliency/message-board.git",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,6 +16,7 @@
   },
   "files": [
     "bin",
+    "claude-marketplace",
     "dist",
     "keyslot",
     "LICENSE",
@@ -32,7 +33,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@consiliency/agent-board-client": "1.40.0",
+    "@consiliency/agent-board-client": "1.41.0",
     "commander": "^14.0.1"
   },
   "license": "Apache-2.0",