@yagni-app/code-staging 1.0.5-staging.1234.1 → 1.0.5-staging.1238.1

package/dist/claudePlugins.d.ts

@@ -18,7 +18,9 @@
  *    disabled via `enabledPlugins`.
  *
  * Deliberately NOT here: network installation of any kind, plugin hooks, MCP
- * servers, LSP servers, themes, output styles. Discovery is read-only.
+ * servers (standard MCP support lives in `src/mcpCommand.ts` + the extension's
+ * `mcp/` module — see `yagni mcp --help`), LSP servers, themes, output styles.
+ * Discovery is read-only.
  *
  * Everything is fail-soft: malformed JSON, missing dirs, or hostile path
  * entries degrade to "that plugin absent" — never a failed launch. Path

package/dist/claudePlugins.js

@@ -18,7 +18,9 @@
  *    disabled via `enabledPlugins`.
  *
  * Deliberately NOT here: network installation of any kind, plugin hooks, MCP
- * servers, LSP servers, themes, output styles. Discovery is read-only.
+ * servers (standard MCP support lives in `src/mcpCommand.ts` + the extension's
+ * `mcp/` module — see `yagni mcp --help`), LSP servers, themes, output styles.
+ * Discovery is read-only.
  *
  * Everything is fail-soft: malformed JSON, missing dirs, or hostile path
  * entries degrade to "that plugin absent" — never a failed launch. Path

package/dist/cli.js

@@ -23,6 +23,7 @@ import { agentDir, credentialsDir, piPackageDir } from "./credentials.js";
 import { DISTRIBUTION } from "./distribution.js";
 import { connectCommand } from "./connectClaudeCode.js";
 import { goCommand } from "./goHeadless.js";
+import { mcpCommand } from "./mcpCommand.js";
 import { login } from "./login.js";
 import { logout } from "./logout.js";
 import { tokenCommand } from "./token.js";
