pi-profile-switch 0.1.0 → 0.3.0

package/src/profile-catalog.ts

@@ -7,9 +7,11 @@
  * - A profile references skills, MCP servers, and tools, and may declare
  *   instructions and a model preset. Extensions are not a profile resource:
  *   every installed extension loads natively in every profile.
- * - schemaVersion 2 is current. Version 1 files load with their per-profile
- *   `extensions` field ignored and a warning, so existing catalogs keep
- *   working without an edit.
+ * - schemaVersion 1 is the only accepted version: any other value fails
+ *   loudly instead of guessing at a shape.
+ * - Unknown fields (an `extensions` declaration left over from v0.1.0, an
+ *   inheritance key) are ignored silently; saving drops them, so a written
+ *   definition always matches the current shape.
  *
  * Invariants:
  * - The built-in `default` profile never exists in either file and cannot be
@@ -27,7 +29,7 @@ import path from "node:path";
 
 import { isRecord, readJsonFile } from "./json-file.ts";
 
-export const PROFILE_SCHEMA_VERSION = 2;
+export const PROFILE_SCHEMA_VERSION = 1;
 export const DEFAULT_PROFILE_NAME = "default";
 
 export interface ProfileModel {
@@ -62,13 +64,6 @@ export interface ResolvedProfile {
 	definition: ProfileDefinition;
 }
 
-/** One parsed catalog file: definitions plus non-fatal compatibility
- *  warnings the caller surfaces once per activation. */
-export interface CatalogDocument {
-	profiles: Map<string, ProfileDefinition>;
-	warnings: string[];
-}
-
 export class CatalogError extends Error {
 	constructor(message: string) {
 		super(message);
@@ -94,8 +89,8 @@ function readOptionalString(value: unknown, field: string, profileName: string):
 
 /** Parses one raw profile definition; exported for the write-side store
  *  (profile-catalog-store.ts) so anything written is loadable. Unknown
- *  fields are ignored by design — `extensions` is reported by
- *  parseCatalogDocument, which has the file path for the warning. */
+ *  fields are ignored by design — an `extensions` key left over from
+ *  v0.1.0 is dropped silently, exactly like any other unknown key. */
 export function parseProfileDefinition(name: string, raw: unknown): ProfileDefinition {
 	if (!isRecord(raw)) {
 		throw new CatalogError(`profile "${name}" must be an object`);
@@ -123,22 +118,16 @@ export function parseProfileDefinition(name: string, raw: unknown): ProfileDefin
 
 /** Parses one catalog document. Missing files are handled by the caller;
  *  this function sees only parsed JSON. */
-export function parseCatalogDocument(value: unknown, filePath: string): CatalogDocument {
+export function parseCatalogDocument(value: unknown, filePath: string): Map<string, ProfileDefinition> {
 	if (!isRecord(value)) {
 		throw new CatalogError(`${filePath}: catalog must be an object`);
 	}
-	const warnings: string[] = [];
 	const version = value.schemaVersion;
-	if (version !== 1 && version !== PROFILE_SCHEMA_VERSION) {
+	if (version !== PROFILE_SCHEMA_VERSION) {
 		throw new CatalogError(
 			`${filePath}: unsupported schemaVersion ${JSON.stringify(version)} (expected ${PROFILE_SCHEMA_VERSION})`,
 		);
 	}
-	if (version === 1) {
-		warnings.push(
-			`${filePath}: schemaVersion 1 is read as version ${PROFILE_SCHEMA_VERSION}; profiles declaring "extensions" are upgraded with that field ignored`,
-		);
-	}
 	if (!isRecord(value.profiles)) {
 		throw new CatalogError(`${filePath}: "profiles" must be an object mapping names to definitions`);
 	}
@@ -149,21 +138,16 @@ export function parseCatalogDocument(value: unknown, filePath: string): CatalogD
 				`${filePath}: "${DEFAULT_PROFILE_NAME}" is built in and must not be defined in the catalog`,
 			);
 		}
-		if (isRecord(raw) && raw.extensions !== undefined) {
-			warnings.push(
-				`${filePath}: profile "${name}" declares "extensions"; extensions are always loaded natively (ADR-0007) and the field is ignored — manage extensions with pi install`,
-			);
-		}
 		profiles.set(name, parseProfileDefinition(name, raw));
 	}
-	return { profiles, warnings };
+	return profiles;
 }
 
 /** Reads one catalog file; missing → empty map, malformed → CatalogError. */
-async function loadCatalogFile(catalogPath: string): Promise<CatalogDocument> {
+async function loadCatalogFile(catalogPath: string): Promise<Map<string, ProfileDefinition>> {
 	const result = await readJsonFile(catalogPath);
 	if (!result.ok) {
-		if (result.reason === "missing") return { profiles: new Map(), warnings: [] };
+		if (result.reason === "missing") return new Map();
 		throw new CatalogError(`invalid JSON in ${catalogPath}`);
 	}
 	return parseCatalogDocument(result.value, catalogPath);
@@ -171,17 +155,9 @@ async function loadCatalogFile(catalogPath: string): Promise<CatalogDocument> {
 
 export class ProfileCatalog {
 	readonly #profiles: ReadonlyMap<string, CatalogEntry>;
-	readonly #warnings: readonly string[];
 
-	private constructor(profiles: ReadonlyMap<string, CatalogEntry>, warnings: readonly string[]) {
+	private constructor(profiles: ReadonlyMap<string, CatalogEntry>) {
 		this.#profiles = profiles;
-		this.#warnings = warnings;
-	}
-
-	/** Compatibility warnings from reading the catalog files (v1 schema,
-	 *  ignored `extensions` fields). Empty for a current, well-formed pair. */
-	get warnings(): readonly string[] {
-		return this.#warnings;
 	}
 
 	/**
@@ -193,18 +169,16 @@ export class ProfileCatalog {
 	static async load(agentDir: string, options?: { projectDir?: string }): Promise<ProfileCatalog> {
 		const global = await loadCatalogFile(path.join(agentDir, "profiles.json"));
 		const profiles = new Map<string, CatalogEntry>();
-		const warnings = [...global.warnings];
-		for (const [name, definition] of global.profiles) {
+		for (const [name, definition] of global) {
 			profiles.set(name, { source: "global", definition });
 		}
 		if (options?.projectDir !== undefined) {
 			const project = await loadCatalogFile(path.join(options.projectDir, ".pi", "profiles.json"));
-			warnings.push(...project.warnings);
-			for (const [name, definition] of project.profiles) {
+			for (const [name, definition] of project) {
 				profiles.set(name, { source: "project", definition });
 			}
 		}
-		return new ProfileCatalog(profiles, warnings);
+		return new ProfileCatalog(profiles);
 	}
 
 	/** Resolves a profile by name. `default` always resolves to the built-in

package/src/profile-presets.ts

@@ -0,0 +1,61 @@
+/**
+ * ProfilePresets: the starting points `/profile create` offers.
+ *
+ * A preset is DATA, not a profile. It never appears in `/profile list` and
+ * cannot be activated until the create wizard copies it into a user catalog,
+ * so `default` stays the only built-in profile and nothing here is ever
+ * silently in effect. Once copied, the definition belongs to the user: the
+ * preset is not tracked, and later changes to it do not reach existing
+ * profiles.
+ *
+ * Every preset must work on a machine with no skills installed, no MCP
+ * adapter, and no provider credentials:
+ *
+ * - no `mcp`: a declared MCP intent fails the whole activation when
+ *   `pi-mcp-adapter` is absent or the server was never discovered
+ *   (ADR-0002).
+ * - no `model`: `provider` and `id` are required, and an unauthenticated
+ *   model also fails the whole activation.
+ * - no `skills`: a literal reference warns once the skill turns out to be
+ *   missing, and `[]` hides every skill — omitting the field keeps Pi's full
+ *   visibility.
+ * - `tools` names Pi's built-in tools only, because extension and MCP tool
+ *   names may never register, and it always contains `read`: Pi emits the
+ *   prompt's skills section only while `read` or `bash` is active.
+ * - `instructions` states behavior, never a capability name, and stays
+ *   short: Pi appends it to the system prompt on every turn.
+ *
+ * `test/profile-presets.test.ts` enforces every rule above, asserts
+ * `examples/profiles.json` is exactly this catalog, and asserts each preset
+ * appears verbatim in `examples/profiles.example.json`.
+ */
+
+import type { ProfileDefinition } from "./profile-catalog.ts";
+
+export interface ProfilePreset {
+	/** Catalog key the create wizard offers as the new profile's name. */
+	name: string;
+	definition: ProfileDefinition;
+}
+
+/** The read-only behavior contract: describe, do not mutate. */
+const READ_ONLY_INSTRUCTIONS = [
+	"Read-only session: inspect and report; never create, edit, rename, or delete files.",
+	"If a change is needed, describe it in your reply instead of applying it.",
+	"Do not run commands that modify state (installs, formatters, commits, pushes, network writes).",
+	"Prefer an available skill or MCP tool when it fits the request; otherwise use the tools you have.",
+	"Ground claims in evidence: cite file:line and separate verified facts from inferences.",
+	"Reply in English.",
+].join("\n");
+
+export const PROFILE_PRESETS: readonly ProfilePreset[] = [
+	{
+		name: "read-only",
+		definition: {
+			label: "Read-only",
+			description: "Read-only session; no skills or MCP servers assumed — add your own.",
+			tools: ["read", "grep", "find", "ls"],
+			instructions: READ_ONLY_INSTRUCTIONS,
+		},
+	},
+];

package/src/profile-resolver.ts

@@ -23,7 +23,11 @@ import type { RuntimeOverlay } from "./runtime-state-store.ts";
 
 /** The live resource view a resolution runs against. */
 export interface LiveResources {
-	skills: Array<{ name: string; filePath: string }>;
+	/** Pi's loaded skills. `undefined` when the caller cannot read them yet:
+	 *  Pi exposes the list on command contexts and on the `before_agent_start`
+	 *  event, not in `session_start`'s event context. An unknown set leaves the
+	 *  visibility filter intact and reports nothing (see `skillWarnings`). */
+	skills?: Array<{ name: string; filePath: string }>;
 	toolNames: string[];
 	/** MCP adapter state: presence plus discovered server names. */
 	mcp: { adapterPresent: boolean; servers: string[] };
@@ -77,17 +81,21 @@ export class SelectionError extends Error {
 	}
 }
 
-function resolveSkills(
-	declared: string[] | undefined,
-	disabled: string[],
+/** Existence warnings for skill references against one live skill set.
+ *  `undefined` means "not known yet" — Pi's skill list is only readable from
+ *  a command context or from the `before_agent_start` event, so a startup
+ *  activation reports nothing instead of every reference as unloaded. The
+ *  same function re-checks the references on the first turn, when the list
+ *  (including skills contributed through `resources_discover`) is complete. */
+export function skillWarnings(
+	refs: readonly string[],
 	live: LiveResources["skills"],
-): { filter?: SkillsFilter; warning: Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched"> } {
-	const refs = declared ?? [];
-	const warning = { skillsUnresolved: [] as UnresolvedRef[], skillsUnmatched: [] as string[] };
-	if (declared === undefined) {
-		// The profile declares nothing; an overlay may still hide skills.
-		return { ...(disabled.length > 0 ? { filter: { refs: "all" as const, disabled } } : {}), warning };
-	}
+): Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched"> {
+	const warning: Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched"> = {
+		skillsUnresolved: [],
+		skillsUnmatched: [],
+	};
+	if (live === undefined) return warning;
 	for (const ref of refs) {
 		const hits = live.filter((skill) => matchesReference(ref, skill.name));
 		if (hits.length === 0) {
@@ -95,7 +103,22 @@ function resolveSkills(
 			else warning.skillsUnresolved.push({ reference: ref, suggestions: suggestNames(ref, live.map((s) => s.name)) });
 		}
 	}
-	return { filter: { refs, disabled }, warning };
+	return warning;
+}
+
+function resolveSkills(
+	declared: string[] | undefined,
+	disabled: string[],
+	live: LiveResources["skills"],
+): { filter?: SkillsFilter; warning: Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched"> } {
+	if (declared === undefined) {
+		// The profile declares nothing; an overlay may still hide skills.
+		return {
+			...(disabled.length > 0 ? { filter: { refs: "all" as const, disabled } } : {}),
+			warning: skillWarnings([], live),
+		};
+	}
+	return { filter: { refs: declared, disabled }, warning: skillWarnings(declared, live) };
 }
 
 function resolveMcp(
@@ -211,23 +234,33 @@ export function resolveSelection(input: {
 	return selection;
 }
 
-/** User-facing warning lines for one resolved selection. */
-export function formatSelectionWarnings(selection: ResolvedSelection): string[] {
+/** User-facing lines for one set of skill warnings. Shared by the startup
+ *  report and the first-turn re-check, so both read identically. */
+export function formatSkillWarnings(
+	profile: string,
+	warning: Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched">,
+): string[] {
 	const lines: string[] = [];
-	for (const unresolved of selection.warnings.skillsUnresolved) {
+	for (const unresolved of warning.skillsUnresolved) {
 		const hint =
 			unresolved.suggestions.length > 0
 				? ` — did you mean: ${unresolved.suggestions.map((name) => JSON.stringify(name)).join(", ")}?`
 				: "";
 		lines.push(
-			`profile "${selection.name}": skill ${JSON.stringify(unresolved.reference)} is not loaded in this session${hint}`,
+			`profile "${profile}": skill ${JSON.stringify(unresolved.reference)} is not loaded in this session${hint}`,
 		);
 	}
-	if (selection.warnings.skillsUnmatched.length > 0) {
+	if (warning.skillsUnmatched.length > 0) {
 		lines.push(
-			`profile "${selection.name}": skill glob(s) ${selection.warnings.skillsUnmatched.map((ref) => JSON.stringify(ref)).join(", ")} matched nothing`,
+			`profile "${profile}": skill glob(s) ${warning.skillsUnmatched.map((ref) => JSON.stringify(ref)).join(", ")} matched nothing`,
 		);
 	}
+	return lines;
+}
+
+/** User-facing warning lines for one resolved selection. */
+export function formatSelectionWarnings(selection: ResolvedSelection): string[] {
+	const lines: string[] = formatSkillWarnings(selection.name, selection.warnings);
 	if (selection.warnings.mcpUnmatched.length > 0) {
 		lines.push(
 			`profile "${selection.name}": MCP glob(s) ${selection.warnings.mcpUnmatched.map((ref) => JSON.stringify(ref)).join(", ")} matched nothing`,

package/src/runtime-state-store.ts

@@ -42,6 +42,19 @@ export interface RuntimeOverlay {
 	tools?: string[];
 }
 
+/** True when an overlay actually narrows the active profile. An overlay whose
+ *  fields were all removed again (`/profile customize enable …`) is not a
+ *  difference from the catalog, and `parseOverlay` drops an empty overlay on
+ *  read. A `tools: []` override is a difference: it selects no tools. */
+export function overlayNarrows(overlay: RuntimeOverlay | undefined): boolean {
+	if (overlay === undefined) return false;
+	return (
+		(overlay.disabledSkills?.length ?? 0) > 0 ||
+		(overlay.disabledMcp?.length ?? 0) > 0 ||
+		overlay.tools !== undefined
+	);
+}
+
 function parseOverlay(value: unknown): RuntimeOverlay | undefined {
 	if (!isRecord(value)) return undefined;
 	const overlay: RuntimeOverlay = {};

package/src/startup-mcp-scope.ts

@@ -0,0 +1,262 @@
+/**
+ * StartupMcpScope: derives the profile-scoped MCP overlay at times when a
+ * full activation has not (or may not yet) run.
+ *
+ * Two callers:
+ * - The extension-load pass: must be synchronous and must finish before
+ *   pi-mcp-adapter reads its config at `session_start` (and, for eager
+ *   servers, at its own load time). Pi applies CLI flag values only AFTER
+ *   extension loading, so the `--profile` / `--mcp-config` values are read
+ *   from argv here; trust is mirrored from Pi's own resolution order
+ *   (`hasTrustRequiringProjectResources` → stored decision →
+ *   `defaultProjectTrust`; an interactive first-time prompt is not yet
+ *   answerable at load time and counts as untrusted).
+ * - The switch pass: the caller already has the resolved allowlist, so the
+ *   overlay is derived from it directly.
+ *
+ * The generated file IS the adapter's Pi-global slot (`<agentDir>/mcp.json`):
+ * flag injection is impossible (Pi rejects two extensions registering the
+ * same flag), so the mechanism works with the slot the adapter already reads.
+ * The user's own Pi-global servers live in the sidecar `mcp.user.json`.
+ *
+ * Failure policy: a profile name that cannot be resolved (missing, malformed
+ * catalog, unknown name) falls back to "no filtering" — the generated overlay
+ * then changes nothing, and the real problem is reported loudly by the
+ * activation that runs right after. A foreign `--mcp-config` disables
+ * management entirely: the user's explicit file is never overwritten.
+ */
+
+import { hasTrustRequiringProjectResources, ProjectTrustStore } from "@earendil-works/pi-coding-agent";
+import path from "node:path";
+
+import { isRecord, readJsonFileSync } from "./json-file.ts";
+import { readAdapterOtherServerNamesSync, readMcpDocumentSync } from "./mcp-config.ts";
+import {
+	buildMcpOverlay,
+	isDisabledStub,
+	isGeneratedOverlay,
+	MCP_GENERATED_MARKER,
+	mcpSlotPath,
+	mcpSourcePath,
+	resolveAllowedServers,
+	serializeMcpOverlay,
+} from "./mcp-overlay.ts";
+import { writeMcpOverlayIfChangedSync } from "./mcp-overlay-file.ts";
+import { DEFAULT_PROFILE_NAME, parseCatalogDocument, type ProfileDefinition } from "./profile-catalog.ts";
+
+/** Reads `--<name> <value>` / `--<name>=<value>` without Pi's parser (Pi
+ *  applies extension flag values only after extension loading). Last wins. */
+export function readFlagFromArgv(argv: readonly string[], name: string): string | undefined {
+	const long = `--${name}`;
+	let value: string | undefined;
+	for (let index = 0; index < argv.length; index++) {
+		const token = argv[index] ?? "";
+		if (token === long) {
+			const next = argv[index + 1];
+			if (next !== undefined && !next.startsWith("--")) value = next;
+			continue;
+		}
+		if (token.startsWith(`${long}=`)) {
+			const inline = token.slice(long.length + 1);
+			if (inline.length > 0) value = inline;
+		}
+	}
+	return value;
+}
+
+/** True when Pi itself would consider `cwd` trusted right now. Mirrors
+ *  `resolveProjectTrusted` minus extension votes and the interactive prompt. */
+export function resolveProjectTrustedSync(agentDir: string, cwd: string): boolean {
+	if (!hasTrustRequiringProjectResources(cwd)) return true;
+	const stored = new ProjectTrustStore(agentDir).get(cwd);
+	if (stored !== null) return stored;
+	return readDefaultProjectTrustSync(agentDir) === "always";
+}
+
+/** The saved selection for this run: project state wins over global state
+ *  (project state only when trusted), then the built-in default. */
+export function resolveStartupProfileNameSync(input: {
+	agentDir: string;
+	cwd: string;
+	projectTrusted: boolean;
+	argv: readonly string[];
+}): string {
+	const requested = readFlagFromArgv(input.argv, "profile");
+	if (requested !== undefined && requested.length > 0) return requested;
+	const project = input.projectTrusted
+		? readActiveProfile(path.join(input.cwd, ".pi", "pi-profile-state.json"))
+		: undefined;
+	return project ?? readActiveProfile(path.join(input.agentDir, "pi-profile-state.json")) ?? DEFAULT_PROFILE_NAME;
+}
+
+export interface McpOverlaySyncInput {
+	agentDir: string;
+	cwd: string;
+	/** Pi's trust decision. Omitted on the extension-load pass, where Pi has
+	 *  not resolved trust yet; the module mirrors Pi's own order then. */
+	projectTrusted?: boolean;
+	/** Effective `--mcp-config`; undefined means the managed overlay path. */
+	overridePath?: string;
+	/** The command line, for the load pass (Pi applies flag values only after
+	 *  extension loading, so `--profile` is read from here). */
+	argv?: readonly string[];
+	homeDir?: string;
+}
+
+export interface McpOverlaySyncResult {
+	overlayPath: string;
+	/** False when a foreign `--mcp-config` owns the adapter's slot. */
+	managed: boolean;
+	changed: boolean;
+	/** Set when nothing was written; the caller surfaces it as a warning. */
+	error?: string;
+}
+
+/** Load-time (and `session_start` re-check) pass. `profileName` short-circuits
+ *  the state lookup when the caller already activated a profile. */
+export function syncStartupMcpOverlay(
+	input: McpOverlaySyncInput & { profileName?: string; mcpRefs?: readonly string[] | undefined },
+): McpOverlaySyncResult {
+	try {
+		const trust = input.projectTrusted;
+		const profileName =
+			input.profileName ??
+			resolveStartupProfileNameSync({
+				agentDir: input.agentDir,
+				cwd: input.cwd,
+				projectTrusted: trust ?? resolveProjectTrustedSync(input.agentDir, input.cwd),
+				argv: input.argv ?? [],
+			});
+		const refs = input.mcpRefs ?? readProfileMcpRefsSync({ ...input, name: profileName, trust });
+		return writeOverlayForRefs({ ...input, refs });
+	} catch (error) {
+		return {
+			overlayPath: mcpSlotPath(input.agentDir),
+			managed: true,
+			changed: false,
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+/** Switch pass: the caller already resolved the allowlist. */
+export function syncMcpOverlayForSelection(
+	input: McpOverlaySyncInput & { allowed: readonly string[] | "all" },
+): McpOverlaySyncResult {
+	try {
+		return writeOverlay({ ...input, refs: input.allowed });
+	} catch (error) {
+		return {
+			overlayPath: mcpSlotPath(input.agentDir),
+			managed: true,
+			changed: false,
+			error: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+function writeOverlayForRefs(input: McpOverlaySyncInput & { refs: readonly string[] | undefined | "unknown" }): McpOverlaySyncResult {
+	// An unresolvable profile is not an error here: the generated overlay
+	// then filters nothing and the activation reports the real problem.
+	const refs = input.refs === "unknown" ? undefined : input.refs;
+	return writeOverlay({ ...input, refs });
+}
+
+function writeOverlay(input: McpOverlaySyncInput & { refs: readonly string[] | undefined | "all" }): McpOverlaySyncResult {
+	const overlayPath = mcpSlotPath(input.agentDir);
+	if (input.overridePath !== undefined && path.resolve(input.overridePath) !== overlayPath) {
+		return { overlayPath, managed: false, changed: false };
+	}
+	const projectTrusted = input.projectTrusted ?? resolveProjectTrustedSync(input.agentDir, input.cwd);
+	const discovery = {
+		agentDir: input.agentDir,
+		cwd: input.cwd,
+		projectTrusted,
+		...(input.homeDir === undefined ? {} : { homeDir: input.homeDir }),
+	};
+	// The slot is ours; a slot written by hand is adopted into the sidecar
+	// before the first overwrite, so a user's Pi-global servers survive.
+	const sourcePath = mcpSourcePath(input.agentDir);
+	adoptHandWrittenSlotSync(overlayPath, sourcePath);
+	const sourceDocument = readMcpDocumentSync(sourcePath);
+	const sourceNames = isRecord(sourceDocument?.mcpServers) ? Object.keys(sourceDocument.mcpServers) : [];
+	const otherNames = readAdapterOtherServerNamesSync(discovery);
+	const allowed =
+		input.refs === "all"
+			? "all"
+			: resolveAllowedServers(input.refs, [...new Set([...sourceNames, ...otherNames])].sort());
+	const content = serializeMcpOverlay(
+		buildMcpOverlay({
+			...(sourceDocument === undefined ? {} : { slotDocument: sourceDocument }),
+			otherServerNames: otherNames,
+			allowed,
+		}),
+	);
+	return { overlayPath, managed: true, changed: writeMcpOverlayIfChangedSync(overlayPath, content) };
+}
+
+/** A slot file without the generated marker holds the user's own Pi-global
+ *  servers (from before this package managed the slot, or from a manual
+ *  edit). Move them — plus the slot's non-server keys — into the sidecar
+ *  before the slot is overwritten. Stub entries are skipped: they describe
+ *  servers owned by the adapter's other sources. */
+function adoptHandWrittenSlotSync(slotPath: string, sourcePath: string): void {
+	const slot = readMcpDocumentSync(slotPath);
+	if (slot === undefined || isGeneratedOverlay(slot)) return;
+	const sidecar = readMcpDocumentSync(sourcePath) ?? {};
+	const sidecarServers = isRecord(sidecar.mcpServers) ? sidecar.mcpServers : {};
+	const servers: Record<string, unknown> = { ...sidecarServers };
+	const slotServers = isRecord(slot.mcpServers) ? slot.mcpServers : {};
+	for (const [name, definition] of Object.entries(slotServers)) {
+		if (isDisabledStub(definition)) continue;
+		servers[name] = definition;
+	}
+	const document: Record<string, unknown> = { ...sidecar };
+	delete document[MCP_GENERATED_MARKER];
+	for (const [key, value] of Object.entries(slot)) {
+		if (key === "mcpServers" || key === MCP_GENERATED_MARKER) continue;
+		document[key] = value;
+	}
+	document.mcpServers = Object.fromEntries(Object.entries(servers).sort(([left], [right]) => left.localeCompare(right)));
+	writeMcpOverlayIfChangedSync(sourcePath, `${JSON.stringify(document, null, 2)}\n`);
+}
+
+function readActiveProfile(statePath: string): string | undefined {
+	const result = readJsonFileSync(statePath);
+	if (!result.ok || !isRecord(result.value)) return undefined;
+	const name = result.value.activeProfile;
+	return typeof name === "string" && name.length > 0 ? name : undefined;
+}
+
+/** The profile's raw `mcp` references; `"unknown"` when the profile or its
+ *  catalog cannot be read (caller falls back to "no filtering"). */
+function readProfileMcpRefsSync(
+	input: McpOverlaySyncInput & { name: string; trust: boolean | undefined },
+): readonly string[] | undefined | "unknown" {
+	if (input.name === DEFAULT_PROFILE_NAME) return undefined;
+	const trusted = input.trust ?? resolveProjectTrustedSync(input.agentDir, input.cwd);
+	const global = readCatalogSync(path.join(input.agentDir, "profiles.json"));
+	const project = trusted
+		? readCatalogSync(path.join(input.cwd, ".pi", "profiles.json"))
+		: new Map<string, ProfileDefinition>();
+	if (global === "error" || project === "error") return "unknown";
+	const definition = project.get(input.name) ?? global.get(input.name);
+	return definition === undefined ? "unknown" : definition.mcp;
+}
+
+function readCatalogSync(filePath: string): Map<string, ProfileDefinition> | "error" {
+	const result = readJsonFileSync(filePath);
+	if (!result.ok) return result.reason === "missing" ? new Map<string, ProfileDefinition>() : "error";
+	try {
+		return parseCatalogDocument(result.value, filePath);
+	} catch {
+		return "error";
+	}
+}
+
+function readDefaultProjectTrustSync(agentDir: string): string | undefined {
+	const result = readJsonFileSync(path.join(agentDir, "settings.json"));
+	if (!result.ok || !isRecord(result.value)) return undefined;
+	const value = result.value.defaultProjectTrust;
+	return typeof value === "string" ? value : undefined;
+}

package/src/startup-selection.ts

@@ -105,10 +105,7 @@ export async function resolveStartupProfile(input: {
 	const catalog = await ProfileCatalog.load(input.agentDir, {
 		projectDir: input.projectTrusted ? input.cwd : undefined,
 	});
-	const warnings: string[] = [
-		...catalog.warnings,
-		...(await legacyRegistryWarnings(input)),
-	];
+	const warnings: string[] = await legacyRegistryWarnings(input);
 
 	if (input.requested !== undefined) {
 		if (catalog.resolve(input.requested) === undefined) {

package/src/switching/activate-profile.ts

@@ -53,7 +53,10 @@ export interface ActivationDeps {
 
 export interface ActivationResult {
 	selection: ResolvedSelection;
-	warnings: string[];
+	/** The overlay this activation applied; absent when the runtime runs the
+	 *  profile exactly as it is declared. Callers surface it (the footer badge)
+	 *  instead of re-reading the state file. */
+	overlay?: RuntimeOverlay;
 }
 
 /** Resolves a profile against the live resources without applying it.
@@ -65,7 +68,7 @@ export async function resolveProfileSelection(
 	name: string,
 	deps: Pick<ActivationDeps, "agentDir" | "cwd" | "projectTrusted" | "live" | "presetInputs">,
 	overlay?: RuntimeOverlay,
-): Promise<{ selection: ResolvedSelection; warnings: string[] }> {
+): Promise<ResolvedSelection> {
 	const catalog = await ProfileCatalog.load(deps.agentDir, {
 		projectDir: deps.projectTrusted ? deps.cwd : undefined,
 	});
@@ -76,8 +79,7 @@ export async function resolveProfileSelection(
 		);
 	}
 	const suppressTools = !deps.presetInputs.force && deps.presetInputs.explicit.tools;
-	const selection = resolveSelection({ profile, overlay, live: deps.live, suppressTools });
-	return { selection, warnings: [...catalog.warnings] };
+	return resolveSelection({ profile, overlay, live: deps.live, suppressTools });
 }
 
 /** Activates a profile: resolve, validate, optionally persist, apply. */
@@ -87,7 +89,7 @@ export async function activateProfile(
 	options?: { overlay?: RuntimeOverlay | null; persist?: boolean },
 ): Promise<ActivationResult> {
 	const overlay = options?.overlay ?? undefined;
-	const { selection, warnings } = await resolveProfileSelection(name, deps, overlay);
+	const selection = await resolveProfileSelection(name, deps, overlay);
 	const preset = decidePreset({ model: selection.model, ...deps.presetInputs });
 
 	// Validate before touching anything: the model preset is the only
@@ -109,5 +111,5 @@ export async function activateProfile(
 		throw new ActivationError(result.error ?? `profile "${name}" could not be applied`);
 	}
 
-	return { selection, warnings };
+	return { selection, ...(overlay === undefined ? {} : { overlay }) };
 }