pi-profile-switch 0.9.2 → 0.11.0

package/src/switching/apply-plan.ts

@@ -15,6 +15,11 @@
  *      `defaultTools` provides only the boot baseline for built-ins.
  *      Literals that no tool provides are dropped with a warning — Pi
  *      silently ignores unknown names, so the warning is the only signal.
+ *      When the plan carries overlay disabled tool entries, the active set
+ *      is the base expansion — the profile references, or the whole live
+ *      registry when the profile declares none — minus the entries' live
+ *      matches, re-expanded at this moment so registry drift re-applies
+ *      correctly after reload.
  *   2. persistence: when the plan is marked `persistSelection` and this is a
  *      reload, save the selection (activeProfile = plan.profile) to the
  *      profile's scope state file. Launch-transient selections never write.
@@ -40,6 +45,9 @@ export interface LaunchPlanFile {
 	agentDir?: string;
 	tools?: string[];
 	toolReferences?: string[];
+	/** Overlay tool disable entries (names or globs, verbatim); subtracted
+	 *  from the base expansion at session start. */
+	disabledTools?: string[];
 	mcps?: string[];
 	switchedFrom?: string;
 	persistSelection?: boolean;
@@ -95,22 +103,42 @@ export async function applyLaunchPlan(input: {
 	const warnings: string[] = [];
 
 	// --- tools ---
-	if (plan.toolReferences !== undefined) {
+	if (plan.toolReferences !== undefined || plan.disabledTools !== undefined) {
 		const liveNames = surface.getAllTools().map((tool) => tool.name);
-		const { expanded, droppedLiterals } = expandToolReferences(plan.toolReferences, liveNames);
-		if (droppedLiterals.length > 0) {
-			warnings.push(
-				`profile "${plan.profile}": tools ${droppedLiterals.map((name) => JSON.stringify(name)).join(", ")} match nothing in Pi's live registry`,
+		let active: string[];
+		if (plan.toolReferences !== undefined) {
+			const { expanded, droppedLiterals } = expandToolReferences(plan.toolReferences, liveNames);
+			if (droppedLiterals.length > 0) {
+				warnings.push(
+					`profile "${plan.profile}": tools ${droppedLiterals.map((name) => JSON.stringify(name)).join(", ")} match nothing in Pi's live registry`,
+				);
+			}
+			active = expanded;
+		} else {
+			// No declared tools: the base is the whole live registry.
+			active = [...liveNames];
+		}
+		if (plan.disabledTools !== undefined && plan.disabledTools.length > 0) {
+			const { expanded: disabled, droppedLiterals: vanishedEntries } = expandToolReferences(
+				plan.disabledTools,
+				liveNames,
 			);
+			if (vanishedEntries.length > 0) {
+				warnings.push(
+					`profile "${plan.profile}": overlay tool entries ${vanishedEntries.map((name) => JSON.stringify(name)).join(", ")} match nothing in Pi's live registry`,
+				);
+			}
+			const disabledSet = new Set(disabled);
+			active = active.filter((name) => !disabledSet.has(name));
 		}
-		surface.setActiveTools(expanded);
+		surface.setActiveTools(active);
 	}
 
 	// --- persistence (post-reload only) ---
 	if (plan.persistSelection === true && input.reason === "reload" && plan.agentDir !== undefined) {
 		const stateDir = plan.source === "project" ? path.join(input.cwd, ".pi") : getGlobalStateDir(plan.agentDir);
-		// Merge: the overlay belongs to customize/reset, not to this write.
-		// A switch (clearOverlay) explicitly drops it.
+		// Merge: the overlay belongs to the overlay commands, not to this
+		// write. A switch (clearOverlay) explicitly drops it.
 		await new RuntimeStateStore(stateDir).update({
 			activeProfile: plan.profile,
 			...(plan.clearOverlay === true ? { overlay: undefined } : {}),

package/src/switching/list-profiles.ts

@@ -1,6 +1,6 @@
 /**
- * ProfileListing: the `/profile list` and `/profile` selector data surface
- * (ticket 07).
+ * ProfileListing: the profile selector's and the degraded bare `/profile`
+ * list's data surface (ticket 07).
  *
  * Trust-gated exactly like activation: an untrusted project's profiles are
  * invisible. The listing reports each visible profile with the source of

package/src/switching/{customize.ts → overlay.ts}

@@ -1,5 +1,6 @@
 /**
- * Overlay customize/reset orchestration (ticket 06).
+ * Overlay command orchestration (ticket 06; module renamed with the
+ * `/profile overlay` subcommand).
  *
  * The overlay narrows the ACTIVE profile for this runtime only. It is
  * written to the scope state file (never a catalog) purely as the
@@ -8,12 +9,12 @@
  * ignores stored overlays, so an overlay never outlives its runtime.
  *
  * Ordering invariants:
- * - customize: re-resolve with the candidate overlay FIRST (validation:
- *   unknown references fail here, before anything
- *   is written), then switch+reload, then persist the overlay to state. A
- *   failed switch leaves the stored overlay untouched, consistent with the
- *   rolled-back runtime.
- * - reset: switch+reload WITHOUT the overlay first, then delete it from
+ * - disable|enable: re-resolve with the candidate overlay FIRST
+ *   (validation: unknown references and enable misses fail here, before
+ *   anything is written), then switch+reload, then persist the overlay to
+ *   state. A failed switch leaves the stored overlay untouched, consistent
+ *   with the rolled-back runtime.
+ * - clear: switch+reload WITHOUT the overlay first, then delete it from
  *   state. If the switch rolls back, the stored overlay still matches the
  *   restored runtime.
  */
@@ -31,7 +32,7 @@ async function currentStateTarget(
 ): Promise<{ profile: string; store: RuntimeStateStore; state: RuntimeState }> {
 	const plan = await readLaunchPlanFile(deps.runtimeDir);
 	if (plan === undefined) {
-		throw new SwitchError("no active profile — nothing to customize");
+		throw new SwitchError("no active profile — nothing to overlay");
 	}
 	const stateDir = plan.source === "project" ? path.join(deps.cwd, ".pi") : getGlobalStateDir(plan.agentDir);
 	if (stateDir === undefined) {
@@ -42,7 +43,7 @@ async function currentStateTarget(
 }
 
 /** Applies a mutation to the active profile's overlay and re-activates. */
-export async function customizeOverlay(
+export async function applyOverlayMutation(
 	deps: SwitchDeps,
 	mutate: (overlay: RuntimeOverlay) => RuntimeOverlay,
 ): Promise<SwitchResult> {
@@ -59,7 +60,7 @@ export async function customizeOverlay(
 }
 
 /** Discards the overlay and reactivates the profile exactly as declared. */
-export async function resetOverlay(deps: SwitchDeps): Promise<SwitchResult> {
+export async function clearOverlay(deps: SwitchDeps): Promise<SwitchResult> {
 	const { profile, store } = await currentStateTarget(deps);
 
 	// overlay: null — explicit "none"; without it the reload path would
@@ -70,47 +71,78 @@ export async function resetOverlay(deps: SwitchDeps): Promise<SwitchResult> {
 	return result;
 }
 
-export const CUSTOMIZE_USAGE =
-	"/profile customize disable|enable skill|extension|mcp <name> · /profile customize tools [ref...]" as const;
+export const OVERLAY_USAGE =
+	"/profile overlay disable|enable skill|extension|mcp|tool <name-or-glob> · /profile overlay clear" as const;
+
+/** The parsed form of `/profile overlay` arguments: either a mutation to
+ *  validate and apply against the stored overlay, or `clear`. */
+export type OverlayCommand =
+	| { kind: "mutate"; mutate: (overlay: RuntimeOverlay) => RuntimeOverlay }
+	| { kind: "clear" };
 
 const DISABLED_FIELDS = {
 	skill: "disabledSkills",
 	extension: "disabledExtensions",
 	mcp: "disabledMcps",
+	tool: "disabledTools",
 } as const;
 
-/** Parses `/profile customize` arguments into an overlay mutation.
+/** Parses `/profile overlay` arguments into an overlay command.
  *  Grammar:
- *    customize disable skill|extension|mcp <name>
- *    customize enable  skill|extension|mcp <name>   (un-disable)
- *    customize tools <ref>...                        (replace tool refs)
- *    customize tools                                  (clear the tools override)
+ *    overlay disable skill|extension|mcp|tool <name-or-glob>
+ *    overlay enable  skill|extension|mcp|tool <name-or-glob>   (remove a stored entry)
+ *    overlay clear                                              (discard the overlay)
+ *
+ *  One uniform grammar for all four resource kinds (the tools-only
+ *  replace-form is gone — tools are disabled like the other kinds). The
+ *  removed `tools` action falls through to the usage error above.
+ *
+ *  `enable` removes a stored entry by exact string match — no hole-punching
+ *  through globs — and fails when nothing equals the given name, listing the
+ *  current entries of that kind.
  */
-export function parseCustomizeArgs(args: string): (overlay: RuntimeOverlay) => RuntimeOverlay {
+export function parseOverlayArgs(args: string): OverlayCommand {
 	const [action, kind, ...rest] = args.trim().split(/\s+/).filter(Boolean);
 
-	if (action === "tools") {
-		const refs = [kind, ...rest].filter((entry): entry is string => entry !== undefined);
-		return (overlay) => {
-			const next = { ...overlay };
-			if (refs.length === 0) delete next.tools;
-			else next.tools = refs;
-			return next;
-		};
+	if (action === "clear") {
+		if (rest.length > 0 || kind !== undefined) throw new SwitchError(`usage: ${OVERLAY_USAGE}`);
+		return { kind: "clear" };
 	}
 
 	const field = DISABLED_FIELDS[kind as keyof typeof DISABLED_FIELDS];
 	if ((action !== "disable" && action !== "enable") || field === undefined || rest.length !== 1) {
-		throw new SwitchError(`usage: ${CUSTOMIZE_USAGE}`);
+		throw new SwitchError(`usage: ${OVERLAY_USAGE}`);
 	}
 	const [name] = rest;
-	return (overlay) => {
-		const current = overlay[field] ?? [];
-		const nextList =
-			action === "disable" ? [...new Set([...current, name])] : current.filter((entry) => entry !== name);
-		const next = { ...overlay };
-		if (nextList.length === 0) delete next[field];
-		else next[field] = nextList;
-		return next;
+
+	if (action === "disable") {
+		return {
+			kind: "mutate",
+			mutate: (overlay) => {
+				const current = overlay[field] ?? [];
+				// `name` is always appended, so the list never empties here (the
+			// enable closure below owns the delete-when-empty branch).
+				return { ...overlay, [field]: [...new Set([...current, name])] };
+			},
+		};
+	}
+
+	return {
+		kind: "mutate",
+		mutate: (overlay) => {
+			const current = overlay[field] ?? [];
+			if (!current.includes(name)) {
+				throw new SwitchError(
+					`no stored ${kind} disable entry equals "${name}" — current entries: ${
+						current.length > 0 ? current.join(", ") : "(none)"
+					}`,
+				);
+			}
+			const nextList = current.filter((entry) => entry !== name);
+			const next = { ...overlay };
+			if (nextList.length === 0) delete next[field];
+			else next[field] = nextList;
+			return next;
+		},
 	};
 }

package/src/switching/status.ts

@@ -145,7 +145,7 @@ export function formatStatusMarkdown(report: StatusReport): string {
 			...(report.overlay.disabledSkills ?? []).map((name) => `-skill:${name}`),
 			...(report.overlay.disabledExtensions ?? []).map((id) => `-extension:${id}`),
 			...(report.overlay.disabledMcps ?? []).map((name) => `-mcp:${name}`),
-			...(report.overlay.tools !== undefined ? [`tools=[${report.overlay.tools.join(", ")}]`] : []),
+			...(report.overlay.disabledTools ?? []).map((name) => `-tool:${name}`),
 		];
 		lines.push(`overlay: ${parts.length > 0 ? parts.join(" ") : "(empty)"}`);
 	}

package/src/switching/switch-profile.ts

@@ -55,6 +55,10 @@ export interface SwitchDeps {
 	realAgentDir: string;
 	/** The project working directory. */
 	cwd: string;
+	/** Pi's live tool registry (pi.getAllTools()): the base set overlay tool
+	 *  disable entries narrow when the profile declares no tools, and the
+	 *  in-session expansion universe for declared references. */
+	getAllTools(): Array<{ name: string }>;
 	/** Pi's native idle wait (ctx.waitForIdle): resolves when the current
 	 *  turn/compaction finishes. */
 	waitForIdle(): Promise<void>;
@@ -162,8 +166,8 @@ export async function switchProfile(
 		throw new SwitchError("no active profile to reload");
 	}
 
-	// Overlay resolution: explicit `overlay` wins (customize), explicit
-	// `null` suppresses (reset/switch), and a plain `/profile reload`
+	// Overlay resolution: explicit `overlay` wins (overlay mutation),
+	// explicit `null` suppresses (clear/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) {
@@ -185,7 +189,7 @@ export async function switchProfile(
 	const resolved = await resolveInitialProfile(
 		target,
 		{ agentDir: deps.realAgentDir, cwd: deps.cwd },
-		{ overlay: overlay ?? undefined },
+		{ overlay: overlay ?? undefined, liveToolNames: deps.getAllTools().map((tool) => tool.name) },
 	);
 
 	const isSwitch = !options?.reloadCurrent && target !== current.profile;

package/src/profile-catalog-store.ts

@@ -1,86 +0,0 @@
-/**
- * ProfileCatalogStore: the WRITE side of profile catalog files,
- * storing each profile in its own `<name>.json` file.
- *
- * Invariants:
- * - Single-file operations (pretty-printed JSON without schemaVersion envelope).
- * - Writes land in `<dir>/<name>.json` via a temporary file + rename.
- * - Names must match `PROFILE_NAME_PATTERN` and cannot be "default".
- * - Definitions are complete and self-contained: no inheritance fields exist.
- * - Definitions are re-parsed through the catalog's own
- *   `parseProfileDefinition`, so anything written is loadable.
- * - Writes land in exactly one scope directory (global or project).
- */
-
-import { mkdir, rename, rm, unlink, writeFile } from "node:fs/promises";
-import path from "node:path";
-
-import {
-	CatalogError,
-	DEFAULT_PROFILE_NAME,
-	loadCatalogDirectory,
-	parseProfileDefinition,
-	PROFILE_NAME_PATTERN,
-	type ProfileDefinition,
-} from "./profile-catalog.ts";
-
-export class ProfileCatalogStore {
-	readonly #dirPath: string;
-
-	constructor(catalogDir: string) {
-		this.#dirPath = catalogDir;
-	}
-
-	/** Validated definitions: missing directory → empty; malformed → CatalogError
-	 *  (catalog errors never pass silently, even on the write path). */
-	async readDefinitions(): Promise<Map<string, ProfileDefinition>> {
-		return loadCatalogDirectory(this.#dirPath);
-	}
-
-	/** Inserts or replaces one complete definition (via atomic rename). */
-	async upsert(name: string, definition: ProfileDefinition): Promise<void> {
-		if (!PROFILE_NAME_PATTERN.test(name)) {
-			throw new CatalogError(`invalid profile name "${name}" (must match ${PROFILE_NAME_PATTERN})`);
-		}
-		if (name === DEFAULT_PROFILE_NAME) {
-			throw new CatalogError(`"${DEFAULT_PROFILE_NAME}" is built in and must not be defined in the catalog`);
-		}
-
-		// Validate before mutating: the definition must parse.
-		const validated = parseProfileDefinition(name, definition);
-
-		await mkdir(this.#dirPath, { recursive: true });
-		const targetPath = path.join(this.#dirPath, `${name}.json`);
-		const tempPath = path.join(
-			this.#dirPath,
-			`.${name}.json.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
-		);
-
-		try {
-			await writeFile(tempPath, `${JSON.stringify(validated, null, 2)}\n`);
-			await rename(tempPath, targetPath);
-		} catch (error) {
-			await rm(tempPath, { force: true });
-			throw error;
-		}
-	}
-
-	/** Removes one profile; unknown names are a loud error, not a no-op. */
-	async remove(name: string): Promise<void> {
-		if (!PROFILE_NAME_PATTERN.test(name)) {
-			throw new CatalogError(`invalid profile name "${name}" (must match ${PROFILE_NAME_PATTERN})`);
-		}
-		if (name === DEFAULT_PROFILE_NAME) {
-			throw new CatalogError(`"${DEFAULT_PROFILE_NAME}" is built in and cannot be deleted`);
-		}
-		const targetPath = path.join(this.#dirPath, `${name}.json`);
-		try {
-			await unlink(targetPath);
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-				throw new CatalogError(`profile "${name}" not found in ${this.#dirPath}`);
-			}
-			throw error;
-		}
-	}
-}

package/src/switching/profile-crud.ts

@@ -1,136 +0,0 @@
-/**
- * ProfileCrud: `/profile create|edit|delete|duplicate` semantics (ticket 09)
- * on top of ProfileCatalogStore.
- *
- * Invariants:
- * - Trust-gated exactly like activation: an untrusted project's catalog is
- *   never read or written.
- * - Deleting the ACTIVE profile requires a replacement up front — the
- *   session must land somewhere defined; the caller switches to it.
- * - Deleting one scope's record while the other scope keeps the name
- *   reveals that definition (merged-catalog semantics; nothing extra to
- *   do beyond reloading).
- * - Duplicating copies the COMPLETE definition under a new name — the
- *   only variant mechanism (no inheritance).
- */
-
-import path from "node:path";
-
-import { getGlobalProfilesDir } 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 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: { realAgentDir: string; cwd: string },
-	scope: CatalogScope,
-): ProfileCatalogStore {
-	if (scope === "global") {
-		return new ProfileCatalogStore(getGlobalProfilesDir());
-	}
-	return new ProfileCatalogStore(path.join(input.cwd, ".pi", "profiles"));
-}
-
-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`);
-	}
-}
-
-/** 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: { realAgentDir: string; cwd: string },
-	scope: CatalogScope,
-): Promise<Map<string, ProfileDefinition>> {
-	if (
-		scope === "project" &&
-		!(await readTrustInputs({ agentDir: input.realAgentDir, cwd: input.cwd })).projectTrusted
-	) {
-		return new Map();
-	}
-	return catalogStore(input, scope).readDefinitions();
-}
-
-/** Creates a complete definition in the chosen scope. */
-export async function createProfile(
-	input: { realAgentDir: string; cwd: string },
-	scope: CatalogScope,
-	name: string,
-	definition: ProfileDefinition,
-): Promise<void> {
-	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`);
-	}
-	await store.upsert(name, definition);
-}
-
-/** Replaces a complete definition; the caller reloads iff it is active. */
-export async function editProfile(
-	input: { realAgentDir: string; cwd: string },
-	scope: CatalogScope,
-	name: string,
-	definition: ProfileDefinition,
-): Promise<void> {
-	await requireScope(input, scope);
-	if (name === DEFAULT_PROFILE_NAME) {
-		throw new CatalogError(`"${DEFAULT_PROFILE_NAME}" is built in and cannot be edited`);
-	}
-	const store = catalogStore(input, scope);
-	if (!(await store.readDefinitions()).has(name)) {
-		throw new CatalogError(`profile "${name}" not found in the ${scope} catalog`);
-	}
-	await store.upsert(name, definition);
-}
-
-/**
- * Deletes a profile from the chosen scope. Deleting the active profile
- * requires `replacement` (validated for existence in the remaining merged
- * catalog by the caller's switch); the built-in default can never be
- * deleted.
- */
-export async function deleteProfile(
-	input: { realAgentDir: string; cwd: string },
-	scope: CatalogScope,
-	name: string,
-	options: { activeProfile?: string; replacement?: string },
-): Promise<void> {
-	await requireScope(input, scope);
-	if (name === DEFAULT_PROFILE_NAME) {
-		throw new CatalogError(`"${DEFAULT_PROFILE_NAME}" is built in and cannot be deleted`);
-	}
-	if (options.activeProfile === name && options.replacement === undefined) {
-		throw new CatalogError(`profile "${name}" is active — choose a replacement profile first`);
-	}
-	await catalogStore(input, scope).remove(name);
-}
-
-/** Copies a complete definition under a new, unused name. */
-export async function duplicateProfile(
-	input: { realAgentDir: string; cwd: string },
-	scope: CatalogScope,
-	sourceName: string,
-	newName: string,
-): Promise<void> {
-	await requireScope(input, scope);
-	const store = catalogStore(input, scope);
-	const definitions = await store.readDefinitions();
-	const source = definitions.get(sourceName);
-	if (source === undefined) {
-		throw new CatalogError(`profile "${sourceName}" not found in the ${scope} catalog`);
-	}
-	if (definitions.has(newName)) {
-		throw new CatalogError(`profile "${newName}" already exists in the ${scope} catalog`);
-	}
-	await store.upsert(newName, { ...source });
-}

package/src/switching/profile-wizard.ts

@@ -1,163 +0,0 @@
-/**
- * ProfileWizard: the interactive create/edit/duplicate dialog for
- * `/profile create|edit|delete|duplicate` (ticket 09), UI-injected for
- * testability.
- *
- * Definitions are complete and self-contained — the wizard edits whole
- * fields, never inheritance or merge syntax. On edit, an empty answer
- * 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.
- */
-
-import type { ProfileDefinition } from "../profile-catalog.ts";
-import type { CatalogScope } from "./profile-crud.ts";
-
-export interface ProfileWizardUi {
-	select(title: string, options: string[]): Promise<string | undefined>;
-	input(title: string, placeholder?: string): Promise<string | undefined>;
-}
-
-export interface ProfileWizardResult {
-	scope: CatalogScope;
-	name: string;
-	definition: ProfileDefinition;
-}
-
-interface ExistingProfile {
-	name: string;
-	source: CatalogScope;
-	definition: ProfileDefinition;
-}
-
-function parseList(raw: string): string[] {
-	return raw
-		.split(",")
-		.map((entry) => entry.trim())
-		.filter((entry) => entry.length > 0);
-}
-
-/** "provider/id[/thinkingLevel]" → ProfileModel; empty/undefined → none. */
-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());
-	if (provider === undefined || provider.length === 0 || id === undefined || id.length === 0) {
-		return undefined;
-	}
-	return thinkingLevel !== undefined && thinkingLevel.length > 0
-		? { defaultProvider: provider, defaultModel: id, defaultThinkingLevel: thinkingLevel }
-		: { defaultProvider: provider, defaultModel: id };
-}
-
-async function captureDefinition(
-	ui: ProfileWizardUi,
-	existing?: ProfileDefinition,
-): Promise<ProfileDefinition | undefined> {
-	const definition: ProfileDefinition = {};
-
-	const label = await ui.input("label (optional; empty keeps current)", existing?.label);
-	if (label === undefined) return undefined;
-	if (label.trim().length > 0) definition.label = label.trim();
-	else if (existing?.label !== undefined) definition.label = existing.label;
-
-	const description = await ui.input("description (optional; empty keeps current)", existing?.description);
-	if (description === undefined) return undefined;
-	if (description.trim().length > 0) definition.description = description.trim();
-	else if (existing?.description !== undefined) definition.description = existing.description;
-
-	const listFields = [
-		["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) {
-		const current = existing?.[field]?.join(", ");
-		const raw = await ui.input(prompt, current);
-		if (raw === undefined) return undefined;
-		const parsed = parseList(raw);
-		// Empty keeps the existing value on edit; on create it omits the field.
-		if (parsed.length > 0) {
-			definition[field] = parsed;
-		} else if (current !== undefined) {
-			definition[field] = existing?.[field];
-		}
-	}
-
-	const instructions = await ui.input(
-		"instructions (appended to the system prompt; empty keeps current)",
-		existing?.instructions,
-	);
-	if (instructions === undefined) return undefined;
-	if (instructions.trim().length > 0) definition.instructions = instructions;
-	else if (existing?.instructions !== undefined) definition.instructions = existing.instructions;
-
-	const currentModel =
-		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.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;
-}
-
-/** Create: scope first (project only when trusted), then name, then fields. */
-export async function runProfileCreateWizard(
-	ui: ProfileWizardUi,
-	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 name = await ui.input("profile name");
-	if (name === undefined || name.trim().length === 0) return undefined;
-
-	const definition = await captureDefinition(ui);
-	if (definition === undefined) return undefined;
-
-	return { scope: scope as CatalogScope, name: name.trim(), definition };
-}
-
-/** Edit: fields prefilled from the existing complete definition. */
-export async function runProfileEditWizard(
-	ui: ProfileWizardUi,
-	input: { existing: ExistingProfile },
-): Promise<ProfileWizardResult | undefined> {
-	const definition = await captureDefinition(ui, input.existing.definition);
-	if (definition === undefined) return undefined;
-	return { scope: input.existing.source, name: input.existing.name, definition };
-}
-
-/** Duplicate: pick a source, name the copy — the only variant mechanism. */
-export async function runProfileDuplicateWizard(
-	ui: ProfileWizardUi,
-	input: { candidates: ExistingProfile[] },
-): Promise<{ scope: CatalogScope; sourceName: string; newName: string } | undefined> {
-	if (input.candidates.length === 0) return undefined;
-	const options = input.candidates.map(
-		(candidate) => `${candidate.name} [${candidate.source}]${candidate.definition.label !== undefined ? ` — ${candidate.definition.label}` : ""}`,
-	);
-	const chosen = await ui.select("duplicate which profile?", options);
-	if (chosen === undefined) return undefined;
-	const source = input.candidates.find((candidate) => chosen.startsWith(`${candidate.name} [`));
-	if (source === undefined) return undefined;
-
-	const newName = await ui.input("new profile name");
-	if (newName === undefined || newName.trim().length === 0) return undefined;
-
-	return { scope: source.source, sourceName: source.name, newName: newName.trim() };
-}