pi-profile-switch 0.9.2 → 0.10.0

package/README.md

@@ -107,17 +107,24 @@ If you used an earlier version that stored all profiles in a single `profiles.js
 
 ## Commands
 
-In the TUI, the `/profile` command family manages everything in-session:
+The `/profile` command family manages everything in-session:
 
 | Command | What it does |
 | --- | --- |
-| `/profile` | Interactive profile picker |
-| `/profile list` / `/profile status` | Show profiles / active profile details |
+| `/profile` | Interactive profile picker; without interactive UI it prints the profile list instead |
 | `/profile use <name>` / `/profile reload` | Switch / reload without restarting (rollback on failure) |
-| `/profile create\|edit\|delete\|duplicate` | Guided profile CRUD (TUI only) |
-| `/profile customize` / `/profile reset` | Narrow the active profile for this session only |
+| `/profile status` | Active profile details: resolved resources and paths, stored overlay, MCP server tri-state |
+| `/profile overlay disable\|enable skill\|extension\|mcp\|tool <name-or-glob>` | Narrow / un-narrow the active profile for this session only; `disable` entries accept names or globs |
+| `/profile overlay clear` | Discard the overlay and reactivate the profile exactly as declared |
 
-All commands work in non-interactive modes (`--mode rpc|print|json`); CRUD wizards are TUI-only.
+All forms work in every mode, including non-interactive ones (`--mode rpc|print|json`); the bare selector degrades to the profile list where no interactive UI exists. The overlay is a runtime-only narrowing: it is never written to a catalog file and never survives a restart. Tools follow the same disable/enable model as the other resource kinds: a tool `disable` entry narrows the profile's resolved tool references — or the runtime's full available tool set when the profile declares no `tools`.
+
+Removed subcommands and their replacements:
+
+| Removed | Replacement |
+| --- | --- |
+| `/profile create` / `/profile edit` / `/profile delete` / `/profile duplicate` | edit the catalog JSON files directly, or configure profiles conversationally with the [`profile-config`](skills/profile-config/SKILL.md) skill |
+| the `tools` replace-form of `/profile overlay` | `/profile overlay disable tool <name-or-glob>` (disable the complement, with globs) or declare the fixed set in the profile's `tools` field |
 
 ## Docs
 

package/README.zh-CN.md

@@ -107,17 +107,24 @@ pi-profile-switch 会向全局 `profiles/` 目录播种一个初始 **`ask`** pr
 
 ## 命令
 
-在 TUI 中，`/profile` 命令族完成所有会话内操作：
+`/profile` 命令族完成所有会话内操作：
 
 | 命令 | 作用 |
 | --- | --- |
-| `/profile` | 交互式选择 profile |
-| `/profile list` / `/profile status` | 列出 profile / 查看活动 profile 详情 |
+| `/profile` | 交互式选择 profile；无交互界面时打印 profile 列表 |
 | `/profile use <name>` / `/profile reload` | 会话内切换 / 重载（失败自动回滚） |
-| `/profile create\|edit\|delete\|duplicate` | 向导式 profile 增删改（仅 TUI） |
-| `/profile customize` / `/profile reset` | 仅本次会话收窄活动 profile |
+| `/profile status` | 查看活动 profile 详情：解析后的资源与路径、已存 overlay、MCP server 三态 |
+| `/profile overlay disable\|enable skill\|extension\|mcp\|tool <name-or-glob>` | 仅本次会话收窄 / 恢复活动 profile；`disable` 接受名称或 glob |
+| `/profile overlay clear` | 丢弃 overlay，完全按定义重新激活 profile |
 
-非交互模式（`--mode rpc|print|json`）下命令同样生效；CRUD 向导仅 TUI 可用。
+所有命令在非交互模式（`--mode rpc|print|json`）下同样生效；裸 `/profile` 在无交互界面时降级为 profile 列表。overlay 是会话级收窄：绝不写入 catalog 文件，也不会跨重启保留。tool 与其他资源类别使用相同的 disable/enable 模型：tool `disable` 条目收窄 profile 解析出的工具引用；profile 未声明 `tools` 时，则收窄运行时的全部可用工具集。
+
+已移除子命令及其替代：
+
+| 移除 | 替代 |
+| --- | --- |
+| `/profile create` / `/profile edit` / `/profile delete` / `/profile duplicate` | 直接编辑 catalog JSON 文件，或通过 [`profile-config`](skills/profile-config/SKILL.md) skill 对话式配置 |
+| `/profile overlay` 的 `tools` 替换式 | `/profile overlay disable tool <name-or-glob>`（用 glob 禁用其余工具），或在 profile 的 `tools` 字段中声明固定集合 |
 
 ## 文档
 

package/extensions/pi-profile/index.ts

@@ -6,21 +6,8 @@ import { readTrustInputs } from "../../src/launcher/initial-profile.ts";
 import { discoverAdapterServerNames } from "../../src/mcp-config.ts";
 import { RuntimeStateStore } from "../../src/runtime-state-store.ts";
 import { applyLaunchPlan, readLaunchPlanFile } from "../../src/switching/apply-plan.ts";
-import { CUSTOMIZE_USAGE, customizeOverlay, parseCustomizeArgs, resetOverlay } from "../../src/switching/customize.ts";
+import { OVERLAY_USAGE, applyOverlayMutation, clearOverlay, parseOverlayArgs } from "../../src/switching/overlay.ts";
 import { formatProfileList, listProfiles } from "../../src/switching/list-profiles.ts";
-import {
-	createProfile,
-	deleteProfile,
-	duplicateProfile,
-	editProfile,
-	readCatalogScope,
-} from "../../src/switching/profile-crud.ts";
-import type { ProfileDefinition } from "../../src/profile-catalog.ts";
-import {
-	runProfileCreateWizard,
-	runProfileDuplicateWizard,
-	runProfileEditWizard,
-} from "../../src/switching/profile-wizard.ts";
 import { buildStatusReport, formatStatusMarkdown } from "../../src/switching/status.ts";
 import { switchProfile, type SwitchDeps } from "../../src/switching/switch-profile.ts";
 import { getGlobalStateDir } from "../../src/workspace.ts";
@@ -37,18 +24,15 @@ import { getGlobalStateDir } from "../../src/workspace.ts";
  *   via `before_agent_start`.
  * - `/profile use <name>` / `/profile reload`: in-session switching without
  *   restarting the Pi process (src/switching/switch-profile.ts).
- * - `/profile customize` / `/profile reset`: runtime overlay (ticket 06).
- * - `/profile` (selector), `/profile list`, `/profile status`:
- *   observability surface (ticket 07). Status combines the active launch
- *   plan, the stored overlay, fresh MCP discovery, and Pi's actual command
- *   registrations (the winner evidence for same-name conflicts).
- * - `/profile create|edit|delete|duplicate`: catalog CRUD wizards (ticket 09).
- *   CRUD is TUI-only (ticket 11): gated on `ctx.mode === "tui"` with a
- *   mode-aware refusal. Mutations apply via the standard reload path;
- *   mutation success is notified BEFORE the reload — the command context
- *   is stale afterwards.
- * - list/status ship structured `details` payloads (`{kind, profiles}` /
- *   `{kind, report}`) for RPC consumers (ticket 11).
+ * - `/profile overlay ...`: runtime overlay (ticket 06; renamed with the
+ *   command word — disable/enable/tools/clear).
+ * - `/profile` (selector; degrades to the list without dialog-capable UI)
+ *   and `/profile status`: observability surface (ticket 07). Status
+ *   combines the active launch plan, the stored overlay, fresh MCP
+ *   discovery, and Pi's actual command registrations (the winner evidence
+ *   for same-name conflicts).
+ * - The degraded list and status ship structured `details` payloads
+ *   (`{kind, profiles}` / `{kind, report}`) for RPC consumers (ticket 11).
  *
  * Pi re-executes this module on reload, so post-reload state is established
  * exclusively through `session_start` — nothing stale survives.
@@ -92,7 +76,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.registerCommand("profile", {
-		description: "pi-profile: /profile [use|reload|customize|reset|list|status|create|edit|delete|duplicate]",
+		description: "pi-profile: /profile [use|reload|status|overlay]",
 		handler: async (args, ctx) => {
 			const [subcommandRaw, ...rest] = args.trim().split(/\s+/).filter(Boolean);
 			const subcommand = subcommandRaw ?? ""; // bare /profile → selector
@@ -107,35 +91,15 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 					// stale context after reload — see above
 				}
 			};
-			const usage = `usage: /profile [use <name> | reload | ${CUSTOMIZE_USAGE} | reset | list | status | create | edit <name> | delete <name> | duplicate]`;
+			const usage = `usage: /profile [use <name> | reload | status | ${OVERLAY_USAGE}]`;
 			if (subcommand === "use" && rest.length === 0) {
 				notify("usage: /profile use <name>", "error");
 				return;
 			}
-			if (
-				subcommand !== "" &&
-				![
-					"use",
-					"reload",
-					"customize",
-					"reset",
-					"list",
-					"status",
-					"create",
-					"edit",
-					"delete",
-					"duplicate",
-				].includes(
-					subcommand,
-				)
-			) {
+			if (subcommand !== "" && !["use", "reload", "status", "overlay"].includes(subcommand)) {
 				notify(usage, "error");
 				return;
 			}
-			if (["edit", "delete"].includes(subcommand) && rest[0] === undefined) {
-				notify(`usage: /profile ${subcommand} <name>`, "error");
-				return;
-			}
 			try {
 				const plan = await readLaunchPlanFile(runtimeDir);
 				if (plan?.agentDir === undefined) {
@@ -148,6 +112,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 					runtimeDir,
 					realAgentDir: plan.agentDir,
 					cwd: ctx.cwd,
+					getAllTools: () => pi.getAllTools(),
 					waitForIdle: () => ctx.waitForIdle(),
 					reload: () => ctx.reload(),
 					// A real reload invalidates this context (Pi re-executes
@@ -172,148 +137,22 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 					notify(`profile reloaded: ${result.profile}`, "info");
 					return;
 				}
-				if (subcommand === "customize") {
-					const result = await customizeOverlay(deps, parseCustomizeArgs(rest.join(" ")));
-					for (const warning of result.warnings) notify(warning, "warning");
-					notify(`overlay updated: ${result.profile}`, "info");
-					return;
-				}
-				if (subcommand === "reset") {
-					const result = await resetOverlay(deps);
-					for (const warning of result.warnings) notify(warning, "warning");
-					notify(`overlay cleared: ${result.profile}`, "info");
-					return;
-				}
-				// Profile catalog CRUD (ticket 09): TUI-only wizards; mutations
-				// land in the chosen scope file. Editing the active profile
-				// reloads immediately; deleting the active profile requires a
-				// replacement chosen up front, then switches to it.
-				if (["create", "edit", "delete", "duplicate"].includes(subcommand)) {
-					if (ctx.mode !== "tui") {
-						notify(`/profile ${subcommand} requires TUI mode (current mode: ${ctx.mode})`, "error");
-						return;
-					}
-					const scopeInput = { realAgentDir: plan.agentDir, cwd: ctx.cwd };
-					if (subcommand === "create") {
-						const { projectTrusted: canWriteProject } = await readTrustInputs({
-							agentDir: plan.agentDir,
-							cwd: ctx.cwd,
-						});
-						const wizard = await runProfileCreateWizard(ctx.ui, { projectTrusted: canWriteProject });
-						if (wizard === undefined) return;
-						await createProfile(scopeInput, wizard.scope, wizard.name, wizard.definition);
-						notify(`created profile "${wizard.name}" (${wizard.scope}) — activate with /profile use ${wizard.name}`, "info");
-						return;
-					}
-					if (subcommand === "duplicate") {
-						const entries = await listProfiles(scopeInput);
-						// Read each scope once (trust-gated — never reads an
-						// untrusted project's catalog).
-						const byScope = {
-							global: await readCatalogScope(scopeInput, "global"),
-							project: await readCatalogScope(scopeInput, "project"),
-						};
-						const candidates: Array<{ name: string; source: "global" | "project"; definition: ProfileDefinition }> = [];
-						for (const entry of entries) {
-							if (entry.source === "builtin") continue;
-							const definition = byScope[entry.source].get(entry.name);
-							if (definition !== undefined) {
-								candidates.push({ name: entry.name, source: entry.source, definition });
-							}
-						}
-						const wizard = await runProfileDuplicateWizard(ctx.ui, { candidates });
-						if (wizard === undefined) return;
-						await duplicateProfile(scopeInput, wizard.scope, wizard.sourceName, wizard.newName);
-						notify(
-							`duplicated "${wizard.sourceName}" → "${wizard.newName}" (${wizard.scope}) — the full definition was copied`,
-							"info",
-						);
-						return;
-					}
-					const name = rest[0] as string;
-					if (subcommand === "edit") {
-						// Edit the WINNING definition in its source scope.
-						const entries = await listProfiles(scopeInput);
-						const existing = entries.find((entry) => entry.name === name);
-						if (existing === undefined || existing.source === "builtin") {
-							notify(`profile "${name}" not found in a writable catalog`, "error");
-							return;
-						}
-						const definition = (await readCatalogScope(scopeInput, existing.source)).get(name);
-						if (definition === undefined) {
-							notify(`profile "${name}" not found in the ${existing.source} catalog`, "error");
-							return;
-						}
-						const wizard = await runProfileEditWizard(ctx.ui, {
-							existing: { name, source: existing.source, definition },
-						});
-						if (wizard === undefined) return;
-						await editProfile(scopeInput, wizard.scope, wizard.name, wizard.definition);
-						if (name === plan.profile) {
-							notify(`saved profile "${name}"; reloading`, "info");
-							await switchProfile(plan.profile, deps, { reloadCurrent: true });
-						} else {
-							notify(`saved profile "${name}" (inactive — runtime untouched)`, "info");
-						}
+				if (subcommand === "overlay") {
+					const command = parseOverlayArgs(rest.join(" "));
+					if (command.kind === "clear") {
+						const result = await clearOverlay(deps);
+						for (const warning of result.warnings) notify(warning, "warning");
+						notify(`overlay cleared: ${result.profile}`, "info");
 						return;
 					}
-					// delete
-					const entries = await listProfiles(scopeInput);
-					const existing = entries.find((entry) => entry.name === name);
-					if (existing === undefined || existing.source === "builtin") {
-						notify(`profile "${name}" not found in a writable catalog`, "error");
-						return;
-					}
-					// Both scopes hold the name: choose which record to delete.
-					let scope = existing.source as "global" | "project";
-					const projectCatalog = await readCatalogScope(scopeInput, "project");
-					const globalCatalog = await readCatalogScope(scopeInput, "global");
-					if (projectCatalog.has(name) && globalCatalog.has(name)) {
-						const chosen = await ctx.ui.select(`delete "${name}" from which catalog?`, ["global", "project"]);
-						if (chosen === undefined) return;
-						scope = chosen as "global" | "project";
-					}
-					// If the OTHER scope keeps the name alive, deletion reveals
-					// it and the session can stay on the revealed same-name
-					// definition (symmetric: project→global and global→project).
-					const survivesElsewhere =
-						(scope === "project" && globalCatalog.has(name)) || (scope === "global" && projectCatalog.has(name));
-					let replacement: string | undefined;
-					if (name === plan.profile && !survivesElsewhere) {
-						const survivors = entries.filter((entry) => entry.name !== name);
-						const chosen = await ctx.ui.select(
-							`"${name}" is active — switch to which profile?`,
-							survivors.map((entry) => `${entry.name} [${entry.source}]`),
-						);
-						if (chosen === undefined) return;
-						replacement = chosen.split(" [")[0];
-					}
-					await deleteProfile(scopeInput, scope, name, { activeProfile: plan.profile, replacement });
-					if (name === plan.profile) {
-						if (replacement !== undefined) {
-							notify(`deleted "${name}" (${scope}); switching to ${replacement}`, "info");
-							await switchProfile(replacement, deps, { clearOverlay: true });
-						} else {
-							notify(`deleted the ${scope} record of "${name}"; reloading the revealed definition`, "info");
-							await switchProfile(plan.profile, deps, { reloadCurrent: true });
-						}
-					} else {
-						notify(`deleted profile "${name}" (${scope})`, "info");
-					}
+					const result = await applyOverlayMutation(deps, command.mutate);
+					for (const warning of result.warnings) notify(warning, "warning");
+					notify(`overlay updated: ${result.profile}`, "info");
 					return;
 				}
 				// Observability surface (ticket 07): bare /profile opens the
-				// selector; list/status render via a displayed custom message.
+				// selector; status renders via a displayed custom message.
 				const entries = await listProfiles({ realAgentDir: plan.agentDir, cwd: ctx.cwd });
-				if (subcommand === "list") {
-					pi.sendMessage({
-						customType: "pi-profile",
-						content: formatProfileList(entries, plan.profile),
-						display: true,
-						details: { kind: "list", profiles: entries },
-					});
-					return;
-				}
 				if (subcommand === "status") {
 					const { projectTrusted } = await readTrustInputs({ agentDir: plan.agentDir, cwd: ctx.cwd });
 					const stateDir = plan.source === "project" ? path.join(ctx.cwd, ".pi") : getGlobalStateDir(plan.agentDir);
@@ -338,13 +177,17 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 					});
 					return;
 				}
-				// Bare /profile: the interactive selector. Without dialog-capable
-				// UI (print mode), fall back to the list.
-				if (!ctx.hasUI) {
+				// Bare /profile: the interactive selector. Degradation boundary
+				// (delta "Observability surface"): outside TUI mode the selector
+				// does not run — the bare invocation degrades to the trust-gated
+				// list, carrying the structured payload the removed `list`
+				// subcommand emitted.
+				if (!ctx.hasUI || ctx.mode !== "tui") {
 					pi.sendMessage({
 						customType: "pi-profile",
 						content: formatProfileList(entries, plan.profile),
 						display: true,
+						details: { kind: "list", profiles: entries },
 					});
 					return;
 				}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-profile-switch",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Named profiles for Pi: reference skills, extensions, MCP servers, and tools per workflow, switched without restarting. Install: npm install -g pi-profile-switch (not pi install).",
   "type": "module",
   "keywords": [

package/src/launcher/initial-profile.ts

@@ -94,7 +94,7 @@ export async function readTrustInputs(context: LauncherContext): Promise<{
 export async function resolveInitialProfile(
 	name: string | undefined,
 	context: LauncherContext,
-	options?: { overlay?: RuntimeOverlay },
+	options?: { overlay?: RuntimeOverlay; liveToolNames?: string[] },
 ): Promise<InitialProfile> {
 	const { projectTrusted } = await readTrustInputs(context);
 	const projectDir = projectTrusted ? context.cwd : undefined;
@@ -133,7 +133,7 @@ export async function resolveInitialProfile(
 			((overlay.disabledSkills?.length ?? 0) > 0 ||
 				(overlay.disabledExtensions?.length ?? 0) > 0 ||
 				(overlay.disabledMcps?.length ?? 0) > 0 ||
-				overlay.tools !== undefined);
+				(overlay.disabledTools?.length ?? 0) > 0);
 		if (!narrowed) {
 			return { plan: defaultPlan(), projectTrusted, warnings };
 		}
@@ -153,6 +153,7 @@ export async function resolveInitialProfile(
 			skills: discovery.skills,
 			extensions: discovery.extensions,
 			overlay,
+			liveToolNames: options?.liveToolNames,
 		});
 		warnings.push(...discovery.extensions.warnings(), ...unmatchedWarnings(plan));
 		return { plan, discovery, projectDir, projectTrusted, warnings };
@@ -168,6 +169,7 @@ export async function resolveInitialProfile(
 			? await discoverAdapterServerNames(context.agentDir, projectDir)
 			: undefined,
 		overlay: options?.overlay,
+		liveToolNames: options?.liveToolNames,
 	});
 	warnings.push(...discovery.extensions.warnings(), ...unmatchedWarnings(plan));
 	if (plan.mcps !== undefined && !plan.extensions.some(isAdapterExtension)) {

package/src/profile-catalog.ts

@@ -89,8 +89,8 @@ function readOptionalString(value: unknown, field: string, profileName: string,
 	return value;
 }
 
-/** Parses one raw profile definition; exported for the write-side store
- *  (profile-catalog-store.ts) so anything written is loadable. */
+/** Parses one raw profile definition; the single read-time validator so
+ *  catalog files and any external writer stay loadable. */
 export function parseProfileDefinition(name: string, raw: unknown, filePath?: string): ProfileDefinition {
 	if (!isRecord(raw)) {
 		const prefix = filePath ? `${filePath}: ` : "";

package/src/profile-resolver.ts

@@ -67,6 +67,10 @@ export interface ActivationPlan {
 	extensions: Array<{ id: string; entry: string; origin?: "package" | "local" | "path" }>;
 	/** Expanded tool allowlist; undefined when the profile declares no tools. */
 	tools?: string[];
+	/** Overlay tool disable entries (names or globs, verbatim); undefined
+	 *  when the overlay disables no tools. The session-start application
+	 *  subtracts their live matches from the base expansion. */
+	disabledTools?: string[];
 	/** The raw tool references (globs included) for extension-side expansion
 	 *  against Pi's live tool registry, which includes extension-provided
 	 *  tools the pre-spawn expansion cannot know. Set iff `tools` is set. */
@@ -114,12 +118,54 @@ export interface ResolveInput {
 	 * any resolved reference may be narrowed or disabled.
 	 */
 	overlay?: RuntimeOverlay;
+	/**
+	 * Pi's live tool names (`pi.getAllTools()`), supplied by the in-session
+	 * switch path. Required when the overlay disables tools on a profile
+	 * without declared `tools` — the live registry is then the base set the
+	 * entries disable from. The launcher never passes an overlay, so it never
+	 * needs this.
+	 */
+	liveToolNames?: string[];
 }
 
 function isGlob(reference: string): boolean {
 	return reference.includes("*") || reference.includes("?");
 }
 
+/** Expands overlay disable entries against the names the profile resolved.
+ *  Entries are names or globs stored as written, re-expanded at every
+ *  resolution with the same matcher as profile references (ADR-0009 tiering):
+ *  an unmatched literal fails and identifies the entry; a zero-match glob is
+ *  reported through `onZeroMatch` instead of failing. Returns the resolved
+ *  names to disable. */
+function expandDisableEntries(
+	entries: string[],
+	activeNames: readonly string[],
+	kind: string,
+	profileName: string,
+	onZeroMatch: (entry: string) => void,
+): Set<string> {
+	const disabled = new Set<string>();
+	for (const entry of entries) {
+		if (isGlob(entry)) {
+			let matched = 0;
+			for (const name of activeNames) {
+				if (minimatch(name, entry)) {
+					disabled.add(name);
+					matched += 1;
+				}
+			}
+			if (matched === 0) onZeroMatch(entry);
+			continue;
+		}
+		if (!activeNames.includes(entry)) {
+			throw new ActivationError(`profile "${profileName}": overlay disables unknown ${kind} "${entry}"`);
+		}
+		disabled.add(entry);
+	}
+	return disabled;
+}
+
 /** Expands one reference list against a named universe. Literal misses fail
  *  when `literalMustExist`; globs expand to zero or more matches, and a
  *  zero-match glob is reported through `onZeroMatch`. */
@@ -195,42 +241,48 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 	);
 
 	// --- overlay narrowing (ticket 06) ---
-	// Overlay references must name resources the profile actually resolves
-	// (typos fail loudly). Overlays can disable any resolved extension.
-	let toolReferences = definition.tools;
+	// Overlay disable entries are names or globs stored as written and
+	// re-expanded at every resolution; unmatched literals fail and identify
+	// the entry, zero-match globs join `unmatched` with an `overlay ` prefix.
+	// Overlays can disable any resolved extension.
+	const toolReferences = definition.tools;
 	if (overlay !== undefined) {
 		if (overlay.disabledSkills !== undefined && overlay.disabledSkills.length > 0) {
-			const active = new Set(selectedSkills.map((skill) => skill.name));
-			for (const name of overlay.disabledSkills) {
-				if (!active.has(name)) {
-					throw new ActivationError(`profile "${profile.name}": overlay disables unknown skill "${name}"`);
-				}
-			}
-			const disabled = new Set(overlay.disabledSkills);
+			const disabled = expandDisableEntries(
+				overlay.disabledSkills,
+				selectedSkills.map((skill) => skill.name),
+				"skill",
+				profile.name,
+				(entry) => unmatched.push(`overlay skill:${entry}`),
+			);
 			selectedSkills = selectedSkills.filter((skill) => !disabled.has(skill.name));
 		}
 		if (overlay.disabledExtensions !== undefined && overlay.disabledExtensions.length > 0) {
-			const activeIds = new Set(planExtensions.map((entry) => entry.id));
-			for (const id of overlay.disabledExtensions) {
-				if (!activeIds.has(id)) {
-					throw new ActivationError(`profile "${profile.name}": overlay disables unknown extension "${id}"`);
-				}
-			}
-			const disabled = new Set(overlay.disabledExtensions);
+			const disabled = expandDisableEntries(
+				overlay.disabledExtensions,
+				planExtensions.map((entry) => entry.id),
+				"extension",
+				profile.name,
+				(entry) => unmatched.push(`overlay extension:${entry}`),
+			);
 			planExtensions = planExtensions.filter((entry) => !disabled.has(entry.id));
 		}
 		if (overlay.disabledMcps !== undefined && overlay.disabledMcps.length > 0) {
-			const active = new Set(mcps ?? []);
-			for (const name of overlay.disabledMcps) {
-				if (!active.has(name)) {
-					throw new ActivationError(`profile "${profile.name}": overlay disables unknown MCP server "${name}"`);
-				}
+			const active = mcps ?? [];
+			const disabled = expandDisableEntries(
+				overlay.disabledMcps,
+				active,
+				"MCP server",
+				profile.name,
+				(entry) => unmatched.push(`overlay mcp:${entry}`),
+			);
+			// A profile that declared no `mcps` has no MCP restriction; overlay
+			// narrowing must not turn that into an empty whitelist. Literals
+			// still fail and zero-match globs still warn — the expansion above
+			// runs either way — only the reassignment is guarded.
+			if (mcps !== undefined) {
+				mcps = active.filter((name) => !disabled.has(name));
 			}
-			const disabled = new Set(overlay.disabledMcps);
-			mcps = (mcps ?? []).filter((name) => !disabled.has(name));
-		}
-		if (overlay.tools !== undefined) {
-			toolReferences = overlay.tools;
 		}
 	}
 
@@ -241,6 +293,40 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 		});
 	}
 
+	// Tool disable entries join the uniform grammar: the base set is the
+	// profile's resolved tool references when declared (expanded against the
+	// live registry, which the in-session switch path always supplies) and
+	// the live registry itself when the profile declares no tools. The
+	// plan carries the entries verbatim; session-start application subtracts
+	// their live matches from the base expansion at that moment.
+	let disabledTools: string[] | undefined;
+	if (overlay?.disabledTools !== undefined && overlay.disabledTools.length > 0) {
+		if (input.liveToolNames === undefined) {
+			throw new ActivationError(
+				`profile "${profile.name}": overlay disables tools but no live tool registry is available`,
+			);
+		}
+		const base =
+			toolReferences !== undefined
+				? expandReferences(toolReferences, input.liveToolNames, (name) => name, "tool", {
+						literalMustExist: false,
+					})
+				: input.liveToolNames;
+		const disabled = expandDisableEntries(
+			overlay.disabledTools,
+			base,
+			"tool",
+			profile.name,
+			(entry) => unmatched.push(`overlay tool:${entry}`),
+		);
+		disabledTools = [...overlay.disabledTools];
+		// The pre-computed boot baseline additionally subtracts the disabled
+		// matches (a no-op for tools only the live registry knows).
+		if (tools !== undefined) {
+			tools = tools.filter((name) => !disabled.has(name));
+		}
+	}
+
 	let model: ProfileModel | undefined;
 	const declaredModel = extractModel(definition);
 	if (declaredModel !== undefined) {
@@ -267,6 +353,7 @@ export async function resolveProfile(input: ResolveInput): Promise<ActivationPla
 		skills: selectedSkills,
 		extensions: planExtensions.map((entry) => ({ id: entry.id, entry: entry.entry })),
 		...(tools !== undefined && toolReferences !== undefined ? { tools, toolReferences: [...toolReferences] } : {}),
+		...(disabledTools !== undefined ? { disabledTools } : {}),
 		...(model !== undefined ? { model } : {}),
 		...(definition.instructions !== undefined ? { instructions: definition.instructions } : {}),
 		...(mcps !== undefined ? { mcps } : {}),

package/src/runtime-state-store.ts

@@ -32,14 +32,13 @@ export interface RuntimeOverlay {
 	disabledSkills?: string[];
 	disabledExtensions?: string[];
 	disabledMcps?: string[];
-	/** Replaces the profile's tool references when set. */
-	tools?: string[];
+	disabledTools?: string[];
 }
 
 function parseOverlay(value: unknown): RuntimeOverlay | undefined {
 	if (!isRecord(value)) return undefined;
 	const overlay: RuntimeOverlay = {};
-	for (const key of ["disabledSkills", "disabledExtensions", "disabledMcps", "tools"] as const) {
+	for (const key of ["disabledSkills", "disabledExtensions", "disabledMcps", "disabledTools"] as const) {
 		const list = value[key];
 		if (Array.isArray(list) && list.every((entry) => typeof entry === "string")) {
 			overlay[key] = list;
@@ -77,7 +76,7 @@ export class RuntimeStateStore {
 	}
 
 	/** Read-modify-write merge. A field set to `undefined` is deleted; absent
-	 *  fields keep their stored value. Used by the switch/customize paths so
+	 *  fields keep their stored value. Used by the switch/overlay paths so
 	 *  one concern (selection, anchor, overlay) never clobbers another. */
 	async update(patch: Partial<RuntimeState>): Promise<RuntimeState> {
 		const current = await this.read();

package/src/settings-generator.ts

@@ -401,6 +401,7 @@ export async function writeRuntimeFiles(
 				agentDir: options.agentDir,
 				...(plan.tools !== undefined ? { tools: plan.tools } : {}),
 				...(plan.toolReferences !== undefined ? { toolReferences: plan.toolReferences } : {}),
+				...(plan.disabledTools !== undefined ? { disabledTools: plan.disabledTools } : {}),
 				...(plan.mcps !== undefined ? { mcps: plan.mcps } : {}),
 				// The resolved sets feed /profile status (absolute paths) and the
 				// glob-delta diff against the previous activation.

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() };
-}