@consiliency/agent-board-cli 1.25.0 → 1.27.0

package/dist/doctor_scopes.js

@@ -84,9 +84,14 @@
 //   tree         a github-sourced plugin runs from its row's `installPath` in the cache (measured:
 //                editing the cached `plugin.json` changed what ran, the marketplace clone's did
 //                not). A DIRECTORY-sourced plugin runs from the source directory, not the cache
-//                (editing the source without reinstalling changed what ran). Ours never has a
-//                directory source; for a FOREIGN directory plugin this is a floor: doctor reads
-//                the cache copy, which may not be what runs.
+//                (editing the source without reinstalling changed what ran). For a FOREIGN
+//                directory plugin this is a floor: doctor reads the cache copy, which may not be
+//                what runs. Ours has a directory source since message-board#549 — the per-user
+//                `claudeMarketplaceDir` that `setup` materialises from the cli package, byte-equal
+//                to what it installed — so the floor is the same, and a MISSING directory is
+//                `plugin_source_missing` (measured: `plugin list` then shows `failed to load`).
+//                A directory source is `{source:"directory", path}` in both files (measured,
+//                claude 2.1.283, 2026-09-27); its installed row has no `gitCommitSha`.
 //   auto-update  off globally when `DISABLE_UPDATES` or `DISABLE_AUTOUPDATER` is truthy
 //                (1/true/yes/on), `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` is non-empty, or
 //                `.claude.json` has `autoUpdates: false` (unless `installMethod` is native and
@@ -228,6 +233,8 @@
 import { spawnSync } from "node:child_process";
 import * as nodeFs from "node:fs";
 import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { resolveMarketplaceDir } from "./assets.js";
+import { MARKETPLACE_MANIFEST_KEY, checkTrustChain, claudeMarketplaceDir, compareVersions, isOurMarketplacePath, pluginVersionIn, readTree, sameTree, } from "./claude_marketplace.js";
 export const BOARD_MCP_MARKER = "agent-board-mcp";
 export const METADATA_ONLY_FLAG = "--metadata-only";
 export const OPENCODE_PLUGIN_PACKAGE = "@consiliency/agent-board-opencode";
@@ -244,6 +251,8 @@ export const CLAUDE_PLUGIN_MARKETPLACE = "message-board";
 /** Compared lower-cased, as Claude Code compares repos. */
 export const CLAUDE_PLUGIN_REPO = "consiliency/message-board";
 export const CLAUDE_PLUGIN_SERVER = "agent-board";
+/** message-board#549: THE per-user marketplace directory. Defined once, in `claude_marketplace.ts`. */
+export { claudeMarketplaceDir } from "./claude_marketplace.js";
 export const CLAUDE_PLUGIN_MCP_PACKAGE = "@consiliency/agent-board-mcp";
 /** The SL-0 outcome: `B` = the FileChanged hook carries `asyncRewake: true`. */
 export const CLAUDE_WAKE_SHAPE = "B";
@@ -1068,11 +1077,24 @@ function readJsonFile(fs, path) {
     return text === null ? null : parseJson(text);
 }
 const truthyEnv = (value) => value !== undefined && ["1", "true", "yes", "on"].includes(value.toLowerCase().trim());
