pi-profile-switch 0.3.1 → 0.4.2

package/src/switching/profile-wizard.ts

@@ -8,14 +8,9 @@
  * keeps the current value (prefill via placeholder); there is no
  * field-clearing gesture (delete + create instead). Any cancelled step
  * aborts the wizard — nothing is written.
- *
- * Create can start from a shipped preset (src/profile-presets.ts). A preset is
- * prefilled form state only: the wizard copies its complete definition into the
- * chosen catalog, and the new profile belongs to the user from then on.
  */
 
 import type { ProfileDefinition } from "../profile-catalog.ts";
-import { PROFILE_PRESETS, type ProfilePreset } from "../profile-presets.ts";
 import type { CatalogScope } from "./profile-crud.ts";
 
 export interface ProfileWizardUi {
@@ -27,8 +22,6 @@ export interface ProfileWizardResult {
 	scope: CatalogScope;
 	name: string;
 	definition: ProfileDefinition;
-	/** Name of the preset this definition was copied from, when any. */
-	preset?: string;
 }
 
 interface ExistingProfile {
@@ -45,7 +38,7 @@ function parseList(raw: string): string[] {
 }
 
 /** "provider/id[/thinkingLevel]" → ProfileModel; empty/undefined → none. */
-function parseModel(raw: string): ProfileDefinition["model"] | undefined {
+function parseModel(raw: string): { defaultProvider: string; defaultModel: string; defaultThinkingLevel?: string } | undefined {
 	const trimmed = raw.trim();
 	if (trimmed.length === 0) return undefined;
 	const [provider, id, thinkingLevel] = trimmed.split("/").map((part) => part.trim());
@@ -53,8 +46,8 @@ function parseModel(raw: string): ProfileDefinition["model"] | undefined {
 		return undefined;
 	}
 	return thinkingLevel !== undefined && thinkingLevel.length > 0
-		? { provider, id, thinkingLevel }
-		: { provider, id };
+		? { defaultProvider: provider, defaultModel: id, defaultThinkingLevel: thinkingLevel }
+		: { defaultProvider: provider, defaultModel: id };
 }
 
 async function captureDefinition(
@@ -74,8 +67,9 @@ async function captureDefinition(
 	else if (existing?.description !== undefined) definition.description = existing.description;
 
 	const listFields = [
-		["skills", "skills (comma-separated names or globs, empty = all visible)"],
-		["mcps", "MCP servers (names or globs, empty = none)"],
+		["skills", "skills (comma-separated names or globs, empty = none)"],
+		["extensions", "extensions (names or globs, empty = none)"],
+		["mcps", "mcp servers (names or globs, empty = none)"],
 		["tools", "tools (names or globs, empty = pi default set)"],
 	] as const;
 	for (const [field, prompt] of listFields) {
@@ -100,64 +94,42 @@ async function captureDefinition(
 	else if (existing?.instructions !== undefined) definition.instructions = existing.instructions;
 
 	const currentModel =
-		existing?.model !== undefined
-			? `${existing.model.provider}/${existing.model.id}${existing.model.thinkingLevel !== undefined ? `/${existing.model.thinkingLevel}` : ""}`
+		existing?.defaultProvider !== undefined && existing?.defaultModel !== undefined
+			? `${existing.defaultProvider}/${existing.defaultModel}${existing.defaultThinkingLevel !== undefined ? `/${existing.defaultThinkingLevel}` : ""}`
 			: undefined;
 	const modelRaw = await ui.input("model provider/id[/thinking] (empty = none)", currentModel);
 	if (modelRaw === undefined) return undefined;
 	const model = parseModel(modelRaw);
 	if (model !== undefined) {
-		definition.model = model;
-	} else if (existing?.model !== undefined && modelRaw.trim().length === 0) {
-		definition.model = existing.model;
+		definition.defaultProvider = model.defaultProvider;
+		definition.defaultModel = model.defaultModel;
+		if (model.defaultThinkingLevel !== undefined) definition.defaultThinkingLevel = model.defaultThinkingLevel;
+	} else if (existing?.defaultProvider !== undefined && modelRaw.trim().length === 0) {
+		definition.defaultProvider = existing.defaultProvider;
+		definition.defaultModel = existing.defaultModel;
+		if (existing.defaultThinkingLevel !== undefined) definition.defaultThinkingLevel = existing.defaultThinkingLevel;
 	}
 
 	return definition;
 }
 
-const BLANK_OPTION = "blank — start from an empty definition";
-
-/** One preset row. The caller identifies the preset by the option's INDEX, so
- *  a preset named like another row's text cannot be misread. */
-function presetOption(preset: ProfilePreset): string {
-	const hint = preset.definition.description ?? preset.definition.label;
-	return hint !== undefined ? `${preset.name} — ${hint}` : preset.name;
-}
-
-/** Create: scope, optional preset, name, then fields. */
+/** Create: scope first (project only when trusted), then name, then fields. */
 export async function runProfileCreateWizard(
 	ui: ProfileWizardUi,
-	input: { projectTrusted: boolean; presets?: readonly ProfilePreset[] },
+	input: { projectTrusted: boolean },
 ): Promise<ProfileWizardResult | undefined> {
 	const scopeOptions = input.projectTrusted ? ["global", "project"] : ["global"];
 	// A single available scope needs no dialog.
 	const scope = scopeOptions.length === 1 ? scopeOptions[0] : await ui.select("write to which catalog?", scopeOptions);
 	if (scope === undefined) return undefined;
 
-	const presets = input.presets ?? PROFILE_PRESETS;
-	let preset: ProfilePreset | undefined;
-	if (presets.length > 0) {
-		const options = [BLANK_OPTION, ...presets.map(presetOption)];
-		const chosen = await ui.select("start from which preset?", options);
-		if (chosen === undefined) return undefined;
-		preset = presets[options.indexOf(chosen) - 1];
-	}
-
-	// An empty answer takes the preset's name, so Enter accepts the preset.
-	const name = await ui.input("profile name", preset?.name);
-	if (name === undefined) return undefined;
-	const resolvedName = name.trim().length > 0 ? name.trim() : preset?.name;
-	if (resolvedName === undefined) return undefined;
+	const name = await ui.input("profile name");
+	if (name === undefined || name.trim().length === 0) return undefined;
 
-	const definition = await captureDefinition(ui, preset?.definition);
+	const definition = await captureDefinition(ui);
 	if (definition === undefined) return undefined;
 
-	return {
-		scope: scope as CatalogScope,
-		name: resolvedName,
-		definition,
-		...(preset !== undefined ? { preset: preset.name } : {}),
-	};
+	return { scope: scope as CatalogScope, name: name.trim(), definition };
 }
 
 /** Edit: fields prefilled from the existing complete definition. */

package/src/switching/status.ts

@@ -1,74 +1,139 @@
 /**
- * StatusReport: the `/profile status` observability surface.
+ * StatusReport: the `/profile status` observability surface (ticket 07).
  *
- * Pure report builder: combines the ACTIVE selection (what the runtime was
- * resolved to), the stored overlay, and fresh MCP discovery. Markdown
- * formatting is the only presentation; the extension ships it via
- * `pi.sendMessage`.
+ * 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`.
+ *
+ * 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
+ * plan resolved a skill whose command name is registered from a DIFFERENT
+ * path (shadowed) or is absent (failed to load) — never blocked, always
+ * visible.
  */
 
-import type { ProfileSource } from "../profile-catalog.ts";
-import type { ResolvedSelection, UnresolvedRef } from "../profile-resolver.ts";
 import type { RuntimeOverlay } from "../runtime-state-store.ts";
-import { visibleSkillNames, type SkillsFilterOutcome } from "../skill-selection.ts";
+import type { LaunchPlanFile } from "./apply-plan.ts";
+
+export interface StatusConflict {
+	/** Command name as registered (e.g. `skill:review`). */
+	name: string;
+	/** The path the active plan resolved. */
+	expectedPath: string;
+	/** The path Pi actually registered (the winner), or "not loaded". */
+	winnerPath: string;
+}
 
 export interface StatusReport {
 	profile: string;
-	source: ProfileSource;
+	source: string;
 	overlay?: RuntimeOverlay;
-	/** The skills the model can see (all loaded skills when unfiltered). */
-	skills: {
-		filtered: boolean;
-		visible: Array<{ name: string; filePath: string }>;
-		loaded: number;
-		/** The last prompt-filter result; `no-filter` when the profile
-		 *  selects nothing. */
-		filterOutcome: SkillsFilterOutcome;
-	};
-	tools?: { active: string[]; pending: string[] };
-	mcp: { enabled: string[]; discovered: string[]; missing: string[] };
-	unresolved: { skills: UnresolvedRef[]; unmatched: string[] };
+	skills: Array<{ name: string; filePath: string }>;
+	extensions: Array<{ id: string; entry: string; origin?: string }>;
+	tools?: string[];
+	mcp: { enabled: string[]; disabled: string[]; missing: string[] };
+	/** Glob delta versus the previous activation (prefixed names). */
+	delta?: { added: string[]; removed: string[] };
+	/** Glob references that matched nothing at resolution (ADR-0006). */
+	unmatched?: string[];
+	conflicts: StatusConflict[];
+}
+
+interface RegisteredCommand {
+	name: string;
+	sourceInfo?: { path: string };
+}
+
+interface RegisteredTool {
+	name: string;
+	sourceInfo?: { path: string; source: string };
+}
+
+function currentNames(plan: LaunchPlanFile): string[] {
+	const names = [
+		...(plan.resolved?.skills ?? []).map((skill) => `skill:${skill.name}`),
+		...(plan.resolved?.extensions ?? []).map((entry) => `extension:${entry.id}`),
+		...(plan.tools ?? []).map((tool) => `tool:${tool}`),
+		...(plan.mcps ?? []).map((server) => `mcp:${server}`),
+	];
+	return names.sort();
 }
 
 export function buildStatusReport(input: {
-	selection: ResolvedSelection;
-	allSkills: Array<{ name: string; filePath: string }>;
+	plan: LaunchPlanFile;
+	overlay?: RuntimeOverlay;
 	discoveredMcpServers: string[];
-	filterOutcome?: SkillsFilterOutcome;
+	commands: RegisteredCommand[];
+	tools: RegisteredTool[];
 }): StatusReport {
-	const { selection } = input;
-	const visibleNames = visibleSkillNames(input.allSkills, selection.skills);
-	const visible =
-		visibleNames === undefined
-			? input.allSkills
-			: input.allSkills.filter((skill) => visibleNames.includes(skill.name));
+	const { plan } = input;
 
-	const enabled = selection.mcp ?? [];
+	const enabled = plan.mcps ?? [];
 	const discovered = new Set(input.discoveredMcpServers);
-	const unmatched = [
-		...selection.warnings.skillsUnmatched,
-		...selection.warnings.mcpUnmatched,
-		...selection.warnings.toolsUnmatched,
-	];
+	const mcp = {
+		enabled,
+		disabled: input.discoveredMcpServers.filter((name) => !enabled.includes(name)),
+		missing: enabled.filter((name) => !discovered.has(name)),
+	};
+
+	let delta: StatusReport["delta"];
+	if (plan.previousResolved !== undefined) {
+		const before = new Set(
+			[
+				...plan.previousResolved.skills.map((name) => `skill:${name}`),
+				...plan.previousResolved.extensions.map((id) => `extension:${id}`),
+				...(plan.previousResolved.tools ?? []).map((name) => `tool:${name}`),
+				...(plan.previousResolved.mcps ?? []).map((name) => `mcp:${name}`),
+			].sort(),
+		);
+		const after = new Set(currentNames(plan));
+		const added = [...after].filter((name) => !before.has(name));
+		const removed = [...before].filter((name) => !after.has(name));
+		if (added.length > 0 || removed.length > 0) {
+			delta = { added, removed };
+		}
+	}
+
+	const conflicts: StatusConflict[] = [];
+	for (const skill of plan.resolved?.skills ?? []) {
+		const command = input.commands.find((entry) => entry.name === `skill:${skill.name}`);
+		const winnerPath = command?.sourceInfo?.path;
+		if (winnerPath === undefined) {
+			conflicts.push({ name: `skill:${skill.name}`, expectedPath: skill.filePath, winnerPath: "not loaded" });
+		} else if (winnerPath !== skill.filePath) {
+			conflicts.push({ name: `skill:${skill.name}`, expectedPath: skill.filePath, winnerPath });
+		}
+	}
+
+	// Tool conflicts: a plan tool whose registered winner is neither a pi
+	// builtin nor a tool from one of the plan's selected extensions was
+	// shadowed by (or shadows) an unexpected source.
+	const extensionDirs = (plan.resolved?.extensions ?? []).map((entry) =>
+		entry.entry.endsWith(".ts") ? entry.entry.slice(0, entry.entry.lastIndexOf("/")) : entry.entry,
+	);
+	for (const toolName of plan.tools ?? []) {
+		const winner = input.tools.find((entry) => entry.name === toolName);
+		const info = winner?.sourceInfo;
+		if (info === undefined) continue; // unknown names are dropped by pi.setActiveTools
+		const expected = info.source === "builtin" || extensionDirs.some((dir) => info.path.startsWith(dir));
+		if (!expected) {
+			conflicts.push({ name: `tool:${toolName}`, expectedPath: "builtin or selected extension", winnerPath: info.path });
+		}
+	}
 
 	return {
-		profile: selection.name,
-		source: selection.source,
-		skills: {
-			filtered: selection.skills !== undefined,
-			visible,
-			loaded: input.allSkills.length,
-			filterOutcome: input.filterOutcome ?? (selection.skills === undefined ? "no-filter" : "filtered"),
-		},
-		...(selection.tools !== undefined
-			? { tools: { active: selection.tools, pending: selection.pendingTools } }
-			: {}),
-		mcp: {
-			enabled,
-			discovered: input.discoveredMcpServers,
-			missing: enabled.filter((name) => !discovered.has(name)),
-		},
-		unresolved: { skills: selection.warnings.skillsUnresolved, unmatched },
+		profile: plan.profile,
+		source: plan.source,
+		overlay: input.overlay,
+		skills: plan.resolved?.skills ?? [],
+		extensions: plan.resolved?.extensions ?? [],
+		...(plan.tools !== undefined ? { tools: plan.tools } : {}),
+		mcp,
+		...(delta !== undefined ? { delta } : {}),
+		...(plan.unmatched !== undefined && plan.unmatched.length > 0 ? { unmatched: plan.unmatched } : {}),
+		conflicts,
 	};
 }
 
@@ -78,36 +143,41 @@ export function formatStatusMarkdown(report: StatusReport): string {
 	if (report.overlay !== undefined) {
 		const parts = [
 			...(report.overlay.disabledSkills ?? []).map((name) => `-skill:${name}`),
-			...(report.overlay.disabledMcp ?? []).map((name) => `-mcp:${name}`),
+			...(report.overlay.disabledExtensions ?? []).map((id) => `-extension:${id}`),
+			...(report.overlay.disabledMcps ?? []).map((name) => `-mcp:${name}`),
 			...(report.overlay.tools !== undefined ? [`tools=[${report.overlay.tools.join(", ")}]`] : []),
 		];
 		lines.push(`overlay: ${parts.length > 0 ? parts.join(" ") : "(empty)"}`);
 	}
-	const skillScope = report.skills.filtered
-		? `${report.skills.visible.length} of ${report.skills.loaded} loaded`
-		: `all ${report.skills.loaded} loaded`;
-	lines.push(`skills: ${skillScope}`);
-	if (report.skills.filtered && report.skills.filterOutcome !== "filtered") {
-		lines.push(`skills filter: not applied (${report.skills.filterOutcome})`);
+	if (report.skills.length > 0) {
+		lines.push("skills:");
+		for (const skill of report.skills) {
+			lines.push(`  ${skill.name} → ${skill.filePath}`);
+		}
 	}
-	for (const skill of report.skills.visible) {
-		lines.push(`  ${skill.name} → ${skill.filePath}`);
+	if (report.extensions.length > 0) {
+		lines.push("extensions:");
+		for (const extension of report.extensions) {
+			const originTag = extension.origin !== undefined ? ` [${extension.origin}]` : "";
+			lines.push(`  ${extension.id}${originTag} → ${extension.entry}`);
+		}
 	}
 	if (report.tools !== undefined) {
-		lines.push(`tools: [${report.tools.active.join(", ")}]`);
-		if (report.tools.pending.length > 0) {
-			lines.push(`tools pending (not registered yet): [${report.tools.pending.join(", ")}]`);
-		}
+		lines.push(`tools: [${report.tools.join(", ")}]`);
 	}
 	lines.push(
-		`mcp: enabled=[${report.mcp.enabled.join(", ")}] discovered=[${report.mcp.discovered.join(", ")}] missing=[${report.mcp.missing.join(", ")}]`,
+		`mcp: enabled=[${report.mcp.enabled.join(", ")}] disabled=[${report.mcp.disabled.join(", ")}] missing=[${report.mcp.missing.join(", ")}]`,
 	);
-	for (const unresolved of report.unresolved.skills) {
-		const hint = unresolved.suggestions.length > 0 ? ` — did you mean: ${unresolved.suggestions.join(", ")}?` : "";
-		lines.push(`unresolved skill: ${unresolved.reference}${hint}`);
+	if (report.delta !== undefined) {
+		lines.push(`delta: +[${report.delta.added.join(", ")}] -[${report.delta.removed.join(", ")}]`);
+	}
+	if (report.unmatched !== undefined) {
+		lines.push(`unmatched (zero-match globs this resolution): [${report.unmatched.join(", ")}]`);
 	}
-	if (report.unresolved.unmatched.length > 0) {
-		lines.push(`zero-match globs: [${report.unresolved.unmatched.join(", ")}]`);
+	for (const conflict of report.conflicts) {
+		lines.push(
+			`conflict: ${conflict.name} — plan resolved ${conflict.expectedPath}, Pi registered ${conflict.winnerPath} (Pi first-wins load order)`,
+		);
 	}
 	return lines.join("\n");
 }

package/src/switching/switch-profile.ts

@@ -0,0 +1,219 @@
+/**
+ * SwitchProfile: the in-session switching orchestrator (ticket 05).
+ *
+ * Runs inside Pi (the extension's `/profile use` / `/profile reload`), but
+ * is written dependency-injected so unit tests never need a real Pi.
+ *
+ * Flow (`/profile use <name>`):
+ *   1. wait for the agent to be idle (Pi's native `ctx.waitForIdle()`) — a
+ *      running turn is never torn down
+ *   2. snapshot the runtime dir's settings.json + pi-profile.json in memory
+ *   3. re-resolve through the full launcher path (trust check, catalogs,
+ *      discovery, registry, model/MCP validation) against the REAL agent
+ *      dir — any failure here leaves the runtime untouched
+ *   4. rewrite the runtime files in place (the running process's
+ *      PI_CODING_AGENT_DIR cannot move) and mark the plan
+ *      `persistSelection` so the post-reload extension instance saves the
+ *      selection + rollback anchor
+ *   5. `ctx.reload()` — Pi re-reads settings from disk, re-executes
+ *      extensions, preserves the session
+ *   6. VERIFY the reload ran: interactive Pi swallows reload refusals and
+ *      errors (showError) instead of rejecting, so a resolved promise is
+ *      not proof. A real reload invalidates this extension context — the
+ *      `assertStale` probe throws iff that happened. A silent skip rolls
+ *      back exactly like a rejection: restore the snapshot, reload again.
+ *      The runtime never sits half-switched.
+ *
+ * `/profile reload` is the same path minus the `switchedFrom` marker (no
+ * change summary) and preserving however the current profile became active
+ * (transient launch selections stay transient).
+ */
+
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { resolveInitialProfile } from "../launcher/initial-profile.ts";
+import { RuntimeStateStore, type RuntimeOverlay } from "../runtime-state-store.ts";
+import { getGlobalStateDir } from "../workspace.ts";
+import { writeRuntimeFiles } from "../settings-generator.ts";
+import { readLaunchPlanFile } from "./apply-plan.ts";
+
+export class SwitchError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "SwitchError";
+	}
+}
+
+export interface SwitchDeps {
+	/** The active generated runtime dir (the running Pi's agent dir). */
+	runtimeDir: string;
+	/** The user's real agent dir (from the launch plan; trust, catalogs,
+	 *  registries, and state all live there). */
+	realAgentDir: string;
+	/** The project working directory. */
+	cwd: string;
+	/** Pi's native idle wait (ctx.waitForIdle): resolves when the current
+	 *  turn/compaction finishes. */
+	waitForIdle(): Promise<void>;
+	reload(): Promise<void>;
+	/** Throws iff this extension context has been invalidated — proof the
+	 *  reload actually re-executed extensions. Interactive Pi swallows reload
+	 *  refusals/failures instead of rejecting, so without this probe a
+	 *  skipped reload would be misreported as a successful switch. Optional
+	 *  for tests; always provided by the extension. */
+	assertStale?(): void;
+}
+
+export interface SwitchResult {
+	profile: string;
+	warnings: string[];
+}
+
+interface RuntimeSnapshot {
+	settings?: string;
+	plan?: string;
+}
+
+async function readIfExists(filePath: string): Promise<string | undefined> {
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		// Absence is expected (first launch); anything else (permissions,
+		// unreadable dir) must not silently disable rollback protection.
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+async function snapshotRuntimeFiles(runtimeDir: string): Promise<RuntimeSnapshot> {
+	return {
+		settings: await readIfExists(path.join(runtimeDir, "settings.json")),
+		plan: await readIfExists(path.join(runtimeDir, "pi-profile.json")),
+	};
+}
+
+async function restoreRuntimeFiles(runtimeDir: string, snapshot: RuntimeSnapshot): Promise<void> {
+	if (snapshot.settings !== undefined) {
+		await writeFile(path.join(runtimeDir, "settings.json"), snapshot.settings);
+	}
+	if (snapshot.plan !== undefined) {
+		await writeFile(path.join(runtimeDir, "pi-profile.json"), snapshot.plan);
+	}
+}
+
+/** Waits are delegated to Pi's native `ctx.waitForIdle()` (see SwitchDeps);
+ *  no polling loop lives here. */
+
+/** Reads the current plan file for `switchedFrom`/persistence. A missing or
+ *  malformed plan means the session is not profile-managed: switching still
+ *  works, with no prior name to report. */
+async function readCurrentPlan(runtimeDir: string): Promise<{ profile?: string; persistSelection: boolean }> {
+	const plan = await readLaunchPlanFile(runtimeDir);
+	return { profile: plan?.profile, persistSelection: plan?.persistSelection === true };
+}
+
+export async function switchProfile(
+	name: string | undefined,
+	deps: SwitchDeps,
+	options?: { reloadCurrent?: boolean; overlay?: RuntimeOverlay | null; clearOverlay?: boolean },
+): Promise<SwitchResult> {
+	const current = await readCurrentPlan(deps.runtimeDir);
+	const target = options?.reloadCurrent === true ? (current.profile ?? name) : name;
+	if (target === undefined) {
+		throw new SwitchError("no active profile to reload");
+	}
+
+	// Overlay resolution: explicit `overlay` wins (customize), explicit
+	// `null` suppresses (reset/switch), and a plain `/profile reload`
+	// re-applies the stored overlay so runtime and state never diverge.
+	let overlay = options?.overlay;
+	if (overlay === undefined && options?.reloadCurrent === true && current.profile !== undefined) {
+		const currentPlan = await readLaunchPlanFile(deps.runtimeDir);
+		if (currentPlan?.agentDir !== undefined) {
+			const stateDir = currentPlan.source === "project" ? path.join(deps.cwd, ".pi") : getGlobalStateDir(currentPlan.agentDir);
+			overlay = (await new RuntimeStateStore(stateDir).read()).overlay ?? null;
+		}
+	}
+
+	await deps.waitForIdle();
+
+	// Snapshot before resolving so the rollback target always exists.
+	const snapshot = await snapshotRuntimeFiles(deps.runtimeDir);
+
+	// Full launcher resolution: trust gate, catalogs, discovery, dependency
+	// closure, model + MCP validation. Failures here leave the runtime
+	// untouched — nothing was written yet.
+	const resolved = await resolveInitialProfile(
+		target,
+		{ agentDir: deps.realAgentDir, cwd: deps.cwd },
+		{ overlay: overlay ?? undefined },
+	);
+
+	const isSwitch = !options?.reloadCurrent && target !== current.profile;
+	// Carry the pre-switch resolved sets into the new plan for status deltas.
+	const previousPlan = await readLaunchPlanFile(deps.runtimeDir);
+	const previousResolved =
+		previousPlan?.resolved !== undefined
+			? {
+					skills: previousPlan.resolved.skills.map((skill) => skill.name),
+					extensions: previousPlan.resolved.extensions.map((entry) => entry.id),
+					...(previousPlan.tools !== undefined ? { tools: previousPlan.tools } : {}),
+					...(previousPlan.mcps !== undefined ? { mcps: previousPlan.mcps } : {}),
+				}
+			: undefined;
+	await writeRuntimeFiles(deps.runtimeDir, resolved.plan, {
+		agentDir: deps.realAgentDir,
+		discovery: resolved.discovery,
+		projectSettings: resolved.projectSettings,
+		planExtras: {
+			...(isSwitch && current.profile !== undefined ? { switchedFrom: current.profile } : {}),
+			// `/profile use` persists; `/profile reload` keeps the current
+			// profile's existing persistence (launch selections stay transient).
+			persistSelection: options?.reloadCurrent === true ? current.persistSelection : true,
+			// A switch discards the previous profile's overlay; the post-reload
+			// instance drops it from the state file. Customize/reset manage the
+			// overlay directly and never set this.
+			...(options?.clearOverlay === true ? { clearOverlay: true } : {}),
+			...(previousResolved !== undefined ? { previousResolved } : {}),
+		},
+	});
+
+	const rollback = async (cause: string): Promise<never> => {
+		// Restore the verified snapshot and reload again — the runtime must
+		// never sit half-switched. State files were not written yet (the
+		// post-reload extension instance owns them), so nothing else moved.
+		await restoreRuntimeFiles(deps.runtimeDir, snapshot);
+		try {
+			await deps.reload();
+		} catch {
+			// The restore reload failing too is reported through the original error.
+		}
+		throw new SwitchError(
+			`activation of profile "${target}" failed; restored the previous settings. Cause: ${cause}`,
+		);
+	};
+
+	try {
+		await deps.reload();
+	} catch (error) {
+		await rollback(error instanceof Error ? error.message : String(error));
+	}
+
+	// Interactive Pi reports reload refusals/failures via the UI instead of
+	// rejecting — verify the reload actually re-executed extensions (which
+	// invalidates this context) before calling the switch a success.
+	if (deps.assertStale !== undefined) {
+		let stale = false;
+		try {
+			deps.assertStale();
+		} catch {
+			stale = true;
+		}
+		if (!stale) {
+			await rollback("Pi did not run the reload (refused or failed silently)");
+		}
+	}
+
+	return { profile: resolved.plan.profile, warnings: resolved.warnings };
+}

package/src/switching/tool-references.ts

@@ -0,0 +1,40 @@
+/**
+ * Tool reference expansion against Pi's LIVE tool registry.
+ *
+ * Pre-spawn, the resolver expands tool globs against built-in names only
+ * (extension tools are unknowable before extension code runs). Post session
+ * start, the extension re-expands the raw references against
+ * `pi.getAllTools()`, which includes extension- and MCP-provided names.
+ * Literal references that match nothing are reported, not silently dropped
+ * (Pi's setActiveTools ignores unknown names).
+ */
+
+import { minimatch } from "minimatch";
+
+export interface ToolExpansion {
+	expanded: string[];
+	/** Literal references no live tool provides. */
+	droppedLiterals: string[];
+}
+
+export function expandToolReferences(references: string[], liveToolNames: string[]): ToolExpansion {
+	const live = new Set(liveToolNames);
+	const expanded = new Set<string>();
+	const droppedLiterals: string[] = [];
+	for (const reference of references) {
+		if (reference.includes("*") || reference.includes("?")) {
+			for (const name of liveToolNames) {
+				if (minimatch(name, reference)) {
+					expanded.add(name);
+				}
+			}
+			continue;
+		}
+		if (live.has(reference)) {
+			expanded.add(reference);
+		} else {
+			droppedLiterals.push(reference);
+		}
+	}
+	return { expanded: [...expanded], droppedLiterals };
+}