pi-profile-switch 0.1.0 → 0.3.0

package/extensions/pi-profile-switch/index.ts

@@ -6,16 +6,20 @@ import {
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 
+import { adapterPresent } from "../../src/adapter-presence.ts";
 import { discoverAdapterServerNames } from "../../src/mcp-config.ts";
 import { probeAdapterPresence } from "../../src/mcp-coordination.ts";
 import { readSessionChoices } from "../../src/model-selection.ts";
+import { buildProfileBadge, PROFILE_STATUS_KEY, renderProfileBadge } from "../../src/profile-badge.ts";
 import type { ProfileDefinition } from "../../src/profile-catalog.ts";
 import {
 	formatSelectionWarnings,
+	formatSkillWarnings,
+	skillWarnings,
 	type LiveResources,
 	type ResolvedSelection,
 } from "../../src/profile-resolver.ts";
-import { RuntimeStateStore, stateDirFor, type RuntimeOverlay } from "../../src/runtime-state-store.ts";
+import { RuntimeStateStore, overlayNarrows, stateDirFor, type RuntimeOverlay } from "../../src/runtime-state-store.ts";
 import {
 	applySkillsFilter,
 	formatInstructionsBlock,
@@ -27,6 +31,11 @@ import {
 	registerProfileFlag,
 	resolveStartupProfile,
 } from "../../src/startup-selection.ts";
+import {
+	readFlagFromArgv,
+	syncMcpOverlayForSelection,
+	syncStartupMcpOverlay,
+} from "../../src/startup-mcp-scope.ts";
 import { retryPendingTools, type ApplySurface } from "../../src/switching/apply-profile.ts";
 import {
 	activateProfile,
@@ -69,6 +78,8 @@ import { buildStatusReport, formatStatusMarkdown } from "../../src/switching/sta
  *   instructions. Unselected skills stay loaded and `/skill:`-invocable.
  * - `/profile …` command family and `/mcp enable|disable`.
  * - Retry pending tool literals each turn until MCP/extension tools register.
+ * - Footer badge: `profile: <name>` (plus `*` for a runtime overlay) in Pi's
+ *   footer status line while a non-`default` profile is active.
  */
 
 type ContextWithOptions = ExtensionContext & { getSystemPromptOptions?: () => BuildSystemPromptOptions };
@@ -77,6 +88,21 @@ type ContextWithOptions = ExtensionContext & { getSystemPromptOptions?: () => Bu
 interface Activation {
 	selection: ResolvedSelection;
 	skillsOutcome?: SkillsFilterOutcome;
+	/** Whether the skill references were checked against Pi's loaded set.
+	 *  False after a startup activation: `session_start`'s event context
+	 *  cannot read that list, so the check moves to the first turn. */
+	skillsChecked: boolean;
+	/** The overlay this runtime was activated with, when one is in effect. */
+	overlay?: RuntimeOverlay;
+}
+
+/** Maps an activation result onto the runtime state `current` mirrors. */
+function activationOf(result: ActivationResult, skillsChecked: boolean): Activation {
+	return {
+		selection: result.selection,
+		skillsChecked,
+		...(result.overlay === undefined ? {} : { overlay: result.overlay }),
+	};
 }
 
 /** Subcommands that mutate a catalog; they need dialog-capable UI. */
@@ -95,9 +121,56 @@ const PROFILE_USAGE = [
 
 export default function piProfileExtension(pi: ExtensionAPI): void {
 	registerProfileFlag(pi);
-	const explicit = detectExplicitDeclarations(process.argv.slice(2));
+	const argv = process.argv.slice(2);
+	const explicit = detectExplicitDeclarations(argv);
+	// pi-mcp-adapter reads its config before any session event fires (and, for
+	// eager servers, at its own load time), so the startup profile's overlay
+	// is generated here, synchronously. Pi applies CLI flag values only after
+	// extension loading, hence argv.
+	const loadAgentDir = getAgentDir();
+	const adapterInstalled = adapterPresent({
+		agentDir: loadAgentDir,
+		argv,
+		probeAnswered: probeAdapterPresence(pi.events),
+	});
+	if (adapterInstalled) {
+		const requestedConfigPath = readFlagFromArgv(argv, "mcp-config");
+		syncStartupMcpOverlay({
+			agentDir: loadAgentDir,
+			cwd: process.cwd(),
+			argv,
+			...(requestedConfigPath === undefined ? {} : { overridePath: requestedConfigPath }),
+		});
+	}
 	let current: Activation | undefined;
 	let filterWarningShown = false;
+	/** The last badge written to the footer, so a refresh only talks to Pi
+	 *  when the rendering actually changed. */
+	let badgeText: string | undefined;
+
+	/** The only writer of `current`'s profile identity (`selection.name` and
+	 *  `overlay`) and of the footer badge. Both mirror the selection this
+	 *  runtime applied, so a failed activation (which throws before reaching
+	 *  here) never claims to be active. The per-turn updates (`pendingTools`,
+	 *  `skillsOutcome`) leave the identity and the badge untouched. */
+	function setCurrent(ctx: ExtensionContext, next: Activation | undefined): void {
+		current = next;
+		refreshBadge(ctx);
+	}
+
+	/** Re-renders the badge from `current`. `default` and an unapplied profile
+	 *  render no badge, which removes Pi's footer status line entirely. */
+	function refreshBadge(ctx: ExtensionContext): void {
+		if (!ctx.hasUI) return;
+		const badge =
+			current === undefined
+				? undefined
+				: buildProfileBadge(current.selection.name, { overlay: overlayNarrows(current.overlay) });
+		const text = badge === undefined ? undefined : renderProfileBadge(badge, ctx.ui.theme);
+		if (text === badgeText) return;
+		badgeText = text;
+		ctx.ui.setStatus(PROFILE_STATUS_KEY, text);
+	}
 
 	const surface = (ctx: ExtensionContext): ApplySurface => ({
 		getAllTools: () => pi.getAllTools(),
@@ -120,8 +193,10 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 	}
 
 	async function loadLive(ctx: ExtensionContext, projectTrusted: boolean): Promise<LiveResources> {
+		// Only command contexts expose the system-prompt options; the
+		// `session_start` event context has no accessor, so the loaded skills
+		// stay unknown there and their existence check moves to the first turn.
 		const options = (ctx as ContextWithOptions).getSystemPromptOptions?.();
-		const skills = (options?.skills ?? []).map((skill) => ({ name: skill.name, filePath: skill.filePath }));
 		const adapterPresent = probeAdapterPresence(pi.events);
 		let servers: string[] = [];
 		if (adapterPresent) {
@@ -131,7 +206,13 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 				notify(ctx, error instanceof Error ? error.message : String(error), "warning");
 			}
 		}
-		return { skills, toolNames: pi.getAllTools().map((tool) => tool.name), mcp: { adapterPresent, servers } };
+		return {
+			...(options?.skills === undefined
+				? {}
+				: { skills: options.skills.map((skill) => ({ name: skill.name, filePath: skill.filePath })) }),
+			toolNames: pi.getAllTools().map((tool) => tool.name),
+			mcp: { adapterPresent, servers },
+		};
 	}
 
 	/** Builds the dependencies for one activation. `force` marks an explicit
@@ -162,20 +243,17 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 			overlay: options?.overlay ?? null,
 			persist: options?.persist ?? true,
 		});
-		current = { selection: result.selection };
-		reportWarnings(ctx, result.warnings);
+		setCurrent(ctx, activationOf(result, deps.live.skills !== undefined));
 		reportWarnings(ctx, formatSelectionWarnings(result.selection));
 		return result;
 	}
 
 	async function profileEntries(ctx: ExtensionContext): Promise<ProfileListEntry[]> {
-		const { entries, warnings } = await listProfiles({
+		return listProfiles({
 			realAgentDir: getAgentDir(),
 			cwd: ctx.cwd,
 			projectTrusted: ctx.isProjectTrusted(),
 		});
-		reportWarnings(ctx, warnings);
-		return entries;
 	}
 
 	function sendListMessage(entries: ProfileListEntry[]): void {
@@ -187,6 +265,75 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 		});
 	}
 
+	/** `session_start` re-check. The load-time pass cannot know an interactive
+	 *  trust answer, and the adapter has already read its config by now — so a
+	 *  difference is written for the next reload and reported instead. */
+	function reportMcpOverlayState(
+		ctx: ExtensionContext,
+		profileName: string,
+		selection: ResolvedSelection,
+		input: { agentDir: string; cwd: string; projectTrusted: boolean },
+	): void {
+		const configOverride = readFlagFromArgv(argv, "mcp-config");
+		const sync = syncStartupMcpOverlay({
+			agentDir: input.agentDir,
+			cwd: input.cwd,
+			projectTrusted: input.projectTrusted,
+			profileName,
+			argv,
+			...(configOverride === undefined ? {} : { overridePath: configOverride }),
+		});
+		if (sync.error !== undefined) {
+			notify(ctx, `pi-profile-switch: MCP overlay unavailable — ${sync.error}`, "warning");
+			return;
+		}
+		if (!sync.managed) {
+			if (selection.mcp !== undefined) {
+				notify(
+					ctx,
+					`pi-profile-switch: --mcp-config points at another file — profile "${profileName}" cannot filter MCP servers`,
+					"warning",
+				);
+			}
+			return;
+		}
+		if (!sync.changed) return;
+		notify(ctx, `pi-profile-switch: MCP config updated for profile "${profileName}" — run /reload to apply`, "warning");
+	}
+
+	/** Repoints the adapter at the overlay for a just-activated selection and
+	 *  rebuilds the runtime when the MCP surface actually moved. Must be the
+	 *  caller's LAST use of `ctx`: `reload()` invalidates the old context. */
+	async function reloadForMcpOverlay(ctx: ExtensionCommandContext, selection: ResolvedSelection): Promise<void> {
+		if (!adapterInstalled) return;
+		const configOverride = readFlagFromArgv(argv, "mcp-config");
+		const sync = syncMcpOverlayForSelection({
+			agentDir: getAgentDir(),
+			cwd: ctx.cwd,
+			projectTrusted: ctx.isProjectTrusted(),
+			allowed: selection.mcp === undefined ? "all" : selection.mcp,
+			...(configOverride === undefined ? {} : { overridePath: configOverride }),
+		});
+		if (sync.error !== undefined) {
+			notify(ctx, `pi-profile-switch: MCP overlay not updated — ${sync.error}`, "warning");
+			return;
+		}
+		if (!sync.managed) {
+			if (selection.mcp !== undefined) {
+				notify(
+					ctx,
+					`pi-profile-switch: --mcp-config points at another file — profile "${selection.name}" cannot filter MCP servers`,
+					"warning",
+				);
+			}
+			return;
+		}
+		if (!sync.changed) return;
+		notify(ctx, `profile "${selection.name}": MCP servers updated — reloading runtime`, "info");
+		await ctx.waitForIdle();
+		await ctx.reload();
+	}
+
 	/** Bare `/profile`: the interactive picker, with a list fallback for
 	 *  modes without dialogs. */
 	async function runPicker(ctx: ExtensionCommandContext, entries: ProfileListEntry[]): Promise<void> {
@@ -206,6 +353,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 		if (chosen === undefined || chosen.name === current?.selection.name) return;
 		const result = await activate(ctx, chosen.name, { force: true, overlay: null, persist: true });
 		notify(ctx, `profile active: ${result.selection.name}`, "info");
+		await reloadForMcpOverlay(ctx, result.selection);
 	}
 
 	/** `/profile create|duplicate|edit|delete`: TUI-only catalog CRUD. */
@@ -219,7 +367,12 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 			const wizard = await runProfileCreateWizard(ctx.ui, { projectTrusted: scopeInput.projectTrusted });
 			if (wizard === undefined) return;
 			await createProfile(scopeInput, wizard.scope, wizard.name, wizard.definition);
-			notify(ctx, `created profile "${wizard.name}" (${wizard.scope}) — activate with /profile use ${wizard.name}`, "info");
+			const origin = wizard.preset !== undefined ? ` from preset "${wizard.preset}"` : "";
+			notify(
+				ctx,
+				`created profile "${wizard.name}" (${wizard.scope})${origin} — activate with /profile use ${wizard.name}`,
+				"info",
+			);
 			return;
 		}
 		if (subcommand === "duplicate") {
@@ -262,8 +415,9 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 			if (wizard === undefined) return;
 			await editProfile(scopeInput, wizard.scope, wizard.name, wizard.definition);
 			if (current !== undefined && name === current.selection.name) {
-				await activate(ctx, name, { persist: true });
+				const reactivated = await activate(ctx, name, { persist: true });
 				notify(ctx, `saved and reactivated profile "${name}"`, "info");
+				await reloadForMcpOverlay(ctx, reactivated.selection);
 			} else {
 				notify(ctx, `saved profile "${name}" (inactive — runtime untouched)`, "info");
 			}
@@ -301,13 +455,14 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 		if (isActive) {
 			const result = await activate(ctx, replacement ?? name, { force: replacement !== undefined, persist: true });
 			notify(ctx, `deleted "${name}" (${scope}); profile active: ${result.selection.name}`, "info");
+			await reloadForMcpOverlay(ctx, result.selection);
 		} else {
 			notify(ctx, `deleted profile "${name}" (${scope})`, "info");
 		}
 	}
 
 	pi.on("session_start", async (_event, ctx) => {
-		current = undefined;
+		setCurrent(ctx, undefined);
 		filterWarningShown = false;
 		const agentDir = getAgentDir();
 		const projectTrusted = ctx.isProjectTrusted();
@@ -327,8 +482,15 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 		try {
 			// Startup activation never persists (a `--profile` selection is for
 			// this run only) and never applies a stored overlay.
-			await activate(ctx, startup.name, { persist: false, overlay: null });
+			const activated = await activate(ctx, startup.name, { persist: false, overlay: null });
 			reportWarnings(ctx, startup.warnings);
+			if (adapterInstalled) {
+				reportMcpOverlayState(ctx, startup.name, activated.selection, {
+					agentDir,
+					cwd: ctx.cwd,
+					projectTrusted,
+				});
+			}
 		} catch (error) {
 			notify(ctx, error instanceof Error ? error.message : String(error), "error");
 			reportWarnings(ctx, startup.warnings);
@@ -351,6 +513,39 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 				},
 			};
 		}
+		// A startup activation cannot see Pi's skill list, so its references are
+		// checked here, on the first turn that carries the complete set — by then
+		// `resources_discover` has contributed every extension's skills. The
+		// corrected warnings replace the (empty) startup ones, so `/profile
+		// status` reports the same thing the user was told.
+		if (!current.skillsChecked) {
+			const refs = current.selection.skills?.refs;
+			const corrected =
+				refs === undefined || refs === "all"
+					? undefined
+					: skillWarnings(
+							refs,
+							(event.systemPromptOptions.skills ?? []).map((skill) => ({
+								name: skill.name,
+								filePath: skill.filePath,
+							})),
+						);
+			current = {
+				...current,
+				skillsChecked: true,
+				...(corrected === undefined
+					? {}
+					: { selection: { ...current.selection, warnings: { ...current.selection.warnings, ...corrected } } }),
+			};
+			if (corrected !== undefined) {
+				reportWarnings(ctx, formatSkillWarnings(current.selection.name, corrected));
+			}
+		}
+		// Pi has no extension-visible theme-change event and footer statuses are
+		// stored as finished strings, so re-render once per turn: a `/theme`
+		// switch is picked up without waiting for the next profile change.
+		// `refreshBadge` dedupes, so an unchanged badge sends nothing.
+		refreshBadge(ctx);
 		const filtered = applySkillsFilter({
 			systemPrompt: event.systemPrompt,
 			options: event.systemPromptOptions,
@@ -408,6 +603,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 					case "use": {
 						const result = await activate(ctx, rest[0] as string, { force: true, overlay: null, persist: true });
 						notify(ctx, `profile active: ${result.selection.name}`, "info");
+						await reloadForMcpOverlay(ctx, result.selection);
 						return;
 					}
 					case "customize": {
@@ -418,8 +614,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 						const deps = await activationDeps(ctx, false);
 						const target = { profile: { name: current.selection.name, source: current.selection.source } };
 						const result = await customizeOverlay({ ...deps, ...target }, parseCustomizeArgs(rest.join(" ")));
-						current = { selection: result.selection };
-						reportWarnings(ctx, result.warnings);
+						setCurrent(ctx, activationOf(result, deps.live.skills !== undefined));
 						notify(ctx, `overlay updated: ${result.selection.name}`, "info");
 						return;
 					}
@@ -431,8 +626,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 						const deps = await activationDeps(ctx, false);
 						const target = { profile: { name: current.selection.name, source: current.selection.source } };
 						const result = await resetOverlay({ ...deps, ...target });
-						current = { selection: result.selection };
-						reportWarnings(ctx, result.warnings);
+						setCurrent(ctx, activationOf(result, deps.live.skills !== undefined));
 						notify(ctx, `overlay cleared: ${result.selection.name}`, "info");
 						return;
 					}
@@ -490,12 +684,13 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 				// catalog; the stored overlay is preserved.
 				const overlay = (await new RuntimeStateStore(stateDirFor(profile.source, { agentDir, cwd: ctx.cwd })).read())
 					.overlay;
-				await activate(ctx, profile.name, { overlay: overlay ?? null, persist: true });
+				const reactivated = await activate(ctx, profile.name, { overlay: overlay ?? null, persist: true });
 				notify(
 					ctx,
 					`${action}d MCP server "${server}" in profile "${profile.name}" (mcp: [${result.mcp.join(", ")}])`,
 					"info",
 				);
+				await reloadForMcpOverlay(ctx, reactivated.selection);
 			} catch (error) {
 				notify(ctx, error instanceof Error ? error.message : String(error), "error");
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-profile-switch",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Named profiles for Pi: skills, MCP servers, tools, model, and instructions per workflow — switched in place in the same session.",
   "type": "module",
   "keywords": [

package/schemas/profiles.schema.json

@@ -10,7 +10,8 @@
   "additionalProperties": false,
   "properties": {
     "schemaVersion": {
-      "enum": [1, 2]
+      "description": "Catalog format version. Only 1 is accepted.",
+      "const": 1
     },
     "profiles": {
       "type": "object",
@@ -43,13 +44,6 @@
           },
           "description": "Skill names or globs. Controls what the model sees in the system prompt's skills section; every loaded skill stays callable by the user through /skill:name."
         },
-        "extensions": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Deprecated (schemaVersion 1). Extensions are always loaded natively (ADR-0007); the field is ignored with a warning."
-        },
         "mcp": {
           "type": "array",
           "items": {

package/src/adapter-presence.ts

@@ -0,0 +1,75 @@
+/**
+ * AdapterPresence: a cheap, deterministic "is pi-mcp-adapter installed?"
+ * check that does not depend on extension load order.
+ *
+ * The overlay mechanism only exists to serve the adapter; when the adapter is
+ * absent the extension must not register the `mcp-config` flag default and
+ * must not write anything. Signals, in order of reliability:
+ *
+ * 1. Pi's npm package root (`<agentDir>/npm/node_modules/pi-mcp-adapter`).
+ * 2. The command line (`-e <path>` / `--extension <path>`).
+ * 3. Pi settings `packages` entries.
+ * 4. The adapter's own event-bus presence probe, when it answered during
+ *    extension loading (only reliable when the adapter loaded first).
+ *
+ * Any failure reads as "absent": a false negative only disables the overlay,
+ * while a false positive could hide the user's own Pi-global slot file.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+import { isRecord } from "./json-file.ts";
+
+const ADAPTER_PACKAGE = "pi-mcp-adapter";
+
+export interface AdapterPresenceInput {
+	agentDir: string;
+	argv: readonly string[];
+	/** Result of the adapter's event-bus probe, when the caller ran one. */
+	probeAnswered?: boolean;
+}
+
+export function adapterPresent(input: AdapterPresenceInput): boolean {
+	if (input.probeAnswered === true) return true;
+	try {
+		for (const candidate of [
+			path.join(input.agentDir, "npm", "node_modules", ADAPTER_PACKAGE),
+			path.join(input.agentDir, "node_modules", ADAPTER_PACKAGE),
+		]) {
+			if (existsSync(candidate)) return true;
+		}
+		return argvMentionsAdapter(input.argv) || settingsListAdapter(input.agentDir);
+	} catch {
+		return false;
+	}
+}
+
+function argvMentionsAdapter(argv: readonly string[]): boolean {
+	for (let index = 0; index < argv.length; index++) {
+		const token = argv[index] ?? "";
+		if (token.includes(ADAPTER_PACKAGE)) return true;
+		if ((token === "-e" || token === "--extension") && (argv[index + 1] ?? "").includes(ADAPTER_PACKAGE)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function settingsListAdapter(agentDir: string): boolean {
+	try {
+		const raw: unknown = JSON.parse(readFileSync(path.join(agentDir, "settings.json"), "utf8"));
+		if (!isRecord(raw) || !Array.isArray(raw.packages)) return false;
+		return raw.packages.some((entry) => {
+			const source =
+				typeof entry === "string"
+					? entry
+					: isRecord(entry) && typeof entry.source === "string"
+						? entry.source
+						: undefined;
+			return source !== undefined && source.includes(ADAPTER_PACKAGE);
+		});
+	} catch {
+		return false;
+	}
+}

package/src/json-file.ts

@@ -5,6 +5,7 @@
  * fallback); this helper only classifies the outcome.
  */
 
+import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 
 export type JsonFileResult =
@@ -30,6 +31,25 @@ export async function readJsonFile(filePath: string): Promise<JsonFileResult> {
 	}
 }
 
+/** Synchronous twin of `readJsonFile`, for callers that must finish before
+ *  an event Pi is about to emit (extension loading). Same classification. */
+export function readJsonFileSync(filePath: string): JsonFileResult {
+	let raw: string;
+	try {
+		raw = readFileSync(filePath, "utf8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return { ok: false, reason: "missing" };
+		}
+		throw error;
+	}
+	try {
+		return { ok: true, value: JSON.parse(raw) };
+	} catch {
+		return { ok: false, reason: "invalid" };
+	}
+}
+
 export function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }