@consiliency/agent-board-cli 1.22.4 → 1.23.0

package/dist/doctor_scopes.js

@@ -0,0 +1,757 @@
+// CREDPATH IF-0-CREDPATH-4 — where each harness registers the board, and how doctor reads it.
+//
+// `HARNESS_CONFIG_SCOPES` is the frozen scope table. The plan froze a first version and required
+// SL-5 to re-check every row against the installed harness before building on it; the rows below
+// are the re-checked table, and each amendment says what was measured and how (dev0, 2026-09-25):
+//
+//   claude 2.1.282  The binary names `managed-mcp.json`, `managed-settings.d` and
+//                   `CLAUDE_CONFIG_DIR`; the plan's row had none of them. Added: the managed MCP
+//                   file, managed settings (`managedMcpServers` + `hooks`, file and `.d/*.json`
+//                   drop-ins), and `CLAUDE_CONFIG_DIR` relocating `.claude.json` and
+//                   `settings.json`. `~/.claude/settings.local.json` stays excluded: Claude Code
+//                   does not read it at user scope (the v11 incident).
+//   codex 0.157.0   `codex mcp list` in a temp `CODEX_HOME` MEASURED a project layer the plan
+//                   lacked: `<dir>/.codex/config.toml` for every dir from cwd up to the git root,
+//                   each loaded only when the nearest `[projects."<path>"]` entry at or above it
+//                   says `trust_level = "trusted"` (root trusted + sub untrusted → root only; no
+//                   entry → not loaded).
+//   grok 0.1.220    Row kept as its README documents (`~/.grok/README.md:1873,1889`). The
+//                   measurement is display-only: `grok mcp list` shows a user-scope server (the
+//                   positive control) but not a project one, so it is not evidence either way.
+//   agy 1.2.11      `agy mcp add` / `disable` in a temp HOME wrote
+//                   `{"mcpServers":{<name>:{command,args,disabled}}}`; an empty file is no entries.
+//                   `~/.gemini/config/projects/*.json` holds only `id`/`name`: no project scope.
+//   opencode 1.18.32 `opencode debug config` MEASURED a walk the plan lacked: `opencode.json[c]` and
+//                   `.opencode/opencode.json[c]` in every dir from cwd up to the git root are
+//                   merged, and plugins are deduplicated BY NAME, ignoring the version (user
+//                   `@0.1.1` + project bare → one entry). dev0's live entry is versioned.
+//   pi 0.87.1       Installed on dev0 (the brief said otherwise). Its `docs/packages.md`:
+//                   `PI_CODING_AGENT_DIR` relocates `~/.pi/agent`; entries are strings or
+//                   `{source}` objects; npm packages are identified by name WITHOUT the version,
+//                   and a project entry replaces the personal one. dev0's live entry is
+//                   `npm:@consiliency/agent-board-pi@0.3.1`.
+//
+// Consequence for "exactly once": a harness that deduplicates by name (claude, codex and grok by
+// server name across layers; opencode and pi by package name) cannot load one server twice under
+// one name, so duplicates are counted over DISTINCT names in the merged set. Two differently
+// named board servers are two processes, and that is what fails.
+//
+// PRECEDENCE (code-review round 1, Astra 3). A same-named entry at a higher layer overrides the
+// lower one, so doctor first builds each harness's EFFECTIVE server map and only then judges it:
+// a board entry that a higher layer disables or re-points is not a registration. Each row carries
+// `rank` (higher overrides) and, for a walked row, which end of the walk wins. Measured on dev0,
+// 2026-09-26, in temp homes with real `git init` repositories:
+//   codex 0.157.1   `codex mcp list --json`: a trusted project layer overrides the user layer
+//                   FIELD BY FIELD (`enabled = false` alone disables the user's server; `command`
+//                   alone keeps the user's `args`), and the layer nearest cwd wins.
+//   opencode 1.18.32 `opencode debug config`: field-by-field too; user < every `opencode.json[c]`
+//                   (nearest cwd wins) < every `.opencode/` file, where the FARTHEST (git root)
+//                   wins — measured, and the opposite of the `opencode.json` walk.
+//   claude 2.1.283  `claude mcp get` with a temp `CLAUDE_CONFIG_DIR`: local (`projects[cwd]`)
+//                   beats user (measured: it names the winning scope, not its fields). That the
+//                   whole entry is REPLACED, not overlaid, is inferred from claude keeping each
+//                   scope as its own map, not measured. project vs user could not be measured (an
+//                   unapproved `.mcp.json` is not shown); the documented order local > project >
+//                   user is used, and managed scopes are ranked above all.
+//   grok            unmeasured (display-only, above): ranked like codex, which it mirrors.
+//
+// Floors: plugin-contributed MCP servers and hooks (claude `enabledPlugins`, codex plugins) are
+// not read; claude's `.mcp.json` approval state and pi/grok project trust are not modelled (a
+// project entry is counted as loaded); opencode's `OPENCODE_CONFIG`/`OPENCODE_CONFIG_DIR` are not
+// read; `managed-mcp.json`'s exclusive-control mode is not modelled; `claude mcp get` still showed
+// a local entry carrying `disabled: true`, so doctor's reading of that field as "not launched" is
+// stricter than claude.
+//
+// Config text is DATA. Every object the readers build has a null prototype and every lookup is an
+// own-property lookup; a `__proto__`, `constructor` or `prototype` key makes the file unparseable
+// (round 1, Astra 1: `[__proto__.mcp_servers.x]` used to write onto `Object.prototype`).
+import * as nodeFs from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+export const BOARD_MCP_MARKER = "agent-board-mcp";
+export const METADATA_ONLY_FLAG = "--metadata-only";
+export const OPENCODE_PLUGIN_PACKAGE = "@consiliency/agent-board-opencode";
+export const PI_PACKAGE = "npm:@consiliency/agent-board-pi";
+/** Claude Code events that each need exactly one `wake-hook.sh` hook (`docs/local-wake-signal.md`). */
+export const CLAUDE_REQUIRED_HOOK_EVENTS = Object.freeze(["SessionStart", "FileChanged"]);
+export const WAKE_HOOK_MARKER = "wake-hook.sh";
+const WRAPPER_MAX_BYTES = 64 * 1024;
+const missing = (error) => {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+};
+export const nodeRegistrationFs = {
+    readFile(path) {
+        try {
+            return nodeFs.readFileSync(path, "utf8");
+        }
+        catch (error) {
+            if (missing(error))
+                return null;
+            throw error;
+        }
+    },
+    readdir(path) {
+        try {
+            return nodeFs.readdirSync(path).sort();
+        }
+        catch (error) {
+            if (missing(error))
+                return null;
+            throw error;
+        }
+    },
+    lstat(path) {
+        try {
+            const stats = nodeFs.lstatSync(path);
+            return { uid: stats.uid, size: stats.size, isFile: stats.isFile() };
+        }
+        catch (error) {
+            if (missing(error))
+                return null;
+            throw error;
+        }
+    },
+    exists(path) {
+        try {
+            nodeFs.lstatSync(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    getuid: () => process.getuid?.() ?? -1,
+};
+// ---------------------------------------------------------------------------------------------
+// Readers
+// ---------------------------------------------------------------------------------------------
+export class UnparseableConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UnparseableConfigError";
+    }
+}
+/** Keys that name a prototype slot rather than data: a file carrying one is refused. */
+export const FORBIDDEN_CONFIG_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+/** A prototype-free object: an inherited property cannot answer a lookup on it. */
+const dict = () => Object.create(null);
+/**
+ * A prototype-free copy of the sources' OWN enumerable properties, later sources winning. Not
+ * `Object.assign`, which the #403 code-provenance class check (fleet_diagnosability A10) reserves
+ * because it can copy an error's `code`.
+ */
+function overlay(...sources) {
+    const out = dict();
+    for (const source of sources)
+        for (const key of Object.keys(source))
+            out[key] = source[key];
+    return out;
+}
+/** An OWN property of `value`, else undefined: nothing is read through a prototype. */
+export function own(value, key) {
+    return value !== null && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key)
+        ? value[key]
+        : undefined;
+}
+/** JSON.parse reviver: refuse prototype keys and rebuild every object without a prototype. */
+function prototypeFree(key, value) {
+    if (FORBIDDEN_CONFIG_KEYS.has(key))
+        throw new UnparseableConfigError(`refused key ${key}`);
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return value;
+    return overlay(value);
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text, prototypeFree);
+    }
+    catch (error) {
+        if (error instanceof UnparseableConfigError)
+            throw error;
+        throw new UnparseableConfigError(error.message);
+    }
+}
+/** JSONC: `//` and `/* *\/` comments and trailing commas removed outside strings, then JSON. */
+export function parseJsonc(text) {
+    let out = "";
+    let index = 0;
+    while (index < text.length) {
+        const char = text[index];
+        if (char === "\"") {
+            let end = index + 1;
+            while (end < text.length && text[end] !== "\"")
+                end += text[end] === "\\" ? 2 : 1;
+            out += text.slice(index, end + 1);
+            index = end + 1;
+        }
+        else if (char === "/" && text[index + 1] === "/") {
+            while (index < text.length && text[index] !== "\n")
+                index += 1;
+        }
+        else if (char === "/" && text[index + 1] === "*") {
+            const end = text.indexOf("*/", index + 2);
+            if (end < 0)
+                throw new UnparseableConfigError("unterminated block comment");
+            index = end + 2;
+        }
+        else {
+            out += char;
+            index += 1;
+        }
+    }
+    return parseJson(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+function parseJsonDocument(text, allowEmpty) {
+    if (allowEmpty && text.trim() === "")
+        return dict();
+    return parseJson(text);
+}
+/**
+ * A restricted TOML reader: enough of the grammar to read `[mcp_servers.*]` and `[projects.*]`
+ * tables without a new dependency, and fail-closed on anything outside it. It handles bare and
+ * quoted dotted keys, `[table]` and `[[array.table]]` headers, basic/literal (and multi-line)
+ * strings, arrays over several lines, inline tables, and bare scalars. Sub-tables nest, so
+ * `[mcp_servers.x.env]` is `x`'s `env`, never a server named `x.env`.
+ */
+export function parseRestrictedToml(text) {
+    const root = dict();
+    let table = root;
+    let pos = 0;
+    const fail = (what) => {
+        const line = text.slice(0, pos).split("\n").length;
+        throw new UnparseableConfigError(`TOML line ${line}: ${what}`);
+    };
+    const skipInline = () => {
+        while (pos < text.length && (text[pos] === " " || text[pos] === "\t"))
+            pos += 1;
+        if (text[pos] === "#")
+            while (pos < text.length && text[pos] !== "\n")
+                pos += 1;
+    };
+    const skipAll = () => {
+        for (;;) {
+            skipInline();
+            if (text[pos] === "\n" || text[pos] === "\r")
+                pos += 1;
+            else
+                return;
+        }
+    };
+    const readBasic = () => {
+        if (text.startsWith("\"\"\"", pos)) {
+            const end = text.indexOf("\"\"\"", pos + 3);
+            if (end < 0)
+                fail("unterminated multi-line string");
+            const raw = text.slice(pos + 3, end).replace(/^\r?\n/, "");
+            pos = end + 3;
+            return raw;
+        }
+        let end = pos + 1;
+        while (end < text.length && text[end] !== "\"" && text[end] !== "\n")
+            end += text[end] === "\\" ? 2 : 1;
+        if (text[end] !== "\"")
+            fail("unterminated string");
+        const raw = text.slice(pos, end + 1);
+        pos = end + 1;
+        try {
+            return JSON.parse(raw.replace(/\\U([0-9A-Fa-f]{8})/g, (_m, hex) => String.fromCodePoint(parseInt(hex, 16))));
+        }
+        catch {
+            return fail("invalid escape in string");
+        }
+    };
+    const readLiteral = () => {
+        if (text.startsWith("'''", pos)) {
+            const end = text.indexOf("'''", pos + 3);
+            if (end < 0)
+                fail("unterminated multi-line literal string");
+            const raw = text.slice(pos + 3, end).replace(/^\r?\n/, "");
+            pos = end + 3;
+            return raw;
+        }
+        const end = text.indexOf("'", pos + 1);
+        if (end < 0 || text.slice(pos, end).includes("\n"))
+            fail("unterminated literal string");
+        const raw = text.slice(pos + 1, end);
+        pos = end + 1;
+        return raw;
+    };
+    const readKeyPart = () => {
+        skipInline();
+        const part = text[pos] === "\"" ? readBasic() : text[pos] === "'" ? readLiteral() : (() => {
+            const match = /^[A-Za-z0-9_-]+/.exec(text.slice(pos));
+            if (!match)
+                return fail("expected a key");
+            pos += match[0].length;
+            return match[0];
+        })();
+        if (FORBIDDEN_CONFIG_KEYS.has(part))
+            fail(`refused key ${part}`);
+        return part;
+    };
+    const readKey = () => {
+        const parts = [readKeyPart()];
+        for (;;) {
+            skipInline();
+            if (text[pos] !== ".")
+                return parts;
+            pos += 1;
+            parts.push(readKeyPart());
+        }
+    };
+    const readValue = () => {
+        skipInline();
+        const char = text[pos];
+        if (char === "\"")
+            return readBasic();
+        if (char === "'")
+            return readLiteral();
+        if (char === "[") {
+            pos += 1;
+            const items = [];
+            for (;;) {
+                skipAll();
+                if (text[pos] === "]") {
+                    pos += 1;
+                    return items;
+                }
+                items.push(readValue());
+                skipAll();
+                if (text[pos] === ",")
+                    pos += 1;
+                else if (text[pos] !== "]")
+                    fail("expected , or ] in array");
+            }
+        }
+        if (char === "{") {
+            pos += 1;
+            const inline = dict();
+            skipInline();
+            if (text[pos] === "}") {
+                pos += 1;
+                return inline;
+            }
+            for (;;) {
+                const key = readKey();
+                skipInline();
+                if (text[pos] !== "=")
+                    fail("expected = in inline table");
+                pos += 1;
+                assign(inline, key, readValue());
+                skipInline();
+                if (text[pos] === ",")
+                    pos += 1;
+                else if (text[pos] === "}") {
+                    pos += 1;
+                    return inline;
+                }
+                else
+                    fail("expected , or } in inline table");
+            }
+        }
+        const match = /^[A-Za-z0-9_:.+\-]+(?:[ T][0-9:.+\-Z]+)?/.exec(text.slice(pos));
+        if (!match)
+            return fail("unsupported value");
+        pos += match[0].length;
+        const bare = match[0];
+        if (bare === "true")
+            return true;
+        if (bare === "false")
+            return false;
+        if (/^[+-]?[0-9_]+$/.test(bare))
+            return Number(bare.replace(/_/g, ""));
+        if (/^[+-]?[0-9_]+(\.[0-9_]+)?([eE][+-]?[0-9]+)?$/.test(bare))
+            return Number(bare.replace(/_/g, ""));
+        if (/^\d{4}-\d{2}-\d{2}/.test(bare) || /^\d{2}:\d{2}/.test(bare) || /^[+-]?(inf|nan)$/.test(bare))
+            return bare;
+        return fail("unsupported bare value");
+    };
+    const descend = (from, key, arrayTable) => {
+        let node = from;
+        key.forEach((part, index) => {
+            const last = index === key.length - 1;
+            let next = own(node, part);
+            if (last && arrayTable) {
+                if (next === undefined)
+                    node[part] = next = [];
+                if (!Array.isArray(next))
+                    fail(`${part} is not an array of tables`);
+                const entry = dict();
+                next.push(entry);
+                node = entry;
+                return;
+            }
+            if (Array.isArray(next))
+                next = next[next.length - 1];
+            if (next === undefined)
+                node[part] = next = dict();
+            if (!next || typeof next !== "object" || Array.isArray(next))
+                fail(`${part} is not a table`);
+            node = next;
+        });
+        return node;
+    };
+    const assign = (into, key, value) => {
+        const parent = descend(into, key.slice(0, -1), false);
+        const last = key[key.length - 1];
+        if (Object.prototype.hasOwnProperty.call(parent, last))
+            fail(`duplicate key ${last}`);
+        parent[last] = value;
+    };
+    for (;;) {
+        skipAll();
+        if (pos >= text.length)
+            return root;
+        if (text[pos] === "[") {
+            const arrayTable = text[pos + 1] === "[";
+            pos += arrayTable ? 2 : 1;
+            const key = readKey();
+            skipInline();
+            if (text[pos] !== "]" || (arrayTable && text[pos + 1] !== "]"))
+                fail("unterminated table header");
+            pos += arrayTable ? 2 : 1;
+            table = descend(root, key, arrayTable);
+        }
+        else {
+            const key = readKey();
+            skipInline();
+            if (text[pos] !== "=")
+                fail("expected =");
+            pos += 1;
+            assign(table, key, readValue());
+        }
+        skipInline();
+        if (pos < text.length && text[pos] !== "\n" && text[pos] !== "\r")
+            fail("trailing characters");
+    }
+}
+const empty = () => ({ mcp: [], hooks: Object.create(null), packages: [] });
+const isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+/** Judge-relevant fields of one entry, from its own fields only. */
+export function mcpEntry(name, fields, shape) {
+    let command = null;
+    let args = [];
+    const rawCommand = own(fields, "command");
+    if (shape === "opencode") {
+        if (Array.isArray(rawCommand)) {
+            command = typeof rawCommand[0] === "string" ? rawCommand[0] : null;
+            args = rawCommand.slice(1).filter((item) => typeof item === "string");
+        }
+    }
+    else {
+        command = typeof rawCommand === "string" ? rawCommand : null;
+        const rawArgs = own(fields, "args");
+        args = Array.isArray(rawArgs) ? rawArgs.filter((item) => typeof item === "string") : [];
+    }
+    const disabled = own(fields, "disabled") === true || own(fields, "enabled") === false;
+    return { name, command, args, disabled, fields, shape };
+}
+function mcpFromMap(map, shape) {
+    if (map === undefined || map === null)
+        return [];
+    if (!isObject(map))
+        throw new UnparseableConfigError("MCP server map is not an object");
+    return Object.keys(map).map((name) => {
+        const raw = own(map, name);
+        if (!isObject(raw))
+            throw new UnparseableConfigError(`MCP server ${name} is not an object`);
+        return mcpEntry(name, overlay(raw), shape);
+    });
+}
+function hooksFrom(settings) {
+    const out = Object.create(null);
+    const hooksMap = own(settings, "hooks");
+    if (!isObject(settings) || hooksMap === undefined)
+        return out;
+    if (!isObject(hooksMap))
+        throw new UnparseableConfigError("hooks is not an object");
+    for (const event of Object.keys(hooksMap)) {
+        const groups = own(hooksMap, event);
+        if (!Array.isArray(groups))
+            throw new UnparseableConfigError(`hooks.${event} is not an array`);
+        for (const group of groups) {
+            const hooks = isObject(group) ? own(group, "hooks") : undefined;
+            if (!Array.isArray(hooks))
+                throw new UnparseableConfigError(`hooks.${event} has a group with no hooks array`);
+            for (const hook of hooks) {
+                const command = own(hook, "command");
+                if (isObject(hook) && typeof command === "string")
+                    (out[event] ??= []).push(command);
+            }
+        }
+    }
+    return out;
+}
+function packageSpecs(list, field) {
+    if (list === undefined)
+        return [];
+    if (!Array.isArray(list))
+        throw new UnparseableConfigError(`${field} is not an array`);
+    return list.flatMap((item) => {
+        if (typeof item === "string")
+            return [item];
+        const source = own(item, "source");
+        if (isObject(item) && typeof source === "string")
+            return [source];
+        if (Array.isArray(item) && typeof item[0] === "string")
+            return [item[0]];
+        return [];
+    });
+}
+/** Directories from `cwd` up to its git root (inclusive); just `cwd` outside a repository. */
+export function walkToGitRoot(cwd, fs) {
+    const dirs = [];
+    let current = resolve(cwd);
+    for (;;) {
+        dirs.push(current);
+        if (fs.exists(join(current, ".git")))
+            return dirs;
+        const parent = dirname(current);
+        if (parent === current)
+            return [resolve(cwd)];
+        current = parent;
+    }
+}
+const claudeConfigDir = (ctx) => {
+    const value = ctx.env.CLAUDE_CONFIG_DIR;
+    return value && isAbsolute(value) ? value : null;
+};
+const claudeJsonPath = (ctx) => join(claudeConfigDir(ctx) ?? ctx.home, ".claude.json");
+const claudeUserDir = (ctx) => claudeConfigDir(ctx) ?? join(ctx.home, ".claude");
+const managedSettingsPaths = (ctx) => [
+    join(ctx.claudeManagedDir, "managed-settings.json"),
+    ...(ctx.fs.readdir(join(ctx.claudeManagedDir, "managed-settings.d")) ?? [])
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => join(ctx.claudeManagedDir, "managed-settings.d", name)),
+];
+const codexHome = (ctx) => {
+    const value = ctx.env.CODEX_HOME;
+    return value && isAbsolute(value) ? value : join(ctx.home, ".codex");
+};
+const xdgConfig = (ctx) => {
+    const value = ctx.env.XDG_CONFIG_HOME;
+    return value && value.trim() !== "" && isAbsolute(value) ? value : join(ctx.home, ".config");
+};
+const piAgentDir = (ctx) => {
+    const value = ctx.env.PI_CODING_AGENT_DIR;
+    return value && isAbsolute(value) ? value : join(ctx.home, ".pi", "agent");
+};
+/** codex loads `<dir>/.codex/config.toml` only when the nearest `[projects]` entry at or above `<dir>` is trusted. */
+function codexLayerTrusted(path, ctx) {
+    const text = ctx.fs.readFile(join(codexHome(ctx), "config.toml"));
+    if (text === null)
+        return false;
+    const projects = own(parseRestrictedToml(text), "projects");
+    if (!isObject(projects))
+        return false;
+    let dir = dirname(dirname(path));
+    for (;;) {
+        const entry = own(projects, dir);
+        if (isObject(entry))
+            return own(entry, "trust_level") === "trusted";
+        const parent = dirname(dir);
+        if (parent === dir)
+            return false;
+        dir = parent;
+    }
+}
+const row = (definition) => Object.freeze(definition);
+/** The frozen, re-checked scope table (see the header for each amendment and its evidence). */
+export const HARNESS_CONFIG_SCOPES = Object.freeze({
+    claude: Object.freeze([
+        row({ name: "claude_user_mcp", parser: "json", rank: 10, paths: (ctx) => [claudeJsonPath(ctx)],
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "mcpServers"), "claude") }) }),
+        row({ name: "claude_local_mcp", parser: "json", rank: 30, paths: (ctx) => [claudeJsonPath(ctx)],
+            extract: (doc, ctx) => {
+                const project = own(own(doc, "projects"), resolve(ctx.cwd));
+                return { ...empty(), mcp: mcpFromMap(own(project, "mcpServers"), "claude") };
+            } }),
+        row({ name: "claude_project_mcp", parser: "json", rank: 20, paths: (ctx) => [join(ctx.cwd, ".mcp.json")],
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "mcpServers"), "claude") }) }),
+        row({ name: "claude_managed_mcp", parser: "json", rank: 40, paths: (ctx) => [join(ctx.claudeManagedDir, "managed-mcp.json")],
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "mcpServers"), "claude") }) }),
+        row({ name: "claude_managed_settings", parser: "json", rank: 40, paths: managedSettingsPaths,
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "managedMcpServers"), "claude"), hooks: hooksFrom(doc) }) }),
+        row({ name: "claude_user_settings", parser: "json", rank: 10, paths: (ctx) => [join(claudeUserDir(ctx), "settings.json")],
+            extract: (doc) => ({ ...empty(), hooks: hooksFrom(doc) }) }),
+        row({ name: "claude_project_settings", parser: "json", rank: 20, paths: (ctx) => [join(ctx.cwd, ".claude", "settings.json")],
+            extract: (doc) => ({ ...empty(), hooks: hooksFrom(doc) }) }),
+        row({ name: "claude_project_local_settings", parser: "json", rank: 30, paths: (ctx) => [join(ctx.cwd, ".claude", "settings.local.json")],
+            extract: (doc) => ({ ...empty(), hooks: hooksFrom(doc) }) }),
+    ]),
+    codex: Object.freeze([
+        row({ name: "codex_user", parser: "toml", rank: 10, paths: (ctx) => [join(codexHome(ctx), "config.toml")],
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "mcp_servers"), "toml") }) }),
+        row({ name: "codex_project", parser: "toml", rank: 20, walkWins: "nearest",
+            paths: (ctx) => walkToGitRoot(ctx.cwd, ctx.fs).map((dir) => join(dir, ".codex", "config.toml"))
+                .filter((path) => path !== join(codexHome(ctx), "config.toml")),
+            loaded: codexLayerTrusted,
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "mcp_servers"), "toml") }) }),
+    ]),
+    grok: Object.freeze([
+        row({ name: "grok_user", parser: "toml", rank: 10, paths: (ctx) => [join(ctx.home, ".grok", "config.toml")],
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "mcp_servers"), "toml") }) }),
+        row({ name: "grok_project", parser: "toml", rank: 20, walkWins: "nearest",
+            paths: (ctx) => walkToGitRoot(ctx.cwd, ctx.fs).map((dir) => join(dir, ".grok", "config.toml"))
+                .filter((path) => path !== join(ctx.home, ".grok", "config.toml")),
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "mcp_servers"), "toml") }) }),
+    ]),
+    agy: Object.freeze([
+        row({ name: "agy_user", parser: "json_or_empty", rank: 10, paths: (ctx) => [join(ctx.home, ".gemini", "config", "mcp_config.json")],
+            extract: (doc) => ({ ...empty(), mcp: mcpFromMap(own(doc, "mcpServers"), "agy") }) }),
+    ]),
+    opencode: Object.freeze([
+        row({ name: "opencode_user", parser: "jsonc", rank: 10,
+            paths: (ctx) => ["opencode.json", "opencode.jsonc"].map((name) => join(xdgConfig(ctx), "opencode", name)),
+            extract: (doc) => opencodeContribution(doc) }),
+        // Nearest directory wins, but INSIDE one directory .json is applied before .jsonc: measured on
+        // opencode 1.18.32 (`opencode debug config`, dev0, 2026-09-26) — .jsonc won in both orders. So the directories are reversed here and the pair keeps its order: a flat
+        // `walkWins: "nearest"` reverse would also swap the two files (Q-6).
+        row({ name: "opencode_project", parser: "jsonc", rank: 20,
+            paths: (ctx) => [...walkToGitRoot(ctx.cwd, ctx.fs)].reverse().flatMap((dir) => ["opencode.json", "opencode.jsonc"].map((name) => join(dir, name))),
+            extract: (doc) => opencodeContribution(doc) }),
+        row({ name: "opencode_project_dotdir", parser: "jsonc", rank: 30, walkWins: "farthest",
+            paths: (ctx) => walkToGitRoot(ctx.cwd, ctx.fs).flatMap((dir) => ["opencode.json", "opencode.jsonc"].map((name) => join(dir, ".opencode", name))),
+            extract: (doc) => opencodeContribution(doc) }),
+    ]),
+    pi: Object.freeze([
+        row({ name: "pi_user", parser: "json", rank: 10, paths: (ctx) => [join(piAgentDir(ctx), "settings.json")],
+            extract: (doc) => ({ ...empty(), packages: packageSpecs(own(doc, "packages"), "packages") }) }),
+        row({ name: "pi_project", parser: "json", rank: 20, paths: (ctx) => [join(ctx.cwd, ".pi", "settings.json")],
+            extract: (doc) => ({ ...empty(), packages: packageSpecs(own(doc, "packages"), "packages") }) }),
+    ]),
+});
+/**
+ * How a harness combines a same-named entry across its layers (see the header): codex and
+ * opencode overlay the higher layer's fields (measured); claude replaces the whole entry
+ * (inferred); grok is assumed to behave like codex (unmeasured); agy and pi have one layer, so
+ * their value is never used.
+ */
+export const MCP_LAYER_MERGE = Object.freeze({
+    claude: "replace", codex: "fields", grok: "fields", agy: "fields", opencode: "fields", pi: "fields",
+});
+function opencodeContribution(doc) {
+    if (!isObject(doc))
+        throw new UnparseableConfigError("opencode config is not an object");
+    return { ...empty(), mcp: mcpFromMap(own(doc, "mcp"), "opencode"), packages: packageSpecs(own(doc, "plugin"), "plugin") };
+}
+// ---------------------------------------------------------------------------------------------
+// Judgement
+// ---------------------------------------------------------------------------------------------
+/** A package spec's identity without its version: `@scope/name@1.2.3` → `@scope/name`. */
+export function packageIdentity(spec) {
+    const at = spec.lastIndexOf("@");
+    const scopeEnd = spec.indexOf("/");
+    return at > 0 && at > scopeEnd && spec[at - 1] !== ":" ? spec.slice(0, at) : spec;
+}
+/** A board MCP entry names `agent-board-mcp` in its command/args, or through ONE user-owned wrapper file. */
+export function judgeMcpEntry(entry, fs) {
+    const words = [entry.command ?? "", ...entry.args];
+    const flagged = words.some((word) => word === METADATA_ONLY_FLAG || word.startsWith(`${METADATA_ONLY_FLAG}=`));
+    if (words.some((word) => word.includes(BOARD_MCP_MARKER)))
+        return { board: true, flagged };
+    if (entry.command && isAbsolute(entry.command)) {
+        const stats = fs.lstat(entry.command);
+        if (stats && stats.isFile && stats.uid === fs.getuid() && stats.size < WRAPPER_MAX_BYTES) {
+            const text = fs.readFile(entry.command) ?? "";
+            if (text.includes(BOARD_MCP_MARKER))
+                return { board: true, flagged: flagged || text.includes(METADATA_ONLY_FLAG) };
+        }
+    }
+    return { board: false, flagged: false };
+}
+/**
+ * Read every scope row of `harness` for `cwd`. A file that fails to parse is reported, not guessed.
+ * `files` is in ascending precedence: a later file's same-named entry overrides an earlier one's.
+ */
+export function readScopes(harness, ctx) {
+    const files = [];
+    const unparseable = [];
+    const rows = [...HARNESS_CONFIG_SCOPES[harness]].sort((a, b) => a.rank - b.rank);
+    for (const scope of rows) {
+        // `paths` is in application order (the last file wins), except a walked row with `walkWins`,
+        // whose paths come cwd first and are reversed here when the nearest directory must win.
+        const paths = scope.paths(ctx);
+        for (const path of scope.walkWins === "nearest" ? [...paths].reverse() : paths) {
+            const text = ctx.fs.readFile(path);
+            if (text === null)
+                continue;
+            try {
+                if (scope.loaded && !scope.loaded(path, ctx))
+                    continue;
+                const document = scope.parser === "toml" ? parseRestrictedToml(text)
+                    : scope.parser === "jsonc" ? parseJsonc(text)
+                        : parseJsonDocument(text, scope.parser === "json_or_empty");
+                files.push({ row: scope.name, path, contribution: scope.extract(document, ctx) });
+            }
+            catch (error) {
+                if (!(error instanceof UnparseableConfigError))
+                    throw error;
+                unparseable.push(scope.name);
+            }
+        }
+    }
+    return { files, unparseable };
+}
+/** IF-0-CREDPATH-4 registration, for one working directory. */
+export function judgeRegistration(harness, ctx) {
+    const { files, unparseable } = readScopes(harness, ctx);
+    const failures = [];
+    // The EFFECTIVE server map first: a higher layer's same-named entry overrides (replacing it, or
+    // overlaying its fields), so a board entry disabled or re-pointed above is judged as such.
+    const effective = new Map();
+    for (const file of files) {
+        for (const entry of file.contribution.mcp) {
+            const lower = effective.get(entry.name)?.entry;
+            const merged = lower && MCP_LAYER_MERGE[harness] === "fields"
+                ? mcpEntry(entry.name, overlay(lower.fields, entry.fields), entry.shape)
+                : entry;
+            effective.set(entry.name, { entry: merged, row: file.row });
+        }
+    }
+    const boardNames = new Set();
+    const boardRows = new Set();
+    let flagged = false;
+    for (const { entry, row: scopeRow } of effective.values()) {
+        if (entry.disabled)
+            continue;
+        const verdict = judgeMcpEntry(entry, ctx.fs);
+        if (!verdict.board)
+            continue;
+        boardNames.add(entry.name);
+        boardRows.add(scopeRow);
+        flagged ||= verdict.flagged;
+    }
+    if (flagged)
+        failures.push("metadata_only_flag");
+    if (boardNames.size > 1)
+        failures.push(`duplicate_registration:${[...boardRows].sort().join("+")}`);
+    if (harness === "opencode" || harness === "pi") {
+        const wanted = harness === "opencode" ? OPENCODE_PLUGIN_PACKAGE : PI_PACKAGE;
+        const present = files.some((file) => file.contribution.packages.some((spec) => packageIdentity(spec) === wanted));
+        if (!present)
+            failures.push("no_registration");
+    }
+    else if (boardNames.size === 0) {
+        failures.push("no_registration");
+    }
+    if (harness === "claude") {
+        for (const event of CLAUDE_REQUIRED_HOOK_EVENTS) {
+            const count = files.reduce((sum, file) => sum + (file.contribution.hooks[event] ?? []).filter((command) => command.includes(WAKE_HOOK_MARKER)).length, 0);
+            if (count === 0)
+                failures.push(`missing_hook:${event}`);
+            if (count > 1)
+                failures.push(`duplicate_hook:${event}`);
+        }
+    }
+    // An absence is only evidence when every file was read: the missing entry may be in the file
+    // that did not parse. A duplicate or the flag, seen in files that DID parse, stands.
+    const standing = unparseable.length === 0
+        ? failures
+        : failures.filter((failure) => failure !== "no_registration" && !failure.startsWith("missing_hook:"));
+    if (standing.length > 0)
+        return { status: "fail", reason: standing.join(",") };
+    if (unparseable.length > 0)
+        return { status: "undetermined", reason: `unparseable:${[...new Set(unparseable)].join("+")}` };
+    return { status: "pass", reason: "registered" };
+}