pi-profile-switch 0.3.0 → 0.4.0

package/src/switching/profile-crud.ts

@@ -16,30 +16,34 @@
 
 import path from "node:path";
 
+import { getGlobalProfilesPath } from "../workspace.ts";
+import { readTrustInputs } from "../launcher/initial-profile.ts";
 import { CatalogError, DEFAULT_PROFILE_NAME, type ProfileDefinition } from "../profile-catalog.ts";
 import { ProfileCatalogStore } from "../profile-catalog-store.ts";
 
 export type CatalogScope = "global" | "project";
 
-/** The caller's trust decision (`ctx.isProjectTrusted()`) plus the two
- *  directories scope files live in. */
-export interface CatalogInput {
-	realAgentDir: string;
-	cwd: string;
-	projectTrusted: boolean;
-}
-
 /** The store for one scope's catalog file — the ONLY place scope-file
  *  paths are constructed. Callers must still trust-gate project access
  *  (`requireScope` / `readCatalogScope`). */
-export function catalogStore(input: CatalogInput, scope: CatalogScope): ProfileCatalogStore {
-	return new ProfileCatalogStore(
-		scope === "global" ? path.join(input.realAgentDir, "profiles.json") : path.join(input.cwd, ".pi", "profiles.json"),
-	);
+export function catalogStore(
+	input: { realAgentDir: string; cwd: string },
+	scope: CatalogScope,
+): ProfileCatalogStore {
+	if (scope === "global") {
+		return new ProfileCatalogStore(
+			getGlobalProfilesPath(),
+			path.join(input.realAgentDir, "profiles.json")
+		);
+	}
+	return new ProfileCatalogStore(path.join(input.cwd, ".pi", "profiles.json"));
 }
 
-function requireScope(input: CatalogInput, scope: CatalogScope): void {
-	if (scope === "project" && !input.projectTrusted) {
+async function requireScope(input: { realAgentDir: string; cwd: string }, scope: CatalogScope): Promise<void> {
+	if (
+		scope === "project" &&
+		!(await readTrustInputs({ agentDir: input.realAgentDir, cwd: input.cwd })).projectTrusted
+	) {
 		throw new CatalogError(`project catalog is unavailable: ${input.cwd} is not trusted`);
 	}
 }
@@ -47,10 +51,13 @@ function requireScope(input: CatalogInput, scope: CatalogScope): void {
 /** Reads one scope's catalog with the trust gate applied — project reads
  *  return empty when untrusted (never touching the file). */
 export async function readCatalogScope(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 ): Promise<Map<string, ProfileDefinition>> {
-	if (scope === "project" && !input.projectTrusted) {
+	if (
+		scope === "project" &&
+		!(await readTrustInputs({ agentDir: input.realAgentDir, cwd: input.cwd })).projectTrusted
+	) {
 		return new Map();
 	}
 	return catalogStore(input, scope).readDefinitions();
@@ -58,12 +65,12 @@ export async function readCatalogScope(
 
 /** Creates a complete definition in the chosen scope. */
 export async function createProfile(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 	name: string,
 	definition: ProfileDefinition,
 ): Promise<void> {
-	requireScope(input, scope);
+	await requireScope(input, scope);
 	const store = catalogStore(input, scope);
 	if ((await store.readDefinitions()).has(name)) {
 		throw new CatalogError(`profile "${name}" already exists in the ${scope} catalog`);
@@ -73,12 +80,12 @@ export async function createProfile(
 
 /** Replaces a complete definition; the caller reloads iff it is active. */
 export async function editProfile(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 	name: string,
 	definition: ProfileDefinition,
 ): Promise<void> {
-	requireScope(input, scope);
+	await requireScope(input, scope);
 	if (name === DEFAULT_PROFILE_NAME) {
 		throw new CatalogError(`"${DEFAULT_PROFILE_NAME}" is built in and cannot be edited`);
 	}
@@ -96,12 +103,12 @@ export async function editProfile(
  * deleted.
  */
 export async function deleteProfile(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 	name: string,
 	options: { activeProfile?: string; replacement?: string },
 ): Promise<void> {
-	requireScope(input, scope);
+	await requireScope(input, scope);
 	if (name === DEFAULT_PROFILE_NAME) {
 		throw new CatalogError(`"${DEFAULT_PROFILE_NAME}" is built in and cannot be deleted`);
 	}
@@ -113,12 +120,12 @@ export async function deleteProfile(
 
 /** Copies a complete definition under a new, unused name. */
 export async function duplicateProfile(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 	sourceName: string,
 	newName: string,
 ): Promise<void> {
-	requireScope(input, scope);
+	await requireScope(input, scope);
 	const store = catalogStore(input, scope);
 	const definitions = await store.readDefinitions();
 	const source = definitions.get(sourceName);

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)"],
-		["mcp", "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");
 }