pi-profile-switch 0.12.2 → 0.13.1

package/README.md

@@ -51,7 +51,7 @@ pi-profile-switch seeds the global `profiles/` directory with a starter **`ask`*
 }
 ```
 
-One profile can use every field at once. This example `impl` profile (`impl.json`) loads the TDD skill, the mcp-scripting skill (shipped by pi-mcp-adapter), and your internal skills; wires up two MCP servers; allows the built-in tools; restricts GitHub MCP tools while denying Linear tools; and pins the model and standing instructions:
+One profile can use every field at once. This example `impl` profile (`impl.json`) loads the TDD skill and your internal skills; wires up two MCP servers; allows the built-in tools; restricts GitHub MCP tools while denying Linear tools; and pins the model and standing instructions:
 
 ```json
 {
@@ -59,11 +59,7 @@ One profile can use every field at once. This example `impl` profile (`impl.json
   "description": "Full-powered implementation profile: every available field, pinned model",
   "skills": [
     "tdd",
-    "internal-*",
-    "mcp-scripting"
-  ],
-  "extensions": [
-    "pi-mcp-adapter"
+    "internal-*"
   ],
   "mcps": [
     "github",
@@ -95,15 +91,17 @@ One profile can use every field at once. This example `impl` profile (`impl.json
 How fields resolve:
 
 - `skills`, `extensions`, `mcps`, `tools` take names or globs (e.g. `"internal-*"`) referencing resources you already installed or configured — profiles never copy them. Installed packages and files in standard locations are discovered automatically; no registration needed.
-- `tools` expands strictly against Pi's non-MCP tool registry — built-ins and extension-provided tools, attributed by registration ownership (`sourceInfo`). Available MCP tools remain usable independently of `tools`.
-- `mcp_tools` defines per-server MCP tool filtering: keys are literal configured server names and values are literal pi-mcp-adapter selectors (original or prefixed names; either form can select the same tool). Globs are not accepted. An omitted server keeps native access to all its tools; a nonempty array allows only matched tools; an empty array (`[]`) denies all tools for that server while leaving it enabled. Unmatched selectors remain restrictive and are not diagnosed, so confirm selectors with the adapter/server before writing them.
-- A nonempty `mcp_tools` requires `pi-mcp-adapter` even when `mcps` is omitted. Existing adapter `includeTools` filters are combined only when the profile uses identical selectors or the existing filter is `"*"`; otherwise activation fails before writing runtime files. Existing `excludeTools` restrictions continue to apply.
-- **Migration note:** Former MCP references in `tools` (e.g. `mcp__*`, `<server>_*`) no longer govern MCP access. Move desired MCP tool restrictions to `mcp_tools`.
-- `mcps` references servers from your pi-mcp-adapter configuration; connection details stay in the adapter's own config.
-  - **Omitting `mcps`** leaves all discovered user-level servers at their normal adapter-defined availability.
-  - **`mcps: []` with `pi-mcp-adapter` selected** disables every discovered user-level server (shared locations are explicitly marked `disabled`; agentDir-only servers are omitted from the generated instance `mcp.json`).
-  - **`mcps: []` without `pi-mcp-adapter`** is inert: it does not read MCP configuration, change server availability, or fail because of a malformed config file.
+- `tools` expands strictly against Pi's non-MCP tool registry — built-ins and extension-contributed tools, attributed by registration ownership (`sourceInfo`). Available MCP tools remain usable independently of `tools`.
+- `mcp_tools` defines per-server MCP tool filtering: keys are literal configured server names and values are literal MCP tool names as exposed by Pi's built-in MCP extension. Globs are not accepted. An omitted server keeps native access to all its tools; a nonempty array allows only matched tools; an empty array (`[]`) denies all tools for that server while leaving it enabled. Unmatched selectors remain restrictive and are not diagnosed, so confirm selectors with the server before writing them.
+- **Migration notes:**
+  - Former MCP references in `tools` (e.g. `mcp__*`, `<server>_*`) no longer govern MCP access. Move desired MCP tool restrictions to `mcp_tools`.
+  - Prefixed selectors (e.g. `<server>_<tool>` forms used by previous MCP integrations) no longer apply; replace them with the literal tool names from Pi's built-in MCP extension.
+- `mcps` references servers from your Pi user-level MCP configuration (`~/.config/mcp/mcp.json`, `~/.agents/mcp.json`, `~/.agents/mcp/mcp.json`, and `<agentDir>/mcp.json`); connection details stay in those files.
+  - **Omitting `mcps`** leaves all discovered user-level servers at their normal availability.
+  - **`mcps: []`** disables every discovered user-level server, including agentDir-only servers; every unselected user-level server is explicitly marked `enabled: false` in the generated instance `mcp.json`. Project-level servers are never narrowed.
   - Trusted project-level MCP servers are always kept enabled and are never narrowed by `mcps`.
+  - Servers using `type: "sse"` cannot be selected; migrate them to streamable HTTP before referencing them in a profile.
+- The instance `mcp.json` is always a generated snapshot of the merged user-level configuration. In-session `pi mcp add` edits the instance copy, and the next `/profile use` or `/profile reload` overwrites it with the profile's snapshot.
 - Any field you omit keeps plain Pi behavior.
 
 The files in [`examples/`](examples/) mirror the two profiles above: `ask.json` is the seeded starter, `example.json` the full-field demo.

package/bin/pi-profile.ts

@@ -19,7 +19,7 @@ import { UnknownProfileError, resolveInitialProfile } from "../src/launcher/init
 import { untrustedProjectDiagnostic } from "../src/launcher/untrusted-project-diagnostic.ts";
 import { sweepStaleInstances } from "../src/launcher/runtime-cleanup.ts";
 import { spawnPi } from "../src/launcher/spawn.ts";
-import { McpConfigError, MissingMcpAdapterError } from "../src/mcp-config.ts";
+import { McpConfigError } from "../src/mcp-config.ts";
 import { CatalogError } from "../src/profile-catalog.ts";
 import { ActivationError } from "../src/profile-resolver.ts";
 import { ensureStarterAssets } from "../src/starter-assets.ts";
@@ -77,13 +77,13 @@ try {
 	});
 } catch (error) {
 	// Launcher input/selection failures (unknown profile, unresolvable
-	// references, missing adapter, malformed catalogs) are usage errors:
+	// references, malformed catalogs, illegal MCP config) are usage errors:
 	// exit 2. Unexpected failures: exit 1.
 	const isUsageError =
 		error instanceof UnknownProfileError ||
 		error instanceof ActivationError ||
 		error instanceof ExtensionError ||
-		error instanceof MissingMcpAdapterError ||
+
 		error instanceof McpConfigError ||
 		error instanceof CatalogError;
 	console.error(error instanceof Error ? `pi-profile: ${error.message}` : error);

package/examples/example.json

@@ -3,11 +3,7 @@
   "description": "Full-powered implementation profile: every available field, pinned model",
   "skills": [
     "tdd",
-    "internal-*",
-    "mcp-scripting"
-  ],
-  "extensions": [
-    "pi-mcp-adapter"
+    "internal-*"
   ],
   "mcps": [
     "github",
@@ -24,7 +20,7 @@
   ],
   "mcp_tools": {
     "github": [
-      "github_search",
+      "search",
       "get_issue"
     ],
     "linear": []

package/extensions/pi-profile/index.ts

@@ -227,7 +227,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 					);
 					const discoveredMcpServers = Object.keys(mcpDiscovery.servers).sort();
 					const disabledMcpServers = discoveredMcpServers.filter(
-						(server) => mcpDiscovery.servers[server]?.disabled === true,
+						(server) => mcpDiscovery.servers[server]?.enabled === false,
 					);
 					const report = buildStatusReport({
 						plan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-profile-switch",
-  "version": "0.12.2",
+  "version": "0.13.1",
   "description": "Named profiles for Pi: reference skills, extensions, MCP servers, and tools per workflow, switched without restarting. Install: npm install -g pi-profile-switch (not pi install).",
   "type": "module",
   "keywords": [
@@ -36,7 +36,6 @@
     "@earendil-works/pi-coding-agent": "*",
     "@types/node": "^24.0.0",
     "ajv": "^8.20.0",
-    "pi-mcp-adapter": "^2.38.0",
     "typescript": "^5.8.0",
     "vitest": "^3.0.0"
   },

package/skills/profile-config/SKILL.md

@@ -54,9 +54,9 @@ All fields are optional. Undeclared fields keep native Pi behavior or current st
 | `description` | `string` | Short description of the profile (e.g. `"Read-only review profile"`). |
 | `skills` | `string[]` | Skill names or globs to reference. When undeclared, available skills are not narrowed. |
 | `extensions` | `string[]` | Extension identifiers or globs to reference. When undeclared, available extensions are not narrowed. |
-| `mcps` | `string[]` | MCP server names or globs to reference. When undeclared, all discovered user-level servers keep their normal adapter availability and `mcps` adds no adapter requirement; a nonempty `mcp_tools` still requires `pi-mcp-adapter`. An explicit `mcps: []` disables every discovered user-level server when `pi-mcp-adapter` is selected, and is inert when the adapter is not selected. Project-level servers are never narrowed. |
+| `mcps` | `string[]` | MCP server names or globs to reference. When undeclared, all discovered user-level servers keep their normal availability. An explicit `mcps: []` disables every discovered user-level server. Project-level servers are never narrowed. |
 | `tools` | `string[]` | Whitelisted non-MCP tool names or globs (built-in and extension tools only). Live MCP tools remain usable independently of `tools`. When undeclared, tools are not narrowed and Pi's native tool set is kept. |
-| `mcp_tools` | `Record<string, string[]>` | Per-server MCP tool selection: literal server names mapped to literal adapter selectors (original or prefixed names; both forms may select the same tool). Globs are rejected. An omitted server allows all tools; a nonempty array allows only matches; an empty array (`[]`) denies all tools while keeping the server enabled. An empty object (`{}`) behaves like omission. Nonempty declarations require `pi-mcp-adapter`, even when `mcps` is omitted. |
+| `mcp_tools` | `Record<string, string[]>` | Per-server MCP tool selection: literal server names mapped to literal MCP tool names as exposed by Pi's built-in MCP extension. Globs are rejected. An omitted server allows all tools; a nonempty array allows only matches; an empty array (`[]`) denies all tools while keeping the server enabled. An empty object (`{}`) behaves like omission. |
 | `defaultProvider` | `string` | Default model provider (e.g. `"anthropic"`, `"openai"`). Effective only when declared together with `defaultModel`. |
 | `defaultModel` | `string` | Default model name (e.g. `"claude-sonnet-4-5"`). Effective only when declared together with `defaultProvider`. |
 | `defaultThinkingLevel` | `string` | Default thinking level; allowed values: `"off"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"`. Effective only when the model declaration holds. |
@@ -70,9 +70,6 @@ All fields are optional. Undeclared fields keep native Pi behavior or current st
   "skills": [
     "profile-config"
   ],
-  "extensions": [
-    "pi-mcp-adapter"
-  ],
   "mcps": [],
   "tools": [
     "read",
@@ -106,17 +103,17 @@ When helping the user configure a profile, check or consult the following locati
      - Absolute paths or `~/` paths.
      - Glob matching.
 3. **MCP servers**:
-   - Discovery locations: the standard configuration locations recognized by `pi-mcp-adapter` — on the global side `~/.config/mcp/mcp.json`, `~/.agents/mcp.json`, `~/.agents/mcp/mcp.json`, `<agentDir>/mcp.json`; trusted projects additionally have `<projectDir>/.mcp.json` and `<projectDir>/.pi/mcp.json`.
+   - Discovery locations: Pi's user-level MCP configuration files — on the global side `~/.config/mcp/mcp.json`, `~/.agents/mcp.json`, `~/.agents/mcp/mcp.json`, `<agentDir>/mcp.json`; trusted projects additionally have `<projectDir>/.pi/mcp.json`.
    - Reference identity: the server key names under the `mcpServers` object in those configuration files.
-   - A profile declaring nonempty `mcps` or nonempty `mcp_tools` must ensure the `pi-mcp-adapter` extension is available; omitting `mcps` does not remove the requirement for nonempty `mcp_tools`.
+   - Servers using `type: "sse"` cannot be selected; migrate them to streamable HTTP before referencing them in a profile.
 4. **Tools**:
    - Reference identity: non-MCP tool names in Pi's live tool registry.
    - Includes built-in tools (`read`, `write`, `edit`, `bash`, etc.) and extension-contributed tools.
    - MCP-owned tools are **not** controlled by `tools`; legacy references such as `"mcp__*"` or `"github_*"` in `tools` must be migrated to `mcp_tools`.
 5. **MCP Tools (`mcp_tools`)**:
-   - Reference identity: keys are literal configured MCP server names; values are literal pi-mcp-adapter selectors. Original and prefixed selectors can both match the same tool; globs are not accepted.
-   - Selectors are not checked against a live tool catalog. A selector matching no tool stays restrictive and produces no name diagnostic; verify selector forms with the adapter or MCP server before writing the profile.
-   - If the server already has nonempty `includeTools`, each requested selector must be identical to an existing literal or the existing list must include `"*"`; otherwise activation fails before runtime files are written. Existing `excludeTools` still applies.
+   - Reference identity: keys are literal configured MCP server names; values are literal MCP tool names as exposed by Pi's built-in MCP extension. Globs are not accepted.
+   - Selectors are not checked against a live tool catalog. A selector matching no tool stays restrictive and produces no name diagnostic; verify selector forms with the MCP server before writing the profile.
+   - Prefixed selectors from previous MCP integrations (e.g. `<server>_<tool>`) no longer apply; replace them with the literal tool names from Pi's built-in MCP extension.
    - Omitting a server key preserves unrestricted access to that server's tools.
    - An empty list (`[]`) denies all tools for that server while keeping the server enabled.
    - A nonempty list (e.g. `["search", "get_issue"]`) allows only those tools across direct tools, gateway proxies, and scripts.

package/src/extension-discovery.ts

@@ -35,7 +35,7 @@ export interface DiscoveredPackage {
 	 *  npm:/git:/github: prefix (and any version spec) when unreadable. */
 	name: string;
 	/** The source string exactly as configured in the user's settings
-	 *  (e.g. "npm:pi-mcp-adapter"); accepted as a reference alias. */
+	 *  (e.g. "npm:pi-web-access"); accepted as a reference alias. */
 	source: string;
 	/** Absolute install/local root of the package. */
 	root: string;

package/src/launcher/initial-profile.ts

@@ -14,7 +14,7 @@
 import path from "node:path";
 
 import { isRecord, readJsonFile } from "../json-file.ts";
-import { isAdapterExtension, loadMergedMcpServers, MissingMcpAdapterError } from "../mcp-config.ts";
+import { loadMergedMcpServers } from "../mcp-config.ts";
 import { ProfileCatalog, type ResolvedProfile } from "../profile-catalog.ts";
 import { ActivationError, defaultPlan, resolveProfile, type ActivationPlan } from "../profile-resolver.ts";
 import { resolveProjectTrust } from "../project-trust.ts";
@@ -125,7 +125,7 @@ export async function resolveInitialProfile(
 		// The default profile is normally unfiltered. With an overlay it becomes
 		// a synthetic "everything minus disabled" selection (PRD: overlays may
 		// temporarily narrow default's scope). MCP narrowing on default is
-		// rejected — the adapter's own /mcp commands own that surface natively.
+		// rejected — the default profile declares no MCP server selection.
 		const overlay = options?.overlay;
 		const narrowed =
 			overlay !== undefined &&
@@ -138,7 +138,7 @@ export async function resolveInitialProfile(
 		}
 		if ((overlay.disabledMcps?.length ?? 0) > 0) {
 			throw new ActivationError(
-				"the default profile has no MCP allowlist to narrow — use the adapter's own /mcp commands instead",
+				"the default profile has no MCP allowlist to narrow",
 			);
 		}
 		const synthetic: ResolvedProfile = {
@@ -163,15 +163,8 @@ export async function resolveInitialProfile(
 	const mcpToolsDef = (profile.definition as { mcp_tools?: Record<string, string[]> }).mcp_tools;
 	const hasMcpTools = mcpToolsDef !== undefined && Object.keys(mcpToolsDef).length > 0;
 	const declaredMcps = profile.definition.mcps;
-	const isEmptyMcps = declaredMcps !== undefined && declaredMcps.length === 0;
-	let adapterSelectedForEmptyMcps = false;
-	if (isEmptyMcps) {
-		const extSelection = await discovery.extensions.select(profile.definition.extensions ?? []);
-		adapterSelectedForEmptyMcps = extSelection.entries.some(isAdapterExtension);
-	}
 	const needsMcp = Boolean(
-		(declaredMcps?.length ?? 0) > 0 ||
-		(isEmptyMcps && adapterSelectedForEmptyMcps) ||
+		declaredMcps !== undefined ||
 		hasMcpTools ||
 		(options?.overlay?.disabledMcps?.length ?? 0) > 0,
 	);
@@ -190,15 +183,5 @@ export async function resolveInitialProfile(
 		liveToolNames: options?.liveToolNames,
 	});
 	warnings.push(...discovery.extensions.warnings(), ...unmatchedWarnings(plan));
-	if (plan.mcps !== undefined && !plan.extensions.some(isAdapterExtension)) {
-		throw new MissingMcpAdapterError(plan.profile, "mcps");
-	}
-	if (
-		plan.mcpTools !== undefined &&
-		Object.keys(plan.mcpTools).length > 0 &&
-		!plan.extensions.some(isAdapterExtension)
-	) {
-		throw new MissingMcpAdapterError(plan.profile, "mcp_tools");
-	}
 	return { plan, discovery, projectDir, projectTrusted, warnings };
 }

package/src/mcp-config.ts

@@ -1,18 +1,17 @@
 /**
- * AdapterConfigDiscovery: reads MCP server names and configurations
- * pi-mcp-adapter would discover from its standard configuration files,
- * without ever managing them.
+ * McpConfigDiscovery: reads MCP server names and configurations from the
+ * user-level sources Pi's built-in MCP extension reads, without ever
+ * managing them.
  *
  * pi-profile never stores MCP connection parameters or credentials
- * (ADR-0002); this module reads config definitions to validate references
- * before spawn and filter instance mcp.json files.
+ * (ADR-0016); this module reads config definitions to validate references
+ * before spawn and to build the instance `mcp.json` snapshot.
  *
  * Discovery scope: standard user-global configs (~/.config/mcp/mcp.json,
  * ~/.agents/mcp.json, ~/.agents/mcp/mcp.json), the Pi-global
- * `<agentDir>/mcp.json`, and, when trusted, the project's `.mcp.json` and
- * `.pi/mcp.json`. Servers defined solely in the adapter's editor-specific
- * legacy locations (~/.claude/mcp.json et al.) are invisible here unless
- * imported.
+ * `<agentDir>/mcp.json`, and, when trusted, the project's `.pi/mcp.json`
+ * (read for ownership classification only — Pi reads the file itself).
+ * The legacy project-root `.mcp.json` source is not read.
  *
  * Malformed config files fail loudly — a broken mcp.json must not silently
  * read as "no servers" and reject every reference.
@@ -40,12 +39,14 @@ export interface McpDiscoveryOptions {
 export interface MergedMcpResult {
 	servers: Record<string, Record<string, unknown>>;
 	sharedServers: Set<string>;
-	/** Servers defined in a trusted project's own config (`.mcp.json`,
-	 *  `.pi/mcp.json`). They are not the profile's to narrow. */
+	/** Servers defined in a trusted project's own `.pi/mcp.json`. They are
+	 *  not the profile's to narrow. */
 	projectServers: Set<string>;
 	/** Winning origin of each discovered server: "project" if defined or
 	 *  shadowed by project-level configuration, "user" otherwise. */
 	serverOwners: Record<string, "user" | "project">;
+	/** The merged user-level configuration object, with later sources
+	 *  overriding earlier ones per server name. */
 	baseConfig?: Record<string, unknown>;
 }
 
@@ -63,13 +64,16 @@ export interface McpConfigSource {
 }
 
 /**
- * Standard MCP configuration sources recognized by pi-mcp-adapter in precedence order:
+ * Standard MCP configuration sources for Pi's built-in MCP extension, in
+ * precedence order. Project scope is classification-only: the trusted
+ * project's `.pi/mcp.json` is read so its servers can be reported as
+ * project-owned, but Pi reads that file itself.
+ *
  * 1. ~/.config/mcp/mcp.json (user-global standard MCP)
  * 2. ~/.agents/mcp.json (user-global .agents MCP)
  * 3. ~/.agents/mcp/mcp.json (user-global .agents nested MCP)
  * 4. <agentDir>/mcp.json (Pi global override)
- * 5. <projectDir>/.mcp.json (project standard MCP, when project is trusted)
- * 6. <projectDir>/.pi/mcp.json (project Pi override, when project is trusted)
+ * 5. <projectDir>/.pi/mcp.json (project Pi override, when project is trusted)
  */
 export function getStandardMcpConfigSources(
 	agentDir: string,
@@ -84,7 +88,6 @@ export function getStandardMcpConfigSources(
 		{ path: path.join(agentDir, "mcp.json"), isShared: false, isAgentDir: true },
 	];
 	if (projectDir !== undefined) {
-		sources.push({ path: path.join(projectDir, ".mcp.json"), isShared: true, isProject: true });
 		sources.push({ path: path.join(projectDir, ".pi", "mcp.json"), isShared: false, isProject: true });
 	}
 	return sources;
@@ -116,17 +119,21 @@ export async function loadMergedMcpServers(
 		if (!isRecord(result.value)) {
 			throw new McpConfigError(`MCP config must be a JSON object: ${resolvedPath}`, resolvedPath);
 		}
-		if (source.isAgentDir) {
-			baseConfig = result.value;
+
+		if (!source.isProject) {
+			// Merge user-level base configuration: later sources override
+			// earlier ones, with the agentDir file as the final user-level
+			// source. Project sources do not participate in the snapshot.
+			baseConfig = baseConfig === undefined ? { ...result.value } : { ...baseConfig, ...result.value };
 		}
+
 		if (result.value.mcpServers === undefined) continue;
 		if (!isRecord(result.value.mcpServers)) {
 			throw new McpConfigError(`"mcpServers" must be a JSON object: ${resolvedPath}`, resolvedPath);
 		}
 		for (const [name, def] of Object.entries(result.value.mcpServers)) {
-			// The real adapter copies server entries into an ordinary {} and
-			// cannot represent "__proto__" as a discoverable server name; align
-			// discovery so inherited prototype keys are never treated as servers.
+			// Align discovery with JSON semantics: inherited prototype keys are
+			// never treated as discoverable server names.
 			if (name === "__proto__") continue;
 			if (source.isShared) {
 				sharedServers.add(name);
@@ -141,37 +148,3 @@ export async function loadMergedMcpServers(
 
 	return { servers, sharedServers, projectServers, serverOwners, baseConfig };
 }
-
-/** Server names the adapter would discover: standard global MCP configs,
- *  global agentDir config, plus the trusted project's configs. Pass `projectDir`
- *  only when the trust check passed — an untrusted project's config is never read. */
-export async function discoverAdapterServerNames(
-	agentDir: string,
-	projectDir?: string,
-	options?: McpDiscoveryOptions,
-): Promise<string[]> {
-	const { servers } = await loadMergedMcpServers(agentDir, projectDir, options);
-	return Object.keys(servers).sort();
-}
-
-export class MissingMcpAdapterError extends Error {
-	constructor(profile: string, reason: "mcps" | "mcp_tools" = "mcps") {
-		super(
-			reason === "mcp_tools"
-				? `profile "${profile}" declares MCP tools but pi-mcp-adapter is not active. ` +
-				  `Select the adapter in the profile's extensions (e.g. via its npm package) or remove the "mcp_tools" declaration.`
-				: `profile "${profile}" declares MCP servers but pi-mcp-adapter is not active. ` +
-				  `Select the adapter in the profile's extensions (e.g. via its npm package) or remove the "mcps" declaration.`,
-		);
-		this.name = "MissingMcpAdapterError";
-	}
-}
-
-/** Identifies the adapter among active extension entries by its install
- *  path containing "pi-mcp-adapter" (npm package roots and local dirs both
- *  match). Heuristic by design — activation-plan entries carry no package
- *  source string. */
-export function isAdapterExtension(entry: { entry: string }): boolean {
-	return entry.entry.includes("pi-mcp-adapter");
-}
-

package/src/profile-catalog.ts

@@ -44,7 +44,7 @@ export interface ProfileDefinition {
 	extensions?: string[];
 	mcps?: string[];
 	tools?: string[];
-	/** Literal adapter selectors (original or prefixed names); globs are rejected. */
+	/** Literal MCP tool names per server; globs are rejected. */
 	mcp_tools?: Record<string, string[]>;
 	defaultProvider?: string;
 	defaultModel?: string;
@@ -125,7 +125,7 @@ function readMcpTools(
 		for (const tool of tools) {
 			if (isGlobPattern(tool)) {
 				throw new CatalogError(
-					`${prefix}profile "${profileName}": "mcp_tools" entry "${tool}" in server "${server}" is a glob pattern; literal adapter tool selectors are required`,
+					`${prefix}profile "${profileName}": "mcp_tools" entry "${tool}" in server "${server}" is a glob pattern; literal MCP tool names are required`,
 				);
 			}
 		}

package/src/profile-resolver.ts

@@ -12,11 +12,9 @@
  *   pre-registration required.
  * - Undeclared model/thinking/instructions never enter the plan, so Pi's
  *   current state stays untouched.
- * - MCP references (`mcp`) expand against the server names the launcher
- *   discovered from pi-mcp-adapter's pi-native config files: literal misses
- *   fail loudly; globs expand to zero or more matches (consistent with
- *   skills/extensions). Adapter presence is checked separately by the
- *   launcher (ADR-0002).
+ * - MCP references (`mcps`) expand against the merged user-level MCP
+ *   configuration snapshot: literal misses fail loudly; globs expand to zero
+ *   or more matches (consistent with skills/extensions).
  * - Tool globs expand against Pi's built-in tool names for settings
  *   `defaultTools`; raw tool references are also carried into the launch
  *   plan so the in-session extension can expand them against Pi's live
@@ -28,7 +26,7 @@ import { minimatch } from "minimatch";
 
 import type { DiscoveredExtensions } from "./extension-discovery.ts";
 import { isRecord } from "./json-file.ts";
-import { isAdapterExtension, type MergedMcpResult } from "./mcp-config.ts";
+import type { MergedMcpResult } from "./mcp-config.ts";
 import type { ProfileDefinition, ProfileModel, ProfileSource, ResolvedProfile } from "./profile-catalog.ts";
 
 /** Extracts a ProfileModel from flat definition keys, if declared. */
@@ -83,11 +81,10 @@ export interface ActivationPlan {
 	 *  which Pi natively appends to the system prompt. */
 	instructions?: string;
 	/** Expanded MCP server allowlist: written by SettingsGenerator into the
-	 *  filtered instance `mcp.json` (the adapter's runtime restriction) and
-	 *  surfaced in `/profile status`; undefined when the profile declares
-	 *  no `mcps` (no restriction). */
+	 *  instance `mcp.json` snapshot and surfaced in `/profile status`;
+	 *  undefined when the profile declares no `mcps` (no restriction). */
 	mcps?: string[];
-	/** Per-server MCP tool policy: literal adapter selectors per server. */
+	/** Per-server MCP tool policy: literal tool names per server. */
 	mcpTools?: Record<string, string[]>;
 	/** Prepared in-memory instance mcp.json config; never written to pi-profile.json */
 	instanceMcpConfig?: Record<string, unknown>;
@@ -111,10 +108,11 @@ export interface ResolveInput {
 	 */
 	validateModel?: (model: ProfileModel) => Promise<string | undefined>;
 	/**
-	 * Server names discovered from pi-mcp-adapter's pi-native config files
-	 * (see mcp-config.ts). Required when the profile declares `mcp`: without
-	 * the discovered names a reference cannot be validated, so activation
-	 * fails rather than passing references through unchecked.
+	 * Server names discovered from the merged user-level MCP configuration
+	 * snapshot (see mcp-config.ts). Required when the profile declares `mcps`
+	 * or `mcp_tools`: without the discovered names a reference cannot be
+	 * validated, so activation fails rather than passing references through
+	 * unchecked.
 	 */
 	discoveredMcpServers?: string[];
 	/**
@@ -144,11 +142,10 @@ function isGlob(reference: string): boolean {
 }
 
 /** Expands overlay disable entries against the names the profile resolved.
- *  Entries are names or globs stored as written, re-expanded at every
- *  resolution with the same matcher as profile references (ADR-0009 tiering):
- *  an unmatched literal fails and identifies the entry; a zero-match glob is
- *  reported through `onZeroMatch` instead of failing. Returns the resolved
- *  names to disable. */
+ *  Entries are names or globs stored as written and
+ *  re-expanded at every resolution; unmatched literals fail and identify
+ *  the entry, zero-match globs join `unmatched` with an `overlay ` prefix.
+ *  Overlays can disable any resolved extension. */
 function expandDisableEntries(
 	entries: string[],
 	activeNames: readonly string[],
@@ -233,9 +230,6 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 	});
 
 	// Extension references resolve directly against discovered extensions.
-	// Resolve extensions before MCP so an explicitly empty `mcps` array can
-	// be distinguished from omission based on whether the profile selects the
-	// adapter (honor-empty-mcp-allowlist).
 	const selection = await extensions.select(definition.extensions ?? []);
 	for (const reference of selection.unmatched) unmatched.push(`extension:${reference}`);
 	let planExtensions: Array<{ id: string; entry: string; origin?: "package" | "local" | "path" }> = selection.entries.map(
@@ -246,23 +240,34 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 		}),
 	);
 
-	const hasAdapter = planExtensions.some((entry) => isAdapterExtension(entry));
-
 	let mcps: string[] | undefined;
 	if (definition.mcps !== undefined) {
 		if (definition.mcps.length > 0) {
 			if (input.discoveredMcpServers === undefined) {
 				throw new ActivationError(
-					`profile "${profile.name}" declares MCP servers but no adapter server discovery is available`,
+					`profile "${profile.name}" declares MCP servers but no MCP server discovery is available`,
 				);
 			}
 			mcps = expandReferences(definition.mcps, input.discoveredMcpServers, (name) => name, "MCP server", {
 				onZeroMatch: (reference) => unmatched.push(`mcp:${reference}`),
 			});
-		} else if (hasAdapter) {
+			if (input.mcpDiscovery !== undefined) {
+				const discovery = input.mcpDiscovery;
+				const projectNamed = mcps.find(
+					(name) => discovery.serverOwners[name] === "project" || discovery.projectServers.has(name),
+				);
+				if (projectNamed !== undefined) {
+					throw new ActivationError(
+						`profile "${profile.name}": cannot select project-level MCP server "${projectNamed}" (project-level servers are outside profile selection)`,
+					);
+				}
+			}
+		} else {
+			// Explicitly empty mcps: requires discovery so the empty selection
+			// disables every discovered user-level server.
 			if (input.mcpDiscovery === undefined) {
 				throw new ActivationError(
-					`profile "${profile.name}" declares MCP servers but no adapter server discovery is available`,
+					`profile "${profile.name}" declares an empty MCP server selection but no MCP server discovery is available`,
 				);
 			}
 			mcps = [];
@@ -270,11 +275,6 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 	}
 
 	// --- overlay narrowing (ticket 06) ---
-	// Overlay disable entries are names or globs stored as written and
-	// re-expanded at every resolution; unmatched literals fail and identify
-	// the entry, zero-match globs join `unmatched` with an `overlay ` prefix.
-	// Overlays can disable any resolved extension.
-	const toolReferences = definition.tools;
 	if (overlay !== undefined) {
 		if (overlay.disabledSkills !== undefined && overlay.disabledSkills.length > 0) {
 			const disabled = expandDisableEntries(
@@ -320,16 +320,9 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 
 	let mcpTools: Record<string, string[]> | undefined;
 	if (mcpToolKeys.length > 0) {
-		const hasAdapter = planExtensions.some((entry) => isAdapterExtension(entry));
-		if (!hasAdapter) {
-			throw new ActivationError(
-				`profile "${profile.name}" declares MCP tools but pi-mcp-adapter is not active. ` +
-					`Select the adapter in the profile's extensions (e.g. via its npm package) or remove the "mcp_tools" declaration.`,
-			);
-		}
 		if (input.mcpDiscovery === undefined) {
 			throw new ActivationError(
-				`profile "${profile.name}" declares MCP tools but no adapter server discovery is available`,
+				`profile "${profile.name}" declares MCP tools but no MCP server discovery is available`,
 			);
 		}
 
@@ -340,7 +333,7 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 					Object.hasOwn(mcpDiscovery.serverOwners, s) &&
 					mcpDiscovery.serverOwners[s] === "user" &&
 					!mcpDiscovery.projectServers.has(s);
-				const isEnabled = mcpDiscovery.servers[s]?.disabled !== true;
+				const isEnabled = mcpDiscovery.servers[s]?.enabled !== false;
 				const isAllowedByMcps = mcps === undefined || mcps.includes(s);
 				return isUser && isEnabled && isAllowedByMcps;
 			})
@@ -359,7 +352,7 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 				);
 			}
 			const isDisabled =
-				mcpDiscovery.servers[serverKey]?.disabled === true ||
+				mcpDiscovery.servers[serverKey]?.enabled === false ||
 				(mcps !== undefined && !mcps.includes(serverKey));
 			if (isDisabled) {
 				throw new ActivationError(`profile "${profile.name}": MCP server "${serverKey}" is disabled${candidateMsg}`);
@@ -371,6 +364,8 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 		);
 	}
 
+	const toolReferences = definition.tools;
+
 	let instanceMcpConfig: Record<string, unknown> | undefined;
 	if (input.mcpDiscovery !== undefined && (mcps !== undefined || mcpToolKeys.length > 0)) {
 		instanceMcpConfig = buildInstanceMcpConfig(profile.name, input.mcpDiscovery, mcps, mcpTools);
@@ -453,32 +448,6 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 	};
 }
 
-function computeSafeMcpToolIntersection(
-	profileName: string,
-	serverName: string,
-	requestedTools: string[],
-	existingIncludes?: string[],
-): string[] {
-	if (
-		requestedTools.length === 0 ||
-		existingIncludes === undefined ||
-		existingIncludes.length === 0 ||
-		existingIncludes.includes("*")
-	) {
-		return [...requestedTools];
-	}
-
-	const unsafeSelector = requestedTools.find((selector) => !existingIncludes.includes(selector));
-	if (unsafeSelector !== undefined) {
-		throw new ActivationError(
-			`profile "${profileName}": unsafe MCP tool filter intersection for server "${serverName}": ` +
-				`selector ${JSON.stringify(unsafeSelector)} is not an exact member of existing includeTools; ` +
-				`use identical literals or an existing "*" allowlist to prove the restriction is safe`,
-		);
-	}
-	return [...requestedTools];
-}
-
 function setOwnRecordValue<T>(record: Record<string, T>, key: string, value: T): void {
 	Object.defineProperty(record, key, { value, enumerable: true, configurable: true, writable: true });
 }
@@ -502,61 +471,42 @@ export function buildInstanceMcpConfig(
 		const originalDef = Object.hasOwn(mcpDiscovery.servers, serverName)
 			? mcpDiscovery.servers[serverName]
 			: undefined;
-		if (originalDef !== undefined) {
-			const def = { ...originalDef };
-			if (mcps !== undefined) {
-				delete def.disabled;
-			}
+		if (originalDef === undefined) continue;
 
-			if (mcpTools && Object.hasOwn(mcpTools, serverName)) {
-				if (
-					def.includeTools !== undefined &&
-					(!Array.isArray(def.includeTools) || !def.includeTools.every((t) => typeof t === "string"))
-				) {
-					throw new ActivationError(
-						`profile "${profileName}": unsafe MCP tool filter intersection for server "${serverName}": invalid existing includeTools`,
-					);
-				}
-				if (
-					def.excludeTools !== undefined &&
-					(!Array.isArray(def.excludeTools) || !def.excludeTools.every((t) => typeof t === "string"))
-				) {
-					throw new ActivationError(
-						`profile "${profileName}": unsafe MCP tool filter intersection for server "${serverName}": invalid existing excludeTools`,
-					);
-				}
+		// Project-owned servers are never materialized into the snapshot;
+		// Pi reads the trusted project's .pi/mcp.json itself.
+		const isProjectOwned =
+			mcpDiscovery.serverOwners[serverName] === "project" || mcpDiscovery.projectServers.has(serverName);
+		if (isProjectOwned) continue;
 
-				const requested = mcpTools[serverName];
-				const existingIncludes = Array.isArray(def.includeTools) ? (def.includeTools as string[]) : undefined;
-				const existingExcludes = Array.isArray(def.excludeTools) ? (def.excludeTools as string[]) : undefined;
+		// A server explicitly selected by mcps whose definition uses a
+		// transport Pi's built-in MCP extension cannot use fails activation.
+		if (mcps?.includes(serverName) === true && originalDef.type === "sse") {
+			throw new ActivationError(
+				`profile "${profileName}": selected MCP server "${serverName}" uses the legacy SSE transport, which Pi does not support; switch to the server's streamable HTTP URL or remove it from "mcps"`,
+			);
+		}
 
-				const safeTools = computeSafeMcpToolIntersection(
-					profileName,
-					serverName,
-					requested,
-					existingIncludes,
-				);
+		const def = { ...originalDef };
 
-				if (safeTools.length === 0) {
-					delete def.includeTools;
-					if (existingExcludes === undefined || !existingExcludes.includes("*")) {
-						def.excludeTools = [...(existingExcludes ?? []), "*"];
-					}
-				} else {
-					def.includeTools = safeTools;
-				}
+		if (mcpTools && Object.hasOwn(mcpTools, serverName)) {
+			// Profile policy replaces the merged toolExposure wholesale.
+			const requested = mcpTools[serverName];
+			const exposure: Record<string, string> = { "*": "hidden" };
+			for (const selector of requested) {
+				exposure[selector] = "direct";
 			}
-
-			setOwnRecordValue(filteredServers, serverName, def);
+			def.toolExposure = exposure;
 		}
+
+		setOwnRecordValue(filteredServers, serverName, def);
 	}
 
+	// Unselected user-level servers are explicitly disabled.
 	if (mcps !== undefined) {
-		for (const sharedName of mcpDiscovery.sharedServers) {
-			if (!mcps.includes(sharedName)) {
-				if (mcpDiscovery.projectServers.has(sharedName)) continue;
-				setOwnRecordValue(filteredServers, sharedName, { disabled: true });
-			}
+		for (const userName of userServers) {
+			if (mcps.includes(userName)) continue;
+			setOwnRecordValue(filteredServers, userName, { enabled: false });
 		}
 	}
 

package/src/settings-generator.ts

@@ -170,6 +170,29 @@ function homeAgentsSkillsDir(): string {
 	return path.join(process.env.HOME ?? homedir(), ".agents", "skills");
 }
 
+/** The user's own skill exclusions (`!pattern`, `-path`), carried into a
+ *  named profile's generated settings. Relative entries resolve against the
+ *  runtime dir, which mirrors the agent dir, so they pass through unchanged.
+ *  An absolute (or `~`) `-path` under the agent dir is rewritten to its
+ *  runtime mirror path: Pi matches `-` entries lexically. */
+function userSkillExclusions(userSkills: unknown, agentDir: string, runtimeDir: string): string[] {
+	if (!Array.isArray(userSkills)) return [];
+	const exclusions: string[] = [];
+	for (const entry of userSkills) {
+		if (typeof entry !== "string") continue;
+		if (entry.startsWith("!")) {
+			exclusions.push(entry);
+		} else if (entry.startsWith("-")) {
+			const target = entry.slice(1);
+			const expanded = target === "~" || target.startsWith("~/") ? path.join(process.env.HOME ?? homedir(), target.slice(1)) : target;
+			const rel = path.isAbsolute(expanded) ? path.relative(agentDir, expanded) : undefined;
+			const underAgentDir = rel !== undefined && rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+			exclusions.push(underAgentDir ? `-${path.join(runtimeDir, rel)}` : entry);
+		}
+	}
+	return exclusions;
+}
+
 function buildSelectionSettings(
 	plan: ActivationPlan,
 	userSettings: Record<string, unknown>,
@@ -213,6 +236,11 @@ function buildSelectionSettings(
 			skillEntries.push(`-${skill.filePath}`);
 		}
 	}
+	// Discovery already honored the user's own `!pattern` / `-path` skill
+	// exclusions, so the skills they hide never reach the loop above and get no
+	// `-` entry. Replacing the user's array would then drop those exclusions and
+	// let the instance's skills symlink and ~/.agents/skills reveal them.
+	skillEntries.push(...userSkillExclusions(userSettings.skills, agentDir, runtimeDir));
 	settings.skills = skillEntries;
 
 	// --- extensions ---
@@ -430,37 +458,23 @@ export async function writeRuntimeFiles(
 		await symlink(path.join(options.agentDir, "trust.json"), trustLink);
 	}
 
-	// MCP Servers generation (Ticket 04 & Separate MCP tool filtering)
-	const mcpTarget = path.join(options.agentDir, "mcp.json");
+	// MCP Servers generation: the instance mcp.json is always a generated
+	// snapshot of the merged user-level configuration; it is never a symlink
+	// or a copy of the real agentDir file (ADR-0016).
 	const mcpInstancePath = path.join(runtimeDir, "mcp.json");
-	if (plan.instanceMcpConfig !== undefined) {
-		try { await rm(mcpInstancePath); } catch {}
-		await writeFile(mcpInstancePath, JSON.stringify(plan.instanceMcpConfig, null, 2));
-	} else if (
-		plan.mcps === undefined &&
-		(plan.mcpTools === undefined || Object.keys(plan.mcpTools).length === 0)
-	) {
-		// No restrictions, symlink
-		if (await exists(mcpTarget)) {
-			try { await rm(mcpInstancePath); } catch {}
-			await symlink(mcpTarget, mcpInstancePath);
-		}
-	} else {
-		// Filter MCP servers (fallback when instanceMcpConfig is not pre-populated)
-		try { await rm(mcpInstancePath); } catch {}
-		const discovery = await loadMergedMcpServers(
-			options.agentDir,
-			options.projectDir,
-			options.homeDir !== undefined ? { homeDir: options.homeDir } : undefined,
-		);
-		const instanceMcpConfig = buildInstanceMcpConfig(
-			plan.profile,
-			discovery,
-			plan.mcps,
-			plan.mcpTools,
-		);
-		await writeFile(mcpInstancePath, JSON.stringify(instanceMcpConfig, null, 2));
-	}
+	try { await rm(mcpInstancePath); } catch {}
+	const discovery = await loadMergedMcpServers(
+		options.agentDir,
+		options.projectDir,
+		options.homeDir !== undefined ? { homeDir: options.homeDir } : undefined,
+	);
+	const instanceMcpConfig = buildInstanceMcpConfig(
+		plan.profile,
+		discovery,
+		plan.mcps,
+		plan.mcpTools,
+	);
+	await writeFile(mcpInstancePath, JSON.stringify(instanceMcpConfig, null, 2));
 
 	// Instructions generation (Ticket 04)
 	const appendSystemPath = path.join(runtimeDir, "APPEND_SYSTEM.md");

package/src/switching/apply-plan.ts

@@ -10,7 +10,7 @@
  * Steps:
  *   1. tools: re-expand the profile's raw references against Pi's LIVE
  *      non-MCP tool registry and call setActiveTools while retaining
- *      adapter-owned registrations. Settings `defaultTools` provides only
+ *      MCP-owned registrations. Settings `defaultTools` provides only
  *      the boot baseline for built-ins. Literals that no Pi tool provides
  *      are dropped with a warning — Pi silently ignores unknown names, so
  *      the warning is the only signal.
@@ -26,8 +26,8 @@
  *      for the next agent turn and is cleared from the plan file.
  *
  * Pi's reload re-executes extension modules, so no stale handler or command
- * context survives; this module is the only place post-reload state is
- * established.
+ *  context survives; this module is the only place post-reload state is
+ *  established.
  */
 
 import { readFile, writeFile } from "node:fs/promises";
@@ -90,68 +90,13 @@ export async function readLaunchPlanFile(runtimeDir: string): Promise<LaunchPlan
 	return result.value as unknown as LaunchPlanFile;
 }
 
-interface AdapterAttribution {
-	/** Exact adapter entry paths (loose adapter files). */
-	exactEntries: string[];
-	/** Verified pi-mcp-adapter npm package roots. */
-	packageRoots: string[];
-}
-
-async function resolveAdapterPackageRoot(entryPath: string): Promise<string | undefined> {
-	let current = path.resolve(entryPath);
-	while (true) {
-		const parent = path.dirname(current);
-		if (parent === current) return undefined;
-		current = parent;
-		try {
-			const manifest: unknown = JSON.parse(await readFile(path.join(current, "package.json"), "utf8"));
-			if (isRecord(manifest) && manifest.name === "pi-mcp-adapter") {
-				return current;
-			}
-		} catch {
-			// Continue walking toward the filesystem root.
-		}
-	}
-}
-
-async function getAdapterAttribution(plan: LaunchPlanFile): Promise<AdapterAttribution> {
-	const exactEntries: string[] = [];
-	const packageRoots: string[] = [];
-	for (const ext of plan.resolved?.extensions ?? []) {
-		if (ext.origin === "package") {
-			const packageName = ext.id.split(":", 1)[0]!;
-			if (packageName === "pi-mcp-adapter") {
-				const root = await resolveAdapterPackageRoot(ext.entry);
-				if (root !== undefined) {
-					packageRoots.push(root);
-				}
-			}
-		} else if (ext.id === "pi-mcp-adapter") {
-			// Loose adapter files (and plan entries without an origin marker)
-			// own only their exact entry; siblings such as
-			// "pi-mcp-adapter/linter" do not become adapter-owned.
-			exactEntries.push(ext.entry);
-		}
-	}
-	return { exactEntries, packageRoots };
-}
-
-export function isMcpOwnedTool(
-	tool: { name: string; sourceInfo?: { path?: string; source?: string } },
-	attribution?: AdapterAttribution,
-): boolean {
+export function isMcpOwnedTool(tool: {
+	name: string;
+	sourceInfo?: { path?: string; source?: string };
+}): boolean {
 	const info = tool.sourceInfo;
 	if (!info) return false;
-	if (info.source === "pi-mcp-adapter" || info.source === "mcp") return true;
-	if (typeof info.path !== "string" || attribution === undefined) return false;
-	if (attribution.exactEntries.includes(info.path)) return true;
-	for (const root of attribution.packageRoots) {
-		const rel = path.relative(root, info.path);
-		if (rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)) {
-			return true;
-		}
-	}
-	return false;
+	return info.path === "builtin:mcp";
 }
 
 /** Applies the plan carried by the runtime dir's pi-profile.json. */
@@ -173,12 +118,11 @@ export async function applyLaunchPlan(input: {
 	const hasOverlayDisables = plan.disabledTools !== undefined && plan.disabledTools.length > 0;
 	if (plan.toolReferences !== undefined || hasOverlayDisables) {
 		const allTools = surface.getAllTools();
-		const attribution = await getAdapterAttribution(plan);
 		const mcpToolNames: string[] = [];
 		const nonMcpToolNames: string[] = [];
 
 		for (const tool of allTools) {
-			if (isMcpOwnedTool(tool, attribution)) {
+			if (isMcpOwnedTool(tool)) {
 				mcpToolNames.push(tool.name);
 			} else {
 				nonMcpToolNames.push(tool.name);

package/src/switching/status.ts

@@ -2,10 +2,10 @@
  * StatusReport: the `/profile status` observability surface (ticket 07).
  *
  * Pure report builder: combines the ACTIVE launch plan (what the runtime
- * was resolved to), the stored overlay, fresh MCP adapter discovery, and
- * Pi's actual command registrations (the winner evidence for same-name
- * conflicts). Markdown formatting is the only presentation; the extension
- * ships it via `pi.sendMessage`.
+ * was resolved to), the stored overlay, fresh MCP discovery from the merged
+ * user-level snapshot, and Pi's actual command registrations (the winner
+ * evidence for same-name conflicts). Markdown formatting is the only
+ * presentation; the extension ships it via `pi.sendMessage`.
  *
  * Conflict semantics: Pi's load order is first-wins by scope/file order,
  * so the registered command IS the winner. A conflict is reported when the
@@ -73,8 +73,8 @@ export function buildStatusReport(input: {
 	overlay?: RuntimeOverlay;
 	discoveredMcpServers: string[];
 	disabledMcpServers: string[];
-	/** Project-owned server names from trust-gated MCP discovery; kept enabled
-	 *  when the profile declares a defined `mcps` selection. */
+	/** Project-owned server names from trust-gated MCP snapshot discovery;
+	 *  kept enabled when the profile declares a defined `mcps` selection. */
 	projectMcpServers?: string[];
 	commands: RegisteredCommand[];
 	tools: RegisteredTool[];
@@ -87,16 +87,16 @@ export function buildStatusReport(input: {
 	let missing: string[];
 
 	if (plan.mcps === undefined) {
-		const adapterDisabled = new Set(input.disabledMcpServers);
-		enabled = input.discoveredMcpServers.filter((name) => !adapterDisabled.has(name));
-		disabled = input.discoveredMcpServers.filter((name) => adapterDisabled.has(name));
+		const snapshotDisabled = new Set(input.disabledMcpServers);
+		enabled = input.discoveredMcpServers.filter((name) => !snapshotDisabled.has(name));
+		disabled = input.discoveredMcpServers.filter((name) => snapshotDisabled.has(name));
 		missing = [];
 	} else {
 		const projectMcpServers = new Set(input.projectMcpServers ?? []);
-		const adapterDisabled = new Set(input.disabledMcpServers);
+		const snapshotDisabled = new Set(input.disabledMcpServers);
 		const explicitMcps = new Set(plan.mcps);
 		const projectEnabled = input.discoveredMcpServers.filter(
-			(name) => projectMcpServers.has(name) && !explicitMcps.has(name) && !adapterDisabled.has(name),
+			(name) => projectMcpServers.has(name) && !explicitMcps.has(name) && !snapshotDisabled.has(name),
 		);
 		enabled = [...plan.mcps, ...projectEnabled].sort();
 		disabled = input.discoveredMcpServers.filter((name) => !enabled.includes(name));