-/** `source` names a github marketplace of this repository, with no alternate manifest path. */
-function isOurMarketplaceSource(source) {
-    const repo = own(source, "repo");
-    return isObject(source) && own(source, "source") === "github" && typeof repo === "string"
-        && repo.toLowerCase() === CLAUDE_PLUGIN_REPO && own(source, "path") === undefined;
+/**
+ * `source` is ours: a github marketplace of this repository with no alternate manifest path (fleet
+ * hosts installed from a release tag), OR a directory marketplace whose path resolves to THE
+ * per-user directory setup materialises (`claudeMarketplaceDir`, message-board#549). Any other
+ * directory is not ours, so a plugin from it is judged as foreign.
+ */
+function marketplaceSourceKind(source, ctx) {
+    if (!isObject(source))
+        return null;
+    const kind = own(source, "source");
+    if (kind === "github") {
+        const repo = own(source, "repo");
+        return typeof repo === "string" && repo.toLowerCase() === CLAUDE_PLUGIN_REPO && own(source, "path") === undefined ? "github" : null;
+    }
+    if (kind === "directory") {
+        return isOurMarketplacePath(own(source, "path"), ctx.env, ctx.home) ? "directory" : null;
+    }
+    return null;
 }
 /**
  * Reads one plugin tree, confined to the cache. `installPath` must resolve (realpath) strictly
@@ -1080,10 +1102,11 @@ function isOurMarketplaceSource(source) {
  * `UntrustedPluginPathError` and nothing beyond it is read: the only call made on an untrusted
  * path is the `realpath` that judged it.
  */
-function readPluginTree(ctx, installPath, serverPrefix) {
+function readPluginTree(ctx, installPath, serverPrefix, confineTo) {
     if (!isAbsolute(installPath))
         throw new UntrustedPluginPathError();
-    const cache = ctx.fs.realpath(join(claudePluginsDir(ctx), "cache"));
+    // Confined to the cache, or (round 3, C2) to our validated source directory.
+    const cache = ctx.fs.realpath(confineTo ?? join(claudePluginsDir(ctx), "cache"));
     const root = cache === null ? null : ctx.fs.realpath(installPath);
     if (cache === null || root === null || !within(root, cache))
         throw new UntrustedPluginPathError();
@@ -1207,15 +1230,18 @@ function claudeAutoUpdate(ctx, declarations, known) {
  * IF-0-CCPLUGIN-3: every plugin enabled for `ctx.cwd`, followed from `enabledPlugins` to its
  * installed row and read from the cache. Ours is the plugin id `agent-board@message-board` whose
  * marketplace is declared, EVERYWHERE it is declared, as the github repository
- * Consiliency/message-board; anything else contributing a board server or a wake hook is foreign.
+ * Consiliency/message-board or as the per-user directory `claudeMarketplaceDir` (#549); anything
+ * else contributing a board server or a wake hook is foreign.
  */
 export function readClaudePluginScopes(ctx) {
     const unparseable = new Set();
     const failures = new Set();
     const files = [];
     let untrusted = false;
+    const sourceUndetermined = [];
     const summary = {
-        installed: false, serverActive: false, version: null, pinnedMcpVersion: null, sourceRef: null, autoUpdate: { effective: false, source: "default" },
+        installed: false, serverActive: false, version: null, pinnedMcpVersion: null, sourceRef: null, sourceKind: null, sourcePath: null, versionFrom: null,
+        autoUpdate: { effective: false, source: "default" },
     };
     const tolerant = (read, fallback) => {
         try {
@@ -1271,12 +1297,17 @@ export function readClaudePluginScopes(ctx) {
     const ourDeclarations = declarationsOf(CLAUDE_PLUGIN_MARKETPLACE);
     const ourKnown = own(known, CLAUDE_PLUGIN_MARKETPLACE);
     const everyDeclaration = [...ourDeclarations, ...(ourKnown === undefined ? [] : [ourKnown])];
+    // Every declaration must be ours, but not all of one kind: a host migrated from the github ref to
+    // the directory can still carry the github form in a project's settings file.
     const marketplaceIsOurs = everyDeclaration.length > 0
-        && everyDeclaration.every((declaration) => isOurMarketplaceSource(own(declaration, "source")));
+        && everyDeclaration.every((declaration) => marketplaceSourceKind(own(declaration, "source"), ctx) !== null);
     if (marketplaceIsOurs) {
-        // The winning declaration's ref: the highest settings scope, else known_marketplaces.json.
-        const ref = own(own(everyDeclaration[ourDeclarations.length > 0 ? ourDeclarations.length - 1 : 0], "source"), "ref");
-        summary.sourceRef = typeof ref === "string" ? ref : null;
+        // The winning declaration: the highest settings scope, else known_marketplaces.json.
+        const winning = own(everyDeclaration[ourDeclarations.length > 0 ? ourDeclarations.length - 1 : 0], "source");
+        summary.sourceKind = marketplaceSourceKind(winning, ctx);
+        const ref = own(winning, "ref");
+        summary.sourceRef = summary.sourceKind === "github" && typeof ref === "string" ? ref : null;
+        summary.sourcePath = summary.sourceKind === "directory" ? claudeMarketplaceDir(ctx.env, ctx.home) : null;
     }
     summary.autoUpdate = tolerant(() => claudeAutoUpdate(ctx, ourDeclarations, known), { effective: false, source: "undetermined" });
     for (const [id, on] of enabled) {
@@ -1303,9 +1334,23 @@ export function readClaudePluginScopes(ctx) {
             continue;
         }
         const ours = id === CLAUDE_PLUGIN_ID && marketplaceIsOurs;
+        // Round 3 (C2): a directory-sourced plugin RUNS from its source directory, so once that directory
+        // is judged sound (trusted, byte-equal to this cli's packaged copy), the version, pin, stanza and
+        // hooks are read from IT, not from the cache row (which a migration can leave at an old version).
+        // A github source, or a source that is not sound, is read from the cache as before.
+        let sourceVerdict;
+        if (ours && summary.sourceKind === "directory" && summary.sourcePath !== null) {
+            sourceVerdict = judgeOurSourceDirectory(ctx, summary.sourcePath);
+            if (sourceVerdict === "plugin_source_unverifiable" || sourceVerdict === "plugin_source_newer")
+                sourceUndetermined.push(sourceVerdict);
+            else if (sourceVerdict !== null)
+                failures.add(sourceVerdict);
+        }
+        const fromSource = ours && sourceVerdict === null && summary.sourcePath !== null;
+        const treePath = fromSource ? join(summary.sourcePath, "plugins", "agent-board") : own(row, "installPath");
         let tree;
         try {
-            tree = readPluginTree(ctx, own(row, "installPath"), `plugin:${name}`);
+            tree = readPluginTree(ctx, treePath, `plugin:${name}`, fromSource ? summary.sourcePath : undefined);
         }
         catch (error) {
             if (error instanceof UntrustedPluginPathError) {
@@ -1318,10 +1363,11 @@ export function readClaudePluginScopes(ctx) {
             continue;
         }
         const { contribution, manifest } = tree;
-        files.push({ row: ours ? CLAUDE_PLUGIN_ROW : CLAUDE_FOREIGN_PLUGIN_ROW, path: own(row, "installPath"), contribution, pluginId: id });
+        files.push({ row: ours ? CLAUDE_PLUGIN_ROW : CLAUDE_FOREIGN_PLUGIN_ROW, path: treePath, contribution, pluginId: id });
         if (ours) {
             const version = own(manifest, "version");
             summary.installed = true;
+            summary.versionFrom = fromSource ? "source" : "cache";
             summary.version = typeof version === "string" ? version : null;
             const pinArg = contribution.mcp[0]?.args.find((arg) => arg.startsWith(`${CLAUDE_PLUGIN_MCP_PACKAGE}@`));
             summary.pinnedMcpVersion = pinArg === undefined ? null : pinArg.slice(CLAUDE_PLUGIN_MCP_PACKAGE.length + 1);
@@ -1335,7 +1381,68 @@ export function readClaudePluginScopes(ctx) {
                 failures.add("foreign_board_plugin");
         }
     }
-    return { files, unparseable: [...unparseable], untrusted, failures: [...failures], summary, hookPolicy };
+    return { files, unparseable: [...unparseable], untrusted, sourceUndetermined, failures: [...failures], summary, hookPolicy };
+}
+/**
+ * Our directory source, judged as what RUNS: a directory-sourced plugin runs from its source
+ * directory, not the cache copy doctor reads above (CCPLUGIN recon; the header's `tree`). So the
+ * directory itself must be trusted (`checkTrustChain`, shared with setup) and byte-equal to this cli's
+ * packaged marketplace (`readTree`/`sameTree`, shared with setup). Gone → `plugin_source_missing`
+ * (Claude Code then fails to load it, measured). Doctor never tightens a mode: that is setup's.
+ */
+function judgeOurSourceDirectory(ctx, dir) {
+    if (!ctx.fs.exists(dir))
+        return "plugin_source_missing";
+    if (checkTrustChain(dir, { ...ctx.claudeMarketplaceTrust, uid: ctx.fs.getuid(), platform: ctx.platform }) !== null)
+        return "plugin_source_untrusted";
+    let packagedDir;
+    try {
+        packagedDir = ctx.claudeMarketplacePackaged ?? resolveMarketplaceDir();
+    }
+    catch {
+        return "plugin_source_unverifiable";
+    }
+    const packaged = readTree(packagedDir);
+    if (packaged.kind !== "ok" || !packaged.files.has(MARKETPLACE_MANIFEST_KEY))
+        return "plugin_source_unverifiable";
+    // Round 5: every entry inside the directory is judged too (owner, no group/world write): it is
+    // what Claude Code executes. The offending path is not echoed: reasons are authored codes.
+    const current = readTree(dir, { uid: ctx.fs.getuid(), platform: ctx.platform, lstat: ctx.claudeMarketplaceTrust?.lstat });
+    if (current.kind === "missing")
+        return "plugin_source_missing";
+    if (current.kind === "untrusted")
+        return "plugin_source_untrusted";
+    if (current.kind === "ok" && sameTree(current.files, packaged.files))
+        return null;
+    // Round 2, version skew: a directory another cli version wrote. OLDER (or the same version with
+    // other bytes, or unreadable) is stale: re-run setup with this cli. NEWER means THIS doctor is
+    // the old one; it cannot judge a plugin it does not ship, so that is undetermined, not a failure.
+    const skew = current.kind === "ok" ? compareVersions(pluginVersionIn(current.files), pluginVersionIn(packaged.files)) : null;
+    return skew !== null && skew > 0 ? "plugin_source_newer" : "plugin_source_stale";
+}
+/**
+ * Every settings layer that declares OUR marketplace name, in ascending precedence (the last one wins),
+ * with whether its source is exactly our per-user directory. Setup uses it to migrate each layer it
+ * may write and to name the one it may not.
+ */
+export function claudeMarketplaceDeclarations(ctx) {
+    const managed = new Set(managedSettingsPaths(ctx));
+    const layerOf = (path, index) => managed.has(path) ? "managed" : index === 0 ? "user" : index === 1 ? "project" : "local";
+    const out = [];
+    claudeSettingsLayers(ctx).forEach((path, index) => {
+        let document;
+        try {
+            document = readJsonFile(ctx.fs, path);
+        }
+        catch {
+            return;
+        }
+        const declaration = own(own(document, "extraKnownMarketplaces"), CLAUDE_PLUGIN_MARKETPLACE);
+        if (declaration === undefined)
+            return;
+        out.push({ layer: layerOf(path, index), path, directory: marketplaceSourceKind(own(declaration, "source"), ctx) === "directory" });
+    });
+    return out;
 }
 // ---------------------------------------------------------------------------------------------
 // Judgement
@@ -1516,7 +1623,7 @@ export function judgeRegistration(harness, ctx) {
     // An absence is only evidence when every file was read: the missing entry may be in the file
     // that did not parse, under the plugin path doctor refused to follow, or a handler doctor
     // cannot judge. A duplicate or the flag, seen in files that DID parse, stands.
-    const complete = unparseable.length === 0 && !plugins?.untrusted && !unjudgeable && !policyUnjudgeable && policyCheckFailed.length === 0;
+    const complete = unparseable.length === 0 && !plugins?.untrusted && (plugins?.sourceUndetermined.length ?? 0) === 0 && !unjudgeable && !policyUnjudgeable && policyCheckFailed.length === 0;
     const standing = complete
         ? failures
         : failures.filter((failure) => failure !== "no_registration" && !failure.startsWith("missing_hook:"));
@@ -1525,6 +1632,7 @@ export function judgeRegistration(harness, ctx) {
     const unknowns = [
         ...(unparseable.length > 0 ? [`unparseable:${[...new Set(unparseable)].join("+")}`] : []),
         ...(plugins?.untrusted ? ["plugin_path_untrusted"] : []),
+        ...(plugins?.sourceUndetermined ?? []),
         ...(unjudgeable ? ["unjudgeable_hook"] : []),
         ...(policyUnjudgeable ? ["hook_policy_unjudgeable"] : []),
         ...policyCheckFailed,

package/dist/setup_storage.d.ts

@@ -110,6 +110,18 @@ export declare function repairKeyDir(env: NodeJS.ProcessEnv, uid: number): {
     problems: string[];
     root: string | null;
 };
+/**
+ * Why the macOS login keychain did not round-trip, from the probe's classification (#554). Only a
+ * LOCKED keychain is told to unlock: before #554 every cause got that fix, including the
+ * write-permission failure an SSH session produced by writing to System.keychain, where unlocking
+ * the login keychain changed nothing.
+ */
+/** A path as one POSIX shell word: bare when it is plainly safe, else single-quoted ('\'' for a quote). */
+export declare function shellWord(value: string): string;
+export declare function macosKeychainRefusal(probe: OsKeychainProbeResult | null): {
+    reason: string;
+    fix: string;
+};
 /**
  * IF-0-SETUP-3: the key storage, measured, in the IF-0-KEYSEAL-6 order. Never throws for a host
  * condition; a refusal carries the fix.

package/dist/setup_storage.js

@@ -23,7 +23,7 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { chmodSync, closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join } from "node:path";
-import { probeOsKeychainRoundTrip } from "@consiliency/agent-board-client";
+import { OS_KEYCHAIN_SERVICE, probeOsKeychainRoundTrip } from "@consiliency/agent-board-client";
 import { resolveKeyslotDir } from "./assets.js";
 export const SLOT_RE = /^[a-z][a-z0-9-]{0,31}$/;
 const REFERENCE_LINE = /^agent_socket:\/\S+#[A-Za-z0-9_-]{43}$/;
@@ -347,6 +347,48 @@ function externalAgent(agentSocket, env, uid, machineIdFile, repairs) {
         return { storage: "external", reason: "external_declared", keyReference: reference, repairs };
     return refused(problems.includes("missing") ? "external_undeclared" : "external_declaration_mismatch", EXTERNAL_FIX(declaration), repairs);
 }
+const OR_EXTERNAL = "or pass --agent-socket <ref> with an external-agent declaration";
+/**
+ * Why the macOS login keychain did not round-trip, from the probe's classification (#554). Only a
+ * LOCKED keychain is told to unlock: before #554 every cause got that fix, including the
+ * write-permission failure an SSH session produced by writing to System.keychain, where unlocking
+ * the login keychain changed nothing.
+ */
+/** A path as one POSIX shell word: bare when it is plainly safe, else single-quoted ('\'' for a quote). */
+export function shellWord(value) {
+    return /^[A-Za-z0-9_\/.,:@%+=-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+export function macosKeychainRefusal(probe) {
+    // Printed for pasting into a shell: a real path is quoted; the fallback keeps `~` unquoted so it expands.
+    const kc = probe?.keychain !== undefined ? shellWord(probe.keychain) : "~/Library/Keychains/login.keychain-db";
+    switch (probe?.failure) {
+        case "keychain_locked":
+            return { reason: "macos_keychain_locked", fix: `the login keychain is locked, and this session cannot show an unlock prompt: run \`security unlock-keychain ${kc}\` and re-run setup` };
+        case "write_denied":
+            return { reason: "macos_keychain_write_denied", fix: `the keychain refused the write (errSecWrPerm) to ${kc}: check that it is your login keychain and that you own it (ls -l ${kc}), ${OR_EXTERNAL}` };
+        case "login_keychain_absent":
+            return { reason: "macos_login_keychain_absent", fix: `there is no login keychain in ~/Library/Keychains (login.keychain-db or login.keychain): log in once at this Mac's console, which creates it, ${OR_EXTERNAL}` };
+        case "item_outside_login_keychain": {
+            // Setup only ever sees its PROBE: the item found outside the login keychain is the probe's own
+            // throwaway, not this harness's key (a harness key held elsewhere surfaces at enrollment, and in
+            // doctor as key_outside_login_keychain). So say that, and offer only the throwaway's cleanup.
+            const holder = probe?.heldBy !== undefined ? shellWord(probe.heldBy) : null;
+            const cleanup = holder !== null && probe?.handle !== undefined
+                ? `; remove the test item with \`security delete-generic-password -s ${OS_KEYCHAIN_SERVICE} -a ${probe.handle} ${holder}\``
+                : "";
+            return { reason: "macos_keychain_item_elsewhere", fix: `setup's throwaway test item was found outside the login keychain, in ${holder ?? "another keychain on your search list"}, after it was deleted from the login keychain, so this account's keychain search list or default keychain is unusual: check \`security list-keychains -d user\` and \`security default-keychain -d user\`${cleanup}, then re-run setup, ${OR_EXTERNAL}` };
+        }
+        case "item_search_undetermined":
+            return { reason: "macos_keychain_search_undetermined", fix: "a keychain on your search list could not be searched (it may be locked): unlock it or remove it from the search list (security list-keychains -d user), then re-run setup" };
+        case "login_keychain_untrusted":
+        case "login_keychain_path_unsafe":
+            return { reason: "macos_login_keychain_unusable", fix: `${kc} is not usable: it must be a regular file you own (not a symlink) at a path with no whitespace, quotes or backslashes; fix it, ${OR_EXTERNAL}` };
+        default: {
+            const detail = probe ? `${probe.outcome}${probe.failure ? `, ${probe.failure}` : ""}` : "the probe did not answer";
+            return { reason: "macos_keychain_unavailable", fix: `the login keychain did not complete a round trip (${detail}): run setup from a logged-in session, ${OR_EXTERNAL}` };
+        }
+    }
+}
 /**
  * IF-0-SETUP-3: the key storage, measured, in the IF-0-KEYSEAL-6 order. Never throws for a host
  * condition; a refusal carries the fix.
@@ -378,7 +420,7 @@ export async function selectKeyStorage(ctx) {
     let gate = null;
     if (platform !== "linux") {
         gate = platform === "darwin"
-            ? { reason: "macos_keychain_unavailable", fix: "the login keychain did not complete a round trip: unlock it (security unlock-keychain) in a logged-in session and re-run setup" }
+            ? macosKeychainRefusal(keychain)
             : { reason: "platform_unsupported", fix: "setup's key storage supports Linux and macOS; on Windows run setup inside WSL, or pass --agent-socket <ref> with an external-agent declaration" };
     }
     else {

package/dist/setup_writers.d.ts

@@ -1,13 +1,11 @@
 import { type IdentityHarness } from "@consiliency/agent-board-client";
-import type { BakedAssets } from "./assets.js";
+import { type BakedAssets } from "./assets.js";
 import { type ConfigEntry } from "./config_edit.js";
 import { type RegistrationFs, type ScopeContext } from "./doctor_scopes.js";
 export type SetupScope = "user" | "local";
 export declare const SETUP_SCOPES: readonly SetupScope[];
 /** The server name setup writes; the same name the claude plugin registers. */
 export declare const BOARD_SERVER_NAME = "agent-board";
-/** `Consiliency/message-board`: the marketplace source, pinned to the baked release tag. */
-export declare 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`).
@@ -103,6 +101,20 @@ export interface WriterContext {
     run?: ChildRunner;
     fs?: RegistrationFs;
     claudeManagedDir?: string;
+    /** The packaged Claude Code marketplace to materialise; default the cli package's own copy. */
+    marketplaceSource?: string;
+    /** Test injection for the shared trust chain (`/etc/group`, gid, user name, ownership). */
+    marketplaceTrust?: ScopeContext["claudeMarketplaceTrust"];
+    /**
+     * A TEST SEAM, never set by setup: called at each step of the directory swap with the paths in
+     * play, so a test can change the filesystem between setup's check and its use (#549 B3/S1).
+     */
+    marketplaceStep?: (step: "prepared" | "moved_old" | "swapped", paths: {
+        parent: string;
+        dir: string;
+        temp: string;
+        old: string;
+    }) => void;
 }
 export interface WriterResult {
     status: "done" | "already" | "failed";
@@ -112,10 +124,14 @@ export interface WriterResult {
 /** The MCP-writer target file for a harness and scope, as doctor's scope rows locate it. */
 export declare function mcpTarget(harness: IdentityHarness, scope: SetupScope, ctx: ScopeContext): string;
 /**
- * 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 declare function claudePluginExact(ctx: ScopeContext, assets: BakedAssets, scope: SetupScope): {
+export declare function claudePluginExact(ctx: ScopeContext, assets: BakedAssets, scope: SetupScope, rewrote?: boolean): {
     exact: boolean;
     installedAtScope: boolean;
     enabledAtScope: boolean;
@@ -123,6 +139,9 @@ export declare function claudePluginExact(ctx: ScopeContext, assets: BakedAssets
     pinnedAtScope: boolean;
     foreign: boolean;
     unparseable: boolean;
+    staleLayers: SetupScope[];
+    rowLayers: SetupScope[];
+    staleRows: SetupScope[];
 };
 /** The `harness` step for one harness and scope. Never throws for a host condition. */
 export declare function installHarness(ctx: WriterContext): Promise<WriterResult>;