@@ -653,6 +654,12 @@ export async function main(argv) {
     if (command === "connect") {
         return connectCommand(rest);
     }
+    // MCP server configuration: same three-scope model and file homes the
+    // in-session /mcp panel uses, shared code via the bundled extension's
+    // config entry. `list` runs real health-check connections.
+    if (command === "mcp") {
+        return mcpCommand(rest);
+    }
     // The headless pipeline entry. `go` is a real subcommand, not passthrough:
     // the interactive run stays `/go` inside a session, and a `yagni go` without
     // --headless is refused with usage rather than launched as an agent prompt.

package/dist/doctor.d.ts

@@ -67,6 +67,24 @@ export declare function checkGh(onPath: boolean): CheckResult;
  * most machines have no collector, and that is the healthy default.
  */
 export declare function checkOtelExport(config: OtelLaunchConfig | undefined): CheckResult;
+/** Config-only MCP snapshot (no connections — health checks live in `mcp list`/`get`). */
+export interface McpProbe {
+    /** YAGNI_CODE_MCP_DISABLED kill-switch is active. */
+    disabled: boolean;
+    /** Count of configured servers (post-merge, before the approval gate). */
+    serverCount: number;
+    /** Project-scope servers that are neither enabled nor disabled. */
+    undecidedProjectServers: string[];
+    /** Config parse/validation errors (already human-readable). */
+    errors: string[];
+}
+/**
+ * Advisory (never required) MCP line: reports config health without connecting
+ * to anything — `yagni mcp list`/`get` already run the real health checks, and
+ * doctor must never spawn an unapproved server process. The kill-switch and
+ * pending-approval cases read as `warn`, config errors as `fail` (non-required).
+ */
+export declare function checkMcpConfig(probe: McpProbe): CheckResult;
 /** What the Windows bash probe found (pi needs a bash — Git Bash — on win32). */
 export interface BashProbe {
     found: boolean;
@@ -95,6 +113,8 @@ export interface DoctorDeps {
     probeBash?: () => BashProbe;
     currentVersion?: string;
     probeLatestVersion?: () => Promise<string | null>;
+    /** MCP config snapshot (config-only, no connections). */
+    probeMcp?: () => Promise<McpProbe>;
     log?: (msg: string) => void;
 }
 /** Whether a `gh` executable is resolvable on PATH (no subprocess spawn). */

package/dist/doctor.js

@@ -20,6 +20,7 @@ import { classifyTokenExpiry } from "./launch.js";
 import { resolveOtelLaunchWithWorkspace } from "./otel.js";
 import { resolveExtensionPath, resolvePiCliPath, resolvePiPackageDir } from "./paths.js";
 import { readActiveProfile } from "./profiles.js";
+import { resolveMcpConfigPath } from "./mcpCommand.js";
 // ── Pure check builders ─────────────────────────────────────────────────────
 export function checkPiEngine(probe) {
     if (!probe.binPath || !probe.binExists) {
@@ -225,6 +226,55 @@ export function checkOtelExport(config) {
         required: false,
     };
 }
+/**
+ * Advisory (never required) MCP line: reports config health without connecting
+ * to anything — `yagni mcp list`/`get` already run the real health checks, and
+ * doctor must never spawn an unapproved server process. The kill-switch and
+ * pending-approval cases read as `warn`, config errors as `fail` (non-required).
+ */
+export function checkMcpConfig(probe) {
+    if (probe.disabled) {
+        return {
+            name: "mcp servers",
+            status: "warn",
+            detail: "disabled (YAGNI_CODE_MCP_DISABLED=1)",
+            hint: "unset YAGNI_CODE_MCP_DISABLED to re-enable MCP servers",
+            required: false,
+        };
+    }
+    if (probe.errors.length > 0) {
+        return {
+            name: "mcp servers",
+            status: "fail",
+            detail: `${probe.serverCount} configured, ${probe.errors.length} config error${probe.errors.length === 1 ? "" : "s"}`,
+            hint: `run \`yagni mcp list\` (first error: ${probe.errors[0]})`,
+            required: false,
+        };
+    }
+    if (probe.serverCount === 0) {
+        return {
+            name: "mcp servers",
+            status: "ok",
+            detail: "none configured",
+            required: false,
+        };
+    }
+    if (probe.undecidedProjectServers.length > 0) {
+        return {
+            name: "mcp servers",
+            status: "warn",
+            detail: `${probe.serverCount} configured, ${probe.undecidedProjectServers.length} awaiting approval`,
+            hint: "run /mcp to approve the project servers",
+            required: false,
+        };
+    }
+    return {
+        name: "mcp servers",
+        status: "ok",
+        detail: `${probe.serverCount} configured`,
+        required: false,
+    };
+}
 export function checkBash(probe) {
     if (!probe.found) {
         return {
@@ -312,6 +362,37 @@ function defaultProbeStateDir() {
         return { path, exists: false, mode: null };
     }
 }
+async function defaultProbeMcp(env = process.env) {
+    const disabled = env.YAGNI_CODE_MCP_DISABLED === "1";
+    if (disabled)
+        return { disabled: true, serverCount: 0, undecidedProjectServers: [], errors: [] };
+    try {
+        const mod = (await import(resolveMcpConfigPath()));
+        if (typeof mod?.loadMcpServers !== "function") {
+            return { disabled: false, serverCount: 0, undecidedProjectServers: [], errors: ["extension MCP config entry missing"] };
+        }
+        const loaded = mod.loadMcpServers(process.cwd(), env);
+        const repoRoot = mod.resolveProjectRoot(process.cwd());
+        const { state } = mod.readProjectApproval(repoRoot);
+        const undecided = loaded.servers
+            .filter((s) => s.scope === "project" && mod.decisionFor(state, s.name) === "undecided")
+            .map((s) => s.name);
+        return {
+            disabled: false,
+            serverCount: loaded.servers.length,
+            undecidedProjectServers: undecided,
+            errors: loaded.errors.map((e) => (e.serverName ? `${e.serverName}: ${e.message}` : e.message)),
+        };
+    }
+    catch (err) {
+        return {
+            disabled: false,
+            serverCount: 0,
+            undecidedProjectServers: [],
+            errors: [err instanceof Error ? err.message : String(err)],
+        };
+    }
+}
 async function defaultProbeBackend(baseUrl, token) {
     if (!token)
         return { kind: "skipped" };
@@ -378,6 +459,7 @@ export async function gatherChecks(deps = {}) {
     const readProfile = deps.readActiveProfile ?? readActiveProfile;
     const probeBackend = deps.probeBackend ?? defaultProbeBackend;
     const probeStateDir = deps.probeStateDir ?? defaultProbeStateDir;
+    const probeMcp = deps.probeMcp ?? (() => defaultProbeMcp());
     const ghOnPath = deps.ghOnPath ?? (() => ghOnPathDefault());
     const platform = deps.platform ?? process.platform;
     const probeBash = deps.probeBash ?? (() => bashOnWindowsDefault());
@@ -406,6 +488,7 @@ export async function gatherChecks(deps = {}) {
     checks.push(checkBackend(backend));
     checks.push(checkStateDir(probeStateDir()));
     checks.push(checkGh(ghOnPath()));
+    checks.push(checkMcpConfig(await probeMcp()));
     checks.push(checkOtelExport(await resolveOtelLaunchWithWorkspace({
         env: process.env,
         cwd: process.cwd(),

package/dist/extension/index.d.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { type SpendResponse } from "./costHud.js";
 import { runInitPass as defaultRunInitPass } from "./initPass.js";
-import { fetchMcpServers as defaultFetchMcpServers } from "./mcpTools.js";
+import { startMcp as defaultStartMcp } from "./mcp/startup.js";
 import { type FlushOutcome, type SpoolClientOpts } from "./spool.js";
 import { type TokenProvider } from "./tokenProvider.js";
 import { type CatalogResult, type ContextBrief } from "./config.js";
@@ -53,11 +53,11 @@ export interface RegisterYagniDeps {
     /** The beat's once-per-repo marker store. Injectable (no disk in tests). */
     mineBeatMarkers?: MineBeatMarkers;
     /**
-     * Workspace MCP server list seam (YAG-446). The default hits
-     * `/api/yagni-code/mcp/servers` and is fail-soft: older backends and
-     * un-rescoped tokens yield `[]`, never a startup error.
+     * Local-MCP startup seam: injectable so tests assert the wiring (approval
+     * skip, kill-switch, mutating-tool gate) without touching real config
+     * homes or spawning servers. Default runs the real startup.
      */
-    fetchMcpServers?: typeof defaultFetchMcpServers;
+    startMcp?: typeof defaultStartMcp;
     /**
      * The CLI init pass (Onramp Door B). Injectable so tests assert it fires on a
      * fresh-workspace first-run and is skipped otherwise, without a network or disk.

package/dist/extension/index.js

@@ -29,7 +29,8 @@ import { createYagniFooterFactory, cyclePermissionMode, formatCwd, GIT_MUTATING_
 import { RerouteNotifier } from "./rerouteNotice.js";
 import { isFreshWorkspace, registerTeamSetupCommand, runInitPass as defaultRunInitPass } from "./initPass.js";
 import { isInitDone as defaultIsInitDone, markInitDone as defaultMarkInitDone } from "./initDone.js";
-import { fetchMcpServers as defaultFetchMcpServers, registerMcpCommand, registerMcpTools, } from "./mcpTools.js";
+import { looksMutating } from "./mcp/tools.js";
+import { startMcp as defaultStartMcp, wireShutdown, deriveStartupConnectivityNotices } from "./mcp/startup.js";
 import { registerGoCommand } from "./pipeline/goCommand.js";
 import { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
 import { DEFAULT_PERMISSION_POLICY, createModeHolder, registerPermissionGate } from "./permission/gate.js";
@@ -293,16 +294,65 @@ export async function registerYagni(pi, deps = {}) {
     const decisionCapture = evalMode ? undefined : makeDecisionCapture(decisionClientOpts);
     if (!evalMode)
         registerDecisionCommands(pi, decisionClientOpts);
-    // Workspace MCP servers (YAG-446): register one tool per enabled server
-    // tool, executing through the backend proxy, plus the /mcp listing
-    // command. Fail-soft fetch (older backend / un-rescoped token → no MCP
-    // tools); skipped in eval mode like the other external-side-effect tools.
-    const fetchMcp = deps.fetchMcpServers ?? defaultFetchMcpServers;
-    const mcpServers = evalMode
-        ? []
-        : await fetchMcp({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
-    const { mutatingToolNames: mcpMutatingTools } = registerMcpTools(pi, mcpServers, { baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
-    registerMcpCommand(pi, mcpServers, { baseUrl });
+    // Local MCP servers (standard client, replaces the backend-proxy /mcp of
+    // the YAG-446 era): load user/project/local config, approval-gate project
+    // servers, connect, register one tool per server tool plus /mcp panel.
+    // Fail-soft everywhere; skipped entirely in eval mode (external side
+    // effects) and under the YAGNI_CODE_MCP_DISABLED kill-switch.
+    const startMcpImpl = deps.startMcp ?? defaultStartMcp;
+    // One-shot notices queued by startMcp at session start (the `.mcp.json`
+    // approval prompt); flushed once on the first provider response. Connectivity
+    // notices are NOT here — they are recomputed live at flush (see below).
+    const mcpApprovalNotices = [];
+    const mcpOutcome = evalMode
+        ? { manager: undefined, mutatingToolNames: [] }
+        : await startMcpImpl(pi, {
+            cwd: process.cwd(),
+            env,
+            hasUI: true,
+            notify: (msg) => mcpApprovalNotices.push(msg),
+        });
+    const mcpMutatingSet = new Set(mcpOutcome.mutatingToolNames);
+    // Wire names carry the original tool name after the second `__`: parse it
+    // out and re-run the heuristic for tools registered after startup (a
+    // reconnect can re-register tools the original classification never saw).
+    const mcpStartupIsMutating = (wireName) => {
+        const parts = wireName.split("__");
+        const original = parts.slice(2).join("__");
+        if (!original)
+            return false;
+        return looksMutating(original);
+    };
+    if (!evalMode && mcpOutcome.manager) {
+        wireShutdown(pi, mcpOutcome.manager);
+        // Startup notify (documented CC deviation): one quiet line per notice on
+        // the first provider response — never raw stdout, never blocking.
+        //
+        // Connectivity notices are recomputed against LIVE manager state at flush
+        // time (not the frozen startMcp snapshot): if the user healed a server via
+        // /mcp before the first turn, it must no longer read as broken/unauth.
+        // The static queue only carries non-connectivity notices (e.g. the
+        // `.mcp.json` approval prompt), which stay one-shot.
+        let connectivityNoticesFlushed = false;
+        pi.on("after_provider_response", (_event, ctx) => {
+            try {
+                if (!ctx.hasUI)
+                    return;
+                const connectivity = connectivityNoticesFlushed
+                    ? []
+                    : deriveStartupConnectivityNotices(mcpOutcome.manager);
+                connectivityNoticesFlushed = true;
+                for (const notice of connectivity)
+                    ctx.ui.notify(notice, "info");
+                while (mcpApprovalNotices.length > 0) {
+                    ctx.ui.notify(mcpApprovalNotices.shift(), "info");
+                }
+            }
+            catch {
+                // A notice must never break a turn.
+            }
+        });
+    }
     // P3 + W4: interactive permission tiers + plan mode via /mode, now with a
     // session bless store (three-way review-mode select) and a capture hook that
     // drafts a decision on "don't ask again". Default auto, so still additive.
@@ -461,18 +511,17 @@ export async function registerYagni(pi, deps = {}) {
                     }
                 })();
             },
-        ...(mcpMutatingTools.length > 0
+        ...(mcpMutatingSet.size > 0 || mcpOutcome.manager
             ? {
                 policy: {
-                    planBlockTools: [
-                        ...DEFAULT_PERMISSION_POLICY.planBlockTools,
-                        ...mcpMutatingTools,
-                    ],
-                    reviewConfirmTools: [
-                        ...DEFAULT_PERMISSION_POLICY.reviewConfirmTools,
-                        ...mcpMutatingTools,
-                    ],
+                    planBlockTools: [...DEFAULT_PERMISSION_POLICY.planBlockTools],
+                    reviewConfirmTools: [...DEFAULT_PERMISSION_POLICY.reviewConfirmTools],
                     alwaysConfirmTools: DEFAULT_PERMISSION_POLICY.alwaysConfirmTools,
+                    // Predicate (not a static spread): matches any registered
+                    // mcp__* tool that startup classified as mutating, including
+                    // tools re-registered after a /mcp reconnect.
+                    isMutating: (toolName) => mcpMutatingSet.has(toolName) ||
+                        (toolName.startsWith("mcp__") && mcpStartupIsMutating(toolName)),
                 },
             }
             : {}),

package/dist/extension/mcp/approval.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Approval gate for project-scope `.mcp.json` servers, mirroring Claude Code's
+ * decision shape: a `.mcp.json` in the repo (shared, VCS-controlled) cannot
+ * spawn processes until the user has approved it. Choices live in the
+ * per-project entry of `~/.yagni-code/mcp.json` under Claude Code's exact key
+ * names (`enabledMcpjsonServers` / `disabledMcpjsonServers` /
+ * `enableAllProjectMcpServers`), so a decision made in one tool is respected
+ * by the other.
+ */
+import { McpConfigError, UserMcpProjectEntry } from "./config.js";
+export type ProjectApprovalDecision = "enabled" | "disabled" | "undecided";
+export interface ProjectApprovalState {
+    enabledMcpjsonServers: string[];
+    disabledMcpjsonServers: string[];
+    enableAllProjectMcpServers: boolean;
+}
+/** Read the approval state for one project (abs path). Missing file/entry → fresh state. */
+export declare function readProjectApproval(repoRoot: string): {
+    state: ProjectApprovalState;
+    errors: McpConfigError[];
+};
+/** Effective decision for one project-scope server. Undecided by default. */
+export declare function decisionFor(state: ProjectApprovalState, serverName: string): ProjectApprovalDecision;
+/** Which configured project servers await a decision (drives the session-start prompt). */
+export declare function undecidedProjectServers(state: ProjectApprovalState, projectServerNames: string[]): string[];
+/**
+ * Record a decision. `enableAll: true` mirrors Claude Code's "Yes, approve all
+ * project servers in this repo" (sets the blanket flag); a single enable/disable
+ * appends to the corresponding list. Idempotent.
+ */
+export declare function recordProjectDecision(repoRoot: string, serverName: string | "all", decision: "enabled" | "disabled"): {
+    errors: McpConfigError[];
+};
+/** Clear this project's `.mcp.json` decisions (`yagni mcp reset-project-choices`). */
+export declare function resetProjectChoices(repoRoot: string): {
+    errors: McpConfigError[];
+};
+/**
+ * Mutate `~/.yagni-code/mcp.json`'s per-project entry under a read-modify-write
+ * helper shared with CLI commands (add/remove at local scope).
+ */
+export declare function updateProjectEntry(repoRoot: string, mutate: (entry: UserMcpProjectEntry) => void): {
+    errors: McpConfigError[];
+};
+//# sourceMappingURL=approval.d.ts.map

package/dist/extension/mcp/approval.js

@@ -0,0 +1,164 @@
+/**
+ * Approval gate for project-scope `.mcp.json` servers, mirroring Claude Code's
+ * decision shape: a `.mcp.json` in the repo (shared, VCS-controlled) cannot
+ * spawn processes until the user has approved it. Choices live in the
+ * per-project entry of `~/.yagni-code/mcp.json` under Claude Code's exact key
+ * names (`enabledMcpjsonServers` / `disabledMcpjsonServers` /
+ * `enableAllProjectMcpServers`), so a decision made in one tool is respected
+ * by the other.
+ */
+import { mcpConfigPath, readProjectMcpConfig, readUserMcpConfig, writeUserMcpConfig, } from "./config.js";
+/** Read the approval state for one project (abs path). Missing file/entry → fresh state. */
+export function readProjectApproval(repoRoot) {
+    const { file, errors } = readUserMcpConfig();
+    const entry = (file.projects ?? {})[repoRoot] ?? {};
+    return {
+        state: {
+            enabledMcpjsonServers: entry.enabledMcpjsonServers ?? [],
+            disabledMcpjsonServers: entry.disabledMcpjsonServers ?? [],
+            enableAllProjectMcpServers: entry.enableAllProjectMcpServers ?? false,
+        },
+        errors,
+    };
+}
+/** Effective decision for one project-scope server. Undecided by default. */
+export function decisionFor(state, serverName) {
+    if (state.enableAllProjectMcpServers)
+        return "enabled";
+    if (state.enabledMcpjsonServers.includes(serverName))
+        return "enabled";
+    if (state.disabledMcpjsonServers.includes(serverName))
+        return "disabled";
+    return "undecided";
+}
+/** Which configured project servers await a decision (drives the session-start prompt). */
+export function undecidedProjectServers(state, projectServerNames) {
+    return projectServerNames.filter((name) => decisionFor(state, name) === "undecided");
+}
+/**
+ * Record a decision. `enableAll: true` mirrors Claude Code's "Yes, approve all
+ * project servers in this repo" (sets the blanket flag); a single enable/disable
+ * appends to the corresponding list. Idempotent.
+ */
+export function recordProjectDecision(repoRoot, serverName, decision) {
+    const { file, errors } = readUserMcpConfig();
+    if (errors.length > 0)
+        return { errors };
+    const projects = file.projects ?? {};
+    const entry = projects[repoRoot] ?? {};
+    if (serverName === "all") {
+        if (decision === "enabled") {
+            projects[repoRoot] = { ...entry, enableAllProjectMcpServers: true };
+        }
+        else {
+            // "Disable all" clears the blanket flag and marks every current server
+            // disabled by name (a new server added to .mcp.json later re-prompts).
+            const projectServerNames = currentProjectServerNames(repoRoot);
+            projects[repoRoot] = {
+                ...entry,
+                enableAllProjectMcpServers: false,
+                enabledMcpjsonServers: [],
+                disabledMcpjsonServers: projectServerNames,
+            };
+        }
+    }
+    else {
+        const enabled = new Set(entry.enabledMcpjsonServers ?? []);
+        const disabled = new Set(entry.disabledMcpjsonServers ?? []);
+        if (decision === "enabled") {
+            enabled.add(serverName);
+            disabled.delete(serverName);
+        }
+        else {
+            disabled.add(serverName);
+            enabled.delete(serverName);
+        }
+        projects[repoRoot] = {
+            ...entry,
+            enabledMcpjsonServers: [...enabled],
+            disabledMcpjsonServers: [...disabled],
+        };
+    }
+    file.projects = projects;
+    try {
+        writeUserMcpConfig(file);
+        return { errors: [] };
+    }
+    catch (err) {
+        return {
+            errors: [
+                {
+                    sourcePath: mcpConfigPath(),
+                    message: `could not persist approval decision (${err instanceof Error ? err.message : String(err)})`,
+                },
+            ],
+        };
+    }
+}
+function currentProjectServerNames(repoRoot) {
+    // Read fresh so a just-edited .mcp.json is reflected in a "disable all" write.
+    return Object.keys(readProjectMcpConfig(repoRoot).servers);
+}
+/** Clear this project's `.mcp.json` decisions (`yagni mcp reset-project-choices`). */
+export function resetProjectChoices(repoRoot) {
+    const { file, errors } = readUserMcpConfig();
+    if (errors.length > 0)
+        return { errors };
+    const projects = file.projects ?? {};
+    const entry = projects[repoRoot] ?? {};
+    delete entry.enabledMcpjsonServers;
+    delete entry.disabledMcpjsonServers;
+    delete entry.enableAllProjectMcpServers;
+    // Keep the entry only if it still carries local servers; otherwise drop it.
+    if (Object.keys(entry).length > 0)
+        projects[repoRoot] = entry;
+    else
+        delete projects[repoRoot];
+    file.projects = projects;
+    try {
+        writeUserMcpConfig(file);
+        return { errors: [] };
+    }
+    catch (err) {
+        return {
+            errors: [
+                {
+                    sourcePath: mcpConfigPath(),
+                    message: `could not reset project choices (${err instanceof Error ? err.message : String(err)})`,
+                },
+            ],
+        };
+    }
+}
+/**
+ * Mutate `~/.yagni-code/mcp.json`'s per-project entry under a read-modify-write
+ * helper shared with CLI commands (add/remove at local scope).
+ */
+export function updateProjectEntry(repoRoot, mutate) {
+    const { file, errors } = readUserMcpConfig();
+    if (errors.length > 0)
+        return { errors };
+    const projects = file.projects ?? {};
+    const entry = projects[repoRoot] ?? {};
+    mutate(entry);
+    if (Object.keys(entry).length > 0)
+        projects[repoRoot] = entry;
+    else
+        delete projects[repoRoot];
+    file.projects = projects;
+    try {
+        writeUserMcpConfig(file);
+        return { errors: [] };
+    }
+    catch (err) {
+        return {
+            errors: [
+                {
+                    sourcePath: mcpConfigPath(),
+                    message: `could not persist project entry (${err instanceof Error ? err.message : String(err)})`,
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=approval.js.map