pi-profile-switch 0.9.1 → 0.10.0

package/src/project-trust.ts

@@ -76,11 +76,14 @@ export function resolveProjectTrust(input: ProjectTrustInput): boolean {
 	return input.userDefaultProjectTrust === "always";
 }
 
-/** pi-profile's own project files are trust-requiring even though Pi's
- *  native list doesn't know them: a committed catalog/state file would
- *  otherwise inject profile definitions (and instructions) unguarded. */
-function hasPiProfileProjectFiles(cwd: string): boolean {
-	return ["profiles", "pi-profile-state.json"].some((name) =>
-		existsSync(path.join(cwd, ".pi", name)),
-	);
+/** pi-profile's own project files, relative to the project's `.pi`
+ *  directory. They are trust-requiring even though Pi's native list doesn't
+ *  know them: a committed catalog/state file would otherwise inject profile
+ *  definitions (and instructions) unguarded. Exported so the launcher's
+ *  untrusted-project diagnostic names exactly the files the trust gate
+ *  skips — the two must never drift apart. */
+export const PI_PROFILE_PROJECT_FILES = ["profiles", "pi-profile-state.json"] as const;
+
+export function hasPiProfileProjectFiles(cwd: string): boolean {
+	return PI_PROFILE_PROJECT_FILES.some((name) => existsSync(path.join(cwd, ".pi", name)));
 }

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/starter-assets.ts

@@ -17,25 +17,25 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { getGlobalProfilesDir } from "./workspace.ts";
 
 export interface StarterAssetFileResult {
-	/** 目标文件绝对路径 */
+	/** Absolute path of the target file */
 	path: string;
-	/** 本次调用是否发生了写入 */
+	/** Whether this call performed a write */
 	written: boolean;
 }
 
 export interface StarterAssetsResult {
 	profile: StarterAssetFileResult;
 	skill: StarterAssetFileResult;
-	/** 人类可读的降级警告；为空表示全部成功或无操作 */
+	/** Human-readable degradation warnings; empty means all succeeded or no-op */
 	warnings: string[];
 }
 
 export interface EnsureStarterAssetsOptions {
-	/** 默认 getGlobalProfilesDir()；测试注入 */
+	/** Defaults to getGlobalProfilesDir(); injected by tests */
 	globalProfilesDir?: string;
-	/** 默认 Pi 的 getAgentDir()；测试注入 */
+	/** Defaults to Pi's getAgentDir(); injected by tests */
 	agentDir?: string;
-	/** 默认由 import.meta.url 定位包根；测试注入 */
+	/** Defaults to locating the package root from import.meta.url; injected by tests */
 	packageRoot?: string;
 }
 

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