pi-profile-switch 0.1.0 → 0.2.0

package/README.md

@@ -4,7 +4,7 @@
 
 Named profiles for [Pi](https://github.com/badlogic/pi-mono). A profile selects what the model sees and which capabilities the session uses — skills, MCP servers, tools, a model preset, and extra instructions — switchable in the same Pi process.
 
-Use a lean read-only profile for code review, a full-powered one for implementation, a minimal one for a quick question.
+A shipped `read-only` preset covers the read-and-report workflow; other workflows you write yourself — a profile can narrow the tool set, hide skills, pin a model, or add instructions.
 
 `pi-profile-switch` is a plain Pi package (ADR-0007). It installs like any other extension, leaves Pi's configuration directory untouched, and keeps sessions, packages, project trust, and every other installed extension native.
 
@@ -23,32 +23,36 @@ Requires [Pi](https://www.npmjs.com/package/@earendil-works/pi-coding-agent) (in
 pi
 
 # Use a profile for this run only (not saved)
-pi --profile review
+pi --profile read-only
 
 # The explicit native baseline
 pi --profile default
 ```
 
-Define profiles in `~/.pi/agent/profiles.json` (global) or `<project>/.pi/profiles.json` (project, trusted projects only):
+Create profiles with `/profile create`, which writes `~/.pi/agent/profiles.json` (global) or `<project>/.pi/profiles.json` (project, trusted projects only). The wizard offers the shipped `read-only` preset — Pi's built-in tools only, no skills, MCP servers, or model assumed — or a blank definition:
 
 ```json
 {
-  "schemaVersion": 2,
+  "schemaVersion": 1,
   "profiles": {
-    "review": {
-      "label": "Code review",
-      "skills": ["code-review"],
-      "mcp": ["github"],
-      "tools": ["read", "grep", "find", "bash"],
-      "instructions": "Review only; do not modify files."
+    "read-only": {
+      "label": "Read-only",
+      "description": "Read-only session; no skills or MCP servers assumed — add your own.",
+      "tools": [
+        "read",
+        "grep",
+        "find",
+        "ls"
+      ],
+      "instructions": "Read-only session: inspect and report; never create, edit, rename, or delete files.\nIf a change is needed, describe it in your reply instead of applying it.\nDo not run commands that modify state (installs, formatters, commits, pushes, network writes).\nPrefer an available skill or MCP tool when it fits the request; otherwise use the tools you have.\nGround claims in evidence: cite file:line and separate verified facts from inferences.\nReply in English."
     }
   }
 }
 ```
 
-Profiles **reference** resources by name — they never copy them. Full schema with more examples: [`examples/profiles.json`](examples/profiles.json).
+A preset is a one-time copy into your catalog: it is not tracked, so a package update never changes a profile you already created. Profiles **reference** resources by name — they never copy them. [`examples/profiles.json`](examples/profiles.json) is that same preset as a catalog; the field reference is [`schemas/profiles.schema.json`](schemas/profiles.schema.json).
 
-Existing `schemaVersion: 1` catalogs keep working: the `extensions` field is reported once and ignored, because extensions now load natively in every profile.
+`schemaVersion` is 1. A profile cannot select extensions: they load natively in every profile, so manage them with `pi install`.
 
 ## What a profile controls
 
@@ -75,6 +79,8 @@ In the TUI, the `/profile` command family manages everything in-session:
 | `/profile customize` / `/profile reset` | Narrow the active profile for this session only |
 | `/mcp enable\|disable <server>` | Toggle MCP servers in the active profile |
 
+While a non-`default` profile is active, the footer shows `profile: <name>`, with `*` appended when a session-only overlay is in effect. `default` shows no badge, so an unprofiled session keeps Pi's native footer.
+
 All commands work in non-interactive modes (`--mode rpc|print|json`); CRUD wizards are TUI-only.
 
 ## Guarantees
@@ -84,18 +90,6 @@ All commands work in non-interactive modes (`--mode rpc|print|json`); CRUD wizar
 - **Fail safe** — untrusted project directories are never read; a failed activation applies nothing and reports the cause.
 - **No reload** — switching re-applies runtime state in place; the next turn's prompt carries the new selection.
 
-## Migrating from the launcher
-
-```bash
-pi-profile review          # before
-pi --profile review        # after
-
-pi-profile review -- --mode rpc   # before
-pi --profile review --mode rpc    # after
-```
-
-`/profile reload` and the `/profile resource` commands are gone: skills are read on demand and catalogs are re-read on every use, so there is nothing to reload. Remove leftover `~/.pi/agent/pi-profile/runtime/` directories; the extension no longer creates them.
-
 ## Docs
 
 - [Architecture](docs/architecture/overview.md) · [ADRs](docs/adr/) · [Glossary](CONTEXT.md) (Chinese)

package/README.zh-CN.md

@@ -4,7 +4,7 @@
 
 [Pi](https://github.com/badlogic/pi-mono) 的命名 profile 扩展。一个 profile 选择模型看到什么、会话使用哪些能力——skills、MCP server、tools、预制模型和附加指令——并在同一 Pi 进程内即时切换。
 
-代码评审用精简的只读 profile，实现需求用全量 profile，临时提问用最小 profile。
+随包提供一个 `read-only` 预设覆盖「读代码 + 报告」的工作流；其余工作流由你自己定义——profile 可以收窄工具集、隐藏 skill、固定模型或附加指令。
 
 `pi-profile-switch` 是普通 Pi package（ADR-0007）：像其他扩展一样安装，不改动 Pi 的配置目录，session、packages、项目信任和其他扩展全部保持原生。
 
@@ -23,32 +23,36 @@ pi install npm:pi-profile-switch
 pi
 
 # 仅本次启动使用指定 profile（不保存）
-pi --profile review
+pi --profile read-only
 
 # 显式的原生基线
 pi --profile default
 ```
 
-在 `~/.pi/agent/profiles.json`（全局）或 `<项目>/.pi/profiles.json`（项目级，仅限已信任项目）中定义 profile：
+用 `/profile create` 创建 profile，写入 `~/.pi/agent/profiles.json`（全局）或 `<项目>/.pi/profiles.json`（项目级，仅限已信任项目）。向导提供随包的 `read-only` 预设——只用 Pi 内建工具，不假设任何 skill、MCP server 或模型——也可以从空定义开始：
 
 ```json
 {
-  "schemaVersion": 2,
+  "schemaVersion": 1,
   "profiles": {
-    "review": {
-      "label": "Code review",
-      "skills": ["code-review"],
-      "mcp": ["github"],
-      "tools": ["read", "grep", "find", "bash"],
-      "instructions": "Review only; do not modify files."
+    "read-only": {
+      "label": "Read-only",
+      "description": "Read-only session; no skills or MCP servers assumed — add your own.",
+      "tools": [
+        "read",
+        "grep",
+        "find",
+        "ls"
+      ],
+      "instructions": "Read-only session: inspect and report; never create, edit, rename, or delete files.\nIf a change is needed, describe it in your reply instead of applying it.\nDo not run commands that modify state (installs, formatters, commits, pushes, network writes).\nPrefer an available skill or MCP tool when it fits the request; otherwise use the tools you have.\nGround claims in evidence: cite file:line and separate verified facts from inferences.\nReply in English."
     }
   }
 }
 ```
 
-Profile 只**引用**资源，从不复制资源。完整示例见 [`examples/profiles.json`](examples/profiles.json)。
+预设只被复制一次：它不被跟踪，包升级不会改动你已经创建的 profile。Profile 只**引用**资源，从不复制资源。[`examples/profiles.json`](examples/profiles.json) 就是同一个预设构成的 catalog；字段参考见 [`schemas/profiles.schema.json`](schemas/profiles.schema.json)。
 
-已有的 `schemaVersion: 1` catalog 继续可用：`extensions` 字段会被警告一次并忽略——extensions 现在在所有 profile 中原生加载。
+`schemaVersion` 为 1。Profile 不选择 extension：extensions 在所有 profile 中原生加载，请用 `pi install` 管理。
 
 ## Profile 控制的范围
 
@@ -75,6 +79,8 @@ Profile 只**引用**资源，从不复制资源。完整示例见 [`examples/pr
 | `/profile customize` / `/profile reset` | 仅本次会话收窄活动 profile |
 | `/mcp enable\|disable <server>` | 在活动 profile 中开关 MCP server |
 
+活动 profile 不是 `default` 时，footer 显示 `profile: <name>`；本次会话的 overlay 生效时追加 `*`。`default` 不显示 badge，未使用 profile 的会话保持 Pi 原生 footer。
+
 非交互模式（`--mode rpc|print|json`）下命令同样生效；CRUD 向导仅 TUI 可用。
 
 ## 保证
@@ -84,18 +90,6 @@ Profile 只**引用**资源，从不复制资源。完整示例见 [`examples/pr
 - **失败安全**——未信任的项目目录从不读取；激活失败时不应用任何设置并报出原因。
 - **无 reload**——切换在原位重新应用运行时状态；下一个 turn 的 prompt 直接带上新选择。
 
-## 从 launcher 迁移
-
-```bash
-pi-profile review          # 旧
-pi --profile review        # 新
-
-pi-profile review -- --mode rpc   # 旧
-pi --profile review --mode rpc    # 新
-```
-
-`/profile reload` 与 `/profile resource` 命令已移除：skill 内容按需读取、catalog 每次使用重新读取，没有需要 reload 的缓存。删除遗留的 `~/.pi/agent/pi-profile/runtime/` 目录；新版本不再创建它们。
-
 ## 文档
 
 - [架构设计](docs/architecture/overview.md) · [ADR](docs/adr/) · [术语表](CONTEXT.md)

package/examples/profiles.json

@@ -1,38 +1,16 @@
 {
-  "schemaVersion": 2,
+  "schemaVersion": 1,
   "profiles": {
-    "review": {
-      "label": "Code review",
-      "description": "Read-heavy review workflow",
-      "skills": [
-        "code-review",
-        "diagnosing-bugs"
-      ],
-      "mcp": [
-        "github"
-      ],
+    "read-only": {
+      "label": "Read-only",
+      "description": "Read-only session; no skills or MCP servers assumed — add your own.",
       "tools": [
         "read",
         "grep",
         "find",
-        "bash"
-      ],
-      "instructions": "Review only; do not modify files."
-    },
-    "impl": {
-      "label": "Implementation",
-      "skills": [
-        "tdd"
-      ],
-      "mcp": [
-        "github",
-        "linear"
+        "ls"
       ],
-      "model": {
-        "provider": "deepseek",
-        "id": "deepseek-v4-pro",
-        "thinkingLevel": "high"
-      }
+      "instructions": "Read-only session: inspect and report; never create, edit, rename, or delete files.\nIf a change is needed, describe it in your reply instead of applying it.\nDo not run commands that modify state (installs, formatters, commits, pushes, network writes).\nPrefer an available skill or MCP tool when it fits the request; otherwise use the tools you have.\nGround claims in evidence: cite file:line and separate verified facts from inferences.\nReply in English."
     }
   }
 }

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

@@ -9,13 +9,16 @@ import {
 import { discoverAdapterServerNames } from "../../src/mcp-config.ts";
 import { probeAdapterPresence } from "../../src/mcp-coordination.ts";
 import { readSessionChoices } from "../../src/model-selection.ts";
+import { buildProfileBadge, PROFILE_STATUS_KEY, renderProfileBadge } from "../../src/profile-badge.ts";
 import type { ProfileDefinition } from "../../src/profile-catalog.ts";
 import {
 	formatSelectionWarnings,
+	formatSkillWarnings,
+	skillWarnings,
 	type LiveResources,
 	type ResolvedSelection,
 } from "../../src/profile-resolver.ts";
-import { RuntimeStateStore, stateDirFor, type RuntimeOverlay } from "../../src/runtime-state-store.ts";
+import { RuntimeStateStore, overlayNarrows, stateDirFor, type RuntimeOverlay } from "../../src/runtime-state-store.ts";
 import {
 	applySkillsFilter,
 	formatInstructionsBlock,
@@ -69,6 +72,8 @@ import { buildStatusReport, formatStatusMarkdown } from "../../src/switching/sta
  *   instructions. Unselected skills stay loaded and `/skill:`-invocable.
  * - `/profile …` command family and `/mcp enable|disable`.
  * - Retry pending tool literals each turn until MCP/extension tools register.
+ * - Footer badge: `profile: <name>` (plus `*` for a runtime overlay) in Pi's
+ *   footer status line while a non-`default` profile is active.
  */
 
 type ContextWithOptions = ExtensionContext & { getSystemPromptOptions?: () => BuildSystemPromptOptions };
@@ -77,6 +82,21 @@ type ContextWithOptions = ExtensionContext & { getSystemPromptOptions?: () => Bu
 interface Activation {
 	selection: ResolvedSelection;
 	skillsOutcome?: SkillsFilterOutcome;
+	/** Whether the skill references were checked against Pi's loaded set.
+	 *  False after a startup activation: `session_start`'s event context
+	 *  cannot read that list, so the check moves to the first turn. */
+	skillsChecked: boolean;
+	/** The overlay this runtime was activated with, when one is in effect. */
+	overlay?: RuntimeOverlay;
+}
+
+/** Maps an activation result onto the runtime state `current` mirrors. */
+function activationOf(result: ActivationResult, skillsChecked: boolean): Activation {
+	return {
+		selection: result.selection,
+		skillsChecked,
+		...(result.overlay === undefined ? {} : { overlay: result.overlay }),
+	};
 }
 
 /** Subcommands that mutate a catalog; they need dialog-capable UI. */
@@ -98,6 +118,33 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 	const explicit = detectExplicitDeclarations(process.argv.slice(2));
 	let current: Activation | undefined;
 	let filterWarningShown = false;
+	/** The last badge written to the footer, so a refresh only talks to Pi
+	 *  when the rendering actually changed. */
+	let badgeText: string | undefined;
+
+	/** The only writer of `current`'s profile identity (`selection.name` and
+	 *  `overlay`) and of the footer badge. Both mirror the selection this
+	 *  runtime applied, so a failed activation (which throws before reaching
+	 *  here) never claims to be active. The per-turn updates (`pendingTools`,
+	 *  `skillsOutcome`) leave the identity and the badge untouched. */
+	function setCurrent(ctx: ExtensionContext, next: Activation | undefined): void {
+		current = next;
+		refreshBadge(ctx);
+	}
+
+	/** Re-renders the badge from `current`. `default` and an unapplied profile
+	 *  render no badge, which removes Pi's footer status line entirely. */
+	function refreshBadge(ctx: ExtensionContext): void {
+		if (!ctx.hasUI) return;
+		const badge =
+			current === undefined
+				? undefined
+				: buildProfileBadge(current.selection.name, { overlay: overlayNarrows(current.overlay) });
+		const text = badge === undefined ? undefined : renderProfileBadge(badge, ctx.ui.theme);
+		if (text === badgeText) return;
+		badgeText = text;
+		ctx.ui.setStatus(PROFILE_STATUS_KEY, text);
+	}
 
 	const surface = (ctx: ExtensionContext): ApplySurface => ({
 		getAllTools: () => pi.getAllTools(),
@@ -120,8 +167,10 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 	}
 
 	async function loadLive(ctx: ExtensionContext, projectTrusted: boolean): Promise<LiveResources> {
+		// Only command contexts expose the system-prompt options; the
+		// `session_start` event context has no accessor, so the loaded skills
+		// stay unknown there and their existence check moves to the first turn.
 		const options = (ctx as ContextWithOptions).getSystemPromptOptions?.();
-		const skills = (options?.skills ?? []).map((skill) => ({ name: skill.name, filePath: skill.filePath }));
 		const adapterPresent = probeAdapterPresence(pi.events);
 		let servers: string[] = [];
 		if (adapterPresent) {
@@ -131,7 +180,13 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 				notify(ctx, error instanceof Error ? error.message : String(error), "warning");
 			}
 		}
-		return { skills, toolNames: pi.getAllTools().map((tool) => tool.name), mcp: { adapterPresent, servers } };
+		return {
+			...(options?.skills === undefined
+				? {}
+				: { skills: options.skills.map((skill) => ({ name: skill.name, filePath: skill.filePath })) }),
+			toolNames: pi.getAllTools().map((tool) => tool.name),
+			mcp: { adapterPresent, servers },
+		};
 	}
 
 	/** Builds the dependencies for one activation. `force` marks an explicit
@@ -162,20 +217,17 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 			overlay: options?.overlay ?? null,
 			persist: options?.persist ?? true,
 		});
-		current = { selection: result.selection };
-		reportWarnings(ctx, result.warnings);
+		setCurrent(ctx, activationOf(result, deps.live.skills !== undefined));
 		reportWarnings(ctx, formatSelectionWarnings(result.selection));
 		return result;
 	}
 
 	async function profileEntries(ctx: ExtensionContext): Promise<ProfileListEntry[]> {
-		const { entries, warnings } = await listProfiles({
+		return listProfiles({
 			realAgentDir: getAgentDir(),
 			cwd: ctx.cwd,
 			projectTrusted: ctx.isProjectTrusted(),
 		});
-		reportWarnings(ctx, warnings);
-		return entries;
 	}
 
 	function sendListMessage(entries: ProfileListEntry[]): void {
@@ -219,7 +271,12 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 			const wizard = await runProfileCreateWizard(ctx.ui, { projectTrusted: scopeInput.projectTrusted });
 			if (wizard === undefined) return;
 			await createProfile(scopeInput, wizard.scope, wizard.name, wizard.definition);
-			notify(ctx, `created profile "${wizard.name}" (${wizard.scope}) — activate with /profile use ${wizard.name}`, "info");
+			const origin = wizard.preset !== undefined ? ` from preset "${wizard.preset}"` : "";
+			notify(
+				ctx,
+				`created profile "${wizard.name}" (${wizard.scope})${origin} — activate with /profile use ${wizard.name}`,
+				"info",
+			);
 			return;
 		}
 		if (subcommand === "duplicate") {
@@ -307,7 +364,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 	}
 
 	pi.on("session_start", async (_event, ctx) => {
-		current = undefined;
+		setCurrent(ctx, undefined);
 		filterWarningShown = false;
 		const agentDir = getAgentDir();
 		const projectTrusted = ctx.isProjectTrusted();
@@ -351,6 +408,39 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 				},
 			};
 		}
+		// A startup activation cannot see Pi's skill list, so its references are
+		// checked here, on the first turn that carries the complete set — by then
+		// `resources_discover` has contributed every extension's skills. The
+		// corrected warnings replace the (empty) startup ones, so `/profile
+		// status` reports the same thing the user was told.
+		if (!current.skillsChecked) {
+			const refs = current.selection.skills?.refs;
+			const corrected =
+				refs === undefined || refs === "all"
+					? undefined
+					: skillWarnings(
+							refs,
+							(event.systemPromptOptions.skills ?? []).map((skill) => ({
+								name: skill.name,
+								filePath: skill.filePath,
+							})),
+						);
+			current = {
+				...current,
+				skillsChecked: true,
+				...(corrected === undefined
+					? {}
+					: { selection: { ...current.selection, warnings: { ...current.selection.warnings, ...corrected } } }),
+			};
+			if (corrected !== undefined) {
+				reportWarnings(ctx, formatSkillWarnings(current.selection.name, corrected));
+			}
+		}
+		// Pi has no extension-visible theme-change event and footer statuses are
+		// stored as finished strings, so re-render once per turn: a `/theme`
+		// switch is picked up without waiting for the next profile change.
+		// `refreshBadge` dedupes, so an unchanged badge sends nothing.
+		refreshBadge(ctx);
 		const filtered = applySkillsFilter({
 			systemPrompt: event.systemPrompt,
 			options: event.systemPromptOptions,
@@ -418,8 +508,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 						const deps = await activationDeps(ctx, false);
 						const target = { profile: { name: current.selection.name, source: current.selection.source } };
 						const result = await customizeOverlay({ ...deps, ...target }, parseCustomizeArgs(rest.join(" ")));
-						current = { selection: result.selection };
-						reportWarnings(ctx, result.warnings);
+						setCurrent(ctx, activationOf(result, deps.live.skills !== undefined));
 						notify(ctx, `overlay updated: ${result.selection.name}`, "info");
 						return;
 					}
@@ -431,8 +520,7 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 						const deps = await activationDeps(ctx, false);
 						const target = { profile: { name: current.selection.name, source: current.selection.source } };
 						const result = await resetOverlay({ ...deps, ...target });
-						current = { selection: result.selection };
-						reportWarnings(ctx, result.warnings);
+						setCurrent(ctx, activationOf(result, deps.live.skills !== undefined));
 						notify(ctx, `overlay cleared: ${result.selection.name}`, "info");
 						return;
 					}

package/package.json

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

package/schemas/profiles.schema.json

@@ -10,6 +10,7 @@
   "additionalProperties": false,
   "properties": {
     "schemaVersion": {
+      "description": "1 is current. 2 is the number v0.1.0 wrote for the same field shape and still reads; saves always write 1.",
       "enum": [1, 2]
     },
     "profiles": {
@@ -48,7 +49,7 @@
           "items": {
             "type": "string"
           },
-          "description": "Deprecated (schemaVersion 1). Extensions are always loaded natively (ADR-0007); the field is ignored with a warning."
+          "description": "Ignored. Extensions always load natively (ADR-0007) and are managed with pi install; the field is accepted so existing catalogs keep validating."
         },
         "mcp": {
           "type": "array",

package/src/profile-badge.ts

@@ -0,0 +1,142 @@
+/**
+ * Profile badge: the persistent, one-line answer to "which profile is this
+ * session running?".
+ *
+ * Presentation only — no state, no I/O, no activation. The extension decides
+ * when a badge is written (after an activation that succeeded, via
+ * `ctx.ui.setStatus(PROFILE_STATUS_KEY, …)`), so the badge can never claim a
+ * selection that was not applied.
+ *
+ * One canonical rendering, shared with the `/profile status` heading
+ * (`profile: <name>`), plus `*` when a runtime overlay is in effect — the only
+ * runtime difference the catalog does not show.
+ */
+
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+
+import { DEFAULT_PROFILE_NAME } from "./profile-catalog.ts";
+
+/**
+ * Status key in Pi's footer. Pi joins all extension statuses into one line,
+ * orders them by key, and truncates that line from the right — so an earlier
+ * key keeps its text visible on a narrow terminal. `active-profile` sorts
+ * before the keys it shares the line with (`mcp`, `pi-…`, `thinking`).
+ */
+export const PROFILE_STATUS_KEY = "active-profile";
+
+/** The label prefix, matching the `/profile status` heading. */
+export const PROFILE_BADGE_LABEL = "profile";
+
+/**
+ * Display columns reserved for the name before it is elided. The footer is a
+ * shared, fixed-width line: profile names are unbounded user input, so an
+ * unelided name would evict the statuses of other extensions.
+ */
+export const PROFILE_BADGE_NAME_COLUMNS = 16;
+
+const ELLIPSIS = "…";
+
+export interface ProfileBadge {
+	/** The name `/profile use` accepts (never the display `label`). */
+	name: string;
+	/** A runtime overlay is in effect: this runtime differs from the catalog. */
+	overlay: boolean;
+}
+
+/** The minimum theme surface the badge needs; `ctx.ui.theme` satisfies it. */
+export interface BadgeTheme {
+	fg(color: ThemeColor, text: string): string;
+}
+
+export interface BadgeOptions {
+	overlay: boolean;
+	/** Override the name budget (tests, future width awareness). */
+	nameColumns?: number;
+}
+
+/**
+ * Builds the badge for a resolved profile, or `undefined` when there must be
+ * no badge at all.
+ *
+ * `default` is Pi's native baseline — it declares nothing — so it must not
+ * change the footer either: a plain Pi session shows no badge, and the footer
+ * status line only exists while some extension status is set.
+ */
+export function buildProfileBadge(name: string, options: BadgeOptions): ProfileBadge | undefined {
+	if (name === DEFAULT_PROFILE_NAME) return undefined;
+	return {
+		name: truncateToColumns(name, options.nameColumns ?? PROFILE_BADGE_NAME_COLUMNS),
+		overlay: options.overlay,
+	};
+}
+
+/**
+ * Renders the badge. Colors come from the caller's theme at render time: Pi
+ * stores footer statuses as finished strings, so the extension re-renders on
+ * profile changes and on each turn (there is no extension-visible theme-change
+ * event).
+ */
+export function renderProfileBadge(badge: ProfileBadge, theme: BadgeTheme): string {
+	const label = theme.fg("dim", `${PROFILE_BADGE_LABEL}: `);
+	const name = theme.fg("dim", badge.name);
+	return badge.overlay ? `${label}${name}${theme.fg("warning", "*")}` : `${label}${name}`;
+}
+
+/* -------------------------------------------------------------------------- */
+/* Display width                                                              */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Width of one code point in terminal columns: 2 for East Asian wide and
+ * fullwidth code points, 1 otherwise. Zero-width joiners and combining marks
+ * are counted as 1 — an approximation that only over-reserves space for
+ * exotic names.
+ */
+export function codePointWidth(codePoint: number): number {
+	return isWide(codePoint) ? 2 : 1;
+}
+
+/** Display width of `text` in terminal columns. */
+export function displayWidth(text: string): number {
+	let width = 0;
+	for (const character of text) width += codePointWidth(character.codePointAt(0)!);
+	return width;
+}
+
+/**
+ * Truncates `text` to at most `columns` terminal columns, appending `…` when
+ * something was dropped. The ellipsis is part of the budget, so the result
+ * never exceeds `columns`.
+ */
+export function truncateToColumns(text: string, columns: number, ellipsis = ELLIPSIS): string {
+	if (columns <= 0) return "";
+	if (displayWidth(text) <= columns) return text;
+	const budget = columns - displayWidth(ellipsis);
+	let result = "";
+	let width = 0;
+	for (const character of text) {
+		const next = width + codePointWidth(character.codePointAt(0)!);
+		if (next > budget) break;
+		result += character;
+		width = next;
+	}
+	return budget < 0 ? "" : `${result}${ellipsis}`;
+}
+
+function isWide(codePoint: number): boolean {
+	return (
+		(codePoint >= 0x1100 && codePoint <= 0x115f) || // Hangul Jamo
+		(codePoint >= 0x2e80 && codePoint <= 0x303e) || // CJK radicals, Kangxi, CJK symbols
+		(codePoint >= 0x3041 && codePoint <= 0x33ff) || // kana, CJK compatibility, CJK punctuation
+		(codePoint >= 0x3400 && codePoint <= 0x4dbf) || // CJK unified ideographs extension A
+		(codePoint >= 0x4e00 && codePoint <= 0x9fff) || // CJK unified ideographs
+		(codePoint >= 0xa000 && codePoint <= 0xa4cf) || // Yi syllables
+		(codePoint >= 0xac00 && codePoint <= 0xd7a3) || // Hangul syllables
+		(codePoint >= 0xf900 && codePoint <= 0xfaff) || // CJK compatibility ideographs
+		(codePoint >= 0xfe30 && codePoint <= 0xfe6f) || // CJK compatibility forms
+		(codePoint >= 0xff00 && codePoint <= 0xff60) || // fullwidth forms
+		(codePoint >= 0xffe0 && codePoint <= 0xffe6) || // fullwidth signs
+		(codePoint >= 0x1f300 && codePoint <= 0x1faff) || // emoji, pictographs
+		(codePoint >= 0x20000 && codePoint <= 0x3fffd) // CJK unified ideographs extension B+
+	);
+}

package/src/profile-catalog-store.ts

@@ -3,9 +3,8 @@
  * separate from the read-only ProfileCatalog.
  *
  * Invariants:
- * - Whole-file overwrites (pretty-printed, `schemaVersion 2` envelope).
- *   A version 1 file is read with its `extensions` fields dropped and is
- *   rewritten as version 2 on the next save; wizard saves never block on
+ * - Whole-file overwrites (pretty-printed, `schemaVersion 1` envelope, the
+ *   constant owned by profile-catalog.ts). Wizard saves never block on
  *   concurrent edits — re-read at write time, same-name conflicts resolve
  *   last-write-wins.
  * - Definitions are complete and self-contained: no inheritance fields
@@ -38,7 +37,7 @@ export class ProfileCatalogStore {
 
 	/** Validated definitions: missing file → empty; malformed → CatalogError
 	 *  (catalog errors never pass silently, even on the write path).
-	 *  Version 1 files load with `extensions` dropped. */
+	 *  Unknown fields (a legacy `extensions` declaration) are dropped. */
 	async readDefinitions(): Promise<Map<string, ProfileDefinition>> {
 		const result = await readJsonFile(this.#filePath);
 		if (!result.ok) {
@@ -48,7 +47,7 @@ export class ProfileCatalogStore {
 		if (!isRecord(result.value)) {
 			throw new CatalogError(`${this.#filePath}: catalog must be an object`);
 		}
-		return parseCatalogDocument(result.value, this.#filePath).profiles;
+		return parseCatalogDocument(result.value, this.#filePath);
 	}
 
 	/** Overwrites the file with the given definitions (last write wins). */

package/src/profile-catalog.ts

@@ -7,9 +7,11 @@
  * - A profile references skills, MCP servers, and tools, and may declare
  *   instructions and a model preset. Extensions are not a profile resource:
  *   every installed extension loads natively in every profile.
- * - schemaVersion 2 is current. Version 1 files load with their per-profile
- *   `extensions` field ignored and a warning, so existing catalogs keep
- *   working without an edit.
+ * - schemaVersion 1 is current. Version 2 describes the same fields — the
+ *   number only marked the era in which `extensions` was still a profile
+ *   resource — and reads the same; every save writes version 1.
+ * - A legacy `extensions` field is ignored silently, like any other unknown
+ *   field: extensions load natively and are managed with `pi install`.
  *
  * Invariants:
  * - The built-in `default` profile never exists in either file and cannot be
@@ -27,7 +29,9 @@ import path from "node:path";
 
 import { isRecord, readJsonFile } from "./json-file.ts";
 
-export const PROFILE_SCHEMA_VERSION = 2;
+export const PROFILE_SCHEMA_VERSION = 1;
+/** The number v0.1.0 wrote for the same field shape: read, never written. */
+const LEGACY_SCHEMA_VERSION = 2;
 export const DEFAULT_PROFILE_NAME = "default";
 
 export interface ProfileModel {
@@ -62,13 +66,6 @@ export interface ResolvedProfile {
 	definition: ProfileDefinition;
 }
 
-/** One parsed catalog file: definitions plus non-fatal compatibility
- *  warnings the caller surfaces once per activation. */
-export interface CatalogDocument {
-	profiles: Map<string, ProfileDefinition>;
-	warnings: string[];
-}
-
 export class CatalogError extends Error {
 	constructor(message: string) {
 		super(message);
@@ -94,8 +91,8 @@ function readOptionalString(value: unknown, field: string, profileName: string):
 
 /** Parses one raw profile definition; exported for the write-side store
  *  (profile-catalog-store.ts) so anything written is loadable. Unknown
- *  fields are ignored by design — `extensions` is reported by
- *  parseCatalogDocument, which has the file path for the warning. */
+ *  fields are ignored by design — a legacy `extensions` declaration is
+ *  dropped silently, exactly like any other unknown key. */
 export function parseProfileDefinition(name: string, raw: unknown): ProfileDefinition {
 	if (!isRecord(raw)) {
 		throw new CatalogError(`profile "${name}" must be an object`);
@@ -123,22 +120,16 @@ export function parseProfileDefinition(name: string, raw: unknown): ProfileDefin
 
 /** Parses one catalog document. Missing files are handled by the caller;
  *  this function sees only parsed JSON. */
-export function parseCatalogDocument(value: unknown, filePath: string): CatalogDocument {
+export function parseCatalogDocument(value: unknown, filePath: string): Map<string, ProfileDefinition> {
 	if (!isRecord(value)) {
 		throw new CatalogError(`${filePath}: catalog must be an object`);
 	}
-	const warnings: string[] = [];
 	const version = value.schemaVersion;
-	if (version !== 1 && version !== PROFILE_SCHEMA_VERSION) {
+	if (version !== PROFILE_SCHEMA_VERSION && version !== LEGACY_SCHEMA_VERSION) {
 		throw new CatalogError(
 			`${filePath}: unsupported schemaVersion ${JSON.stringify(version)} (expected ${PROFILE_SCHEMA_VERSION})`,
 		);
 	}
-	if (version === 1) {
-		warnings.push(
-			`${filePath}: schemaVersion 1 is read as version ${PROFILE_SCHEMA_VERSION}; profiles declaring "extensions" are upgraded with that field ignored`,
-		);
-	}
 	if (!isRecord(value.profiles)) {
 		throw new CatalogError(`${filePath}: "profiles" must be an object mapping names to definitions`);
 	}
@@ -149,21 +140,16 @@ export function parseCatalogDocument(value: unknown, filePath: string): CatalogD
 				`${filePath}: "${DEFAULT_PROFILE_NAME}" is built in and must not be defined in the catalog`,
 			);
 		}
-		if (isRecord(raw) && raw.extensions !== undefined) {
-			warnings.push(
-				`${filePath}: profile "${name}" declares "extensions"; extensions are always loaded natively (ADR-0007) and the field is ignored — manage extensions with pi install`,
-			);
-		}
 		profiles.set(name, parseProfileDefinition(name, raw));
 	}
-	return { profiles, warnings };
+	return profiles;
 }
 
 /** Reads one catalog file; missing → empty map, malformed → CatalogError. */
-async function loadCatalogFile(catalogPath: string): Promise<CatalogDocument> {
+async function loadCatalogFile(catalogPath: string): Promise<Map<string, ProfileDefinition>> {
 	const result = await readJsonFile(catalogPath);
 	if (!result.ok) {
-		if (result.reason === "missing") return { profiles: new Map(), warnings: [] };
+		if (result.reason === "missing") return new Map();
 		throw new CatalogError(`invalid JSON in ${catalogPath}`);
 	}
 	return parseCatalogDocument(result.value, catalogPath);
@@ -171,17 +157,9 @@ async function loadCatalogFile(catalogPath: string): Promise<CatalogDocument> {
 
 export class ProfileCatalog {
 	readonly #profiles: ReadonlyMap<string, CatalogEntry>;
-	readonly #warnings: readonly string[];
 
-	private constructor(profiles: ReadonlyMap<string, CatalogEntry>, warnings: readonly string[]) {
+	private constructor(profiles: ReadonlyMap<string, CatalogEntry>) {
 		this.#profiles = profiles;
-		this.#warnings = warnings;
-	}
-
-	/** Compatibility warnings from reading the catalog files (v1 schema,
-	 *  ignored `extensions` fields). Empty for a current, well-formed pair. */
-	get warnings(): readonly string[] {
-		return this.#warnings;
 	}
 
 	/**
@@ -193,18 +171,16 @@ export class ProfileCatalog {
 	static async load(agentDir: string, options?: { projectDir?: string }): Promise<ProfileCatalog> {
 		const global = await loadCatalogFile(path.join(agentDir, "profiles.json"));
 		const profiles = new Map<string, CatalogEntry>();
-		const warnings = [...global.warnings];
-		for (const [name, definition] of global.profiles) {
+		for (const [name, definition] of global) {
 			profiles.set(name, { source: "global", definition });
 		}
 		if (options?.projectDir !== undefined) {
 			const project = await loadCatalogFile(path.join(options.projectDir, ".pi", "profiles.json"));
-			warnings.push(...project.warnings);
-			for (const [name, definition] of project.profiles) {
+			for (const [name, definition] of project) {
 				profiles.set(name, { source: "project", definition });
 			}
 		}
-		return new ProfileCatalog(profiles, warnings);
+		return new ProfileCatalog(profiles);
 	}
 
 	/** Resolves a profile by name. `default` always resolves to the built-in

package/src/profile-presets.ts

@@ -0,0 +1,60 @@
+/**
+ * ProfilePresets: the starting points `/profile create` offers.
+ *
+ * A preset is DATA, not a profile. It never appears in `/profile list` and
+ * cannot be activated until the create wizard copies it into a user catalog,
+ * so `default` stays the only built-in profile and nothing here is ever
+ * silently in effect. Once copied, the definition belongs to the user: the
+ * preset is not tracked, and later changes to it do not reach existing
+ * profiles.
+ *
+ * Every preset must work on a machine with no skills installed, no MCP
+ * adapter, and no provider credentials:
+ *
+ * - no `mcp`: a declared MCP intent fails the whole activation when
+ *   `pi-mcp-adapter` is absent or the server was never discovered
+ *   (ADR-0002).
+ * - no `model`: `provider` and `id` are required, and an unauthenticated
+ *   model also fails the whole activation.
+ * - no `skills`: a literal reference warns once the skill turns out to be
+ *   missing, and `[]` hides every skill — omitting the field keeps Pi's full
+ *   visibility.
+ * - `tools` names Pi's built-in tools only, because extension and MCP tool
+ *   names may never register, and it always contains `read`: Pi emits the
+ *   prompt's skills section only while `read` or `bash` is active.
+ * - `instructions` states behavior, never a capability name, and stays
+ *   short: Pi appends it to the system prompt on every turn.
+ *
+ * `test/profile-presets.test.ts` enforces every rule above and asserts
+ * `examples/profiles.json` is exactly this catalog.
+ */
+
+import type { ProfileDefinition } from "./profile-catalog.ts";
+
+export interface ProfilePreset {
+	/** Catalog key the create wizard offers as the new profile's name. */
+	name: string;
+	definition: ProfileDefinition;
+}
+
+/** The read-only behavior contract: describe, do not mutate. */
+const READ_ONLY_INSTRUCTIONS = [
+	"Read-only session: inspect and report; never create, edit, rename, or delete files.",
+	"If a change is needed, describe it in your reply instead of applying it.",
+	"Do not run commands that modify state (installs, formatters, commits, pushes, network writes).",
+	"Prefer an available skill or MCP tool when it fits the request; otherwise use the tools you have.",
+	"Ground claims in evidence: cite file:line and separate verified facts from inferences.",
+	"Reply in English.",
+].join("\n");
+
+export const PROFILE_PRESETS: readonly ProfilePreset[] = [
+	{
+		name: "read-only",
+		definition: {
+			label: "Read-only",
+			description: "Read-only session; no skills or MCP servers assumed — add your own.",
+			tools: ["read", "grep", "find", "ls"],
+			instructions: READ_ONLY_INSTRUCTIONS,
+		},
+	},
+];

package/src/profile-resolver.ts

@@ -23,7 +23,11 @@ import type { RuntimeOverlay } from "./runtime-state-store.ts";
 
 /** The live resource view a resolution runs against. */
 export interface LiveResources {
-	skills: Array<{ name: string; filePath: string }>;
+	/** Pi's loaded skills. `undefined` when the caller cannot read them yet:
+	 *  Pi exposes the list on command contexts and on the `before_agent_start`
+	 *  event, not in `session_start`'s event context. An unknown set leaves the
+	 *  visibility filter intact and reports nothing (see `skillWarnings`). */
+	skills?: Array<{ name: string; filePath: string }>;
 	toolNames: string[];
 	/** MCP adapter state: presence plus discovered server names. */
 	mcp: { adapterPresent: boolean; servers: string[] };
@@ -77,17 +81,21 @@ export class SelectionError extends Error {
 	}
 }
 
-function resolveSkills(
-	declared: string[] | undefined,
-	disabled: string[],
+/** Existence warnings for skill references against one live skill set.
+ *  `undefined` means "not known yet" — Pi's skill list is only readable from
+ *  a command context or from the `before_agent_start` event, so a startup
+ *  activation reports nothing instead of every reference as unloaded. The
+ *  same function re-checks the references on the first turn, when the list
+ *  (including skills contributed through `resources_discover`) is complete. */
+export function skillWarnings(
+	refs: readonly string[],
 	live: LiveResources["skills"],
-): { filter?: SkillsFilter; warning: Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched"> } {
-	const refs = declared ?? [];
-	const warning = { skillsUnresolved: [] as UnresolvedRef[], skillsUnmatched: [] as string[] };
-	if (declared === undefined) {
-		// The profile declares nothing; an overlay may still hide skills.
-		return { ...(disabled.length > 0 ? { filter: { refs: "all" as const, disabled } } : {}), warning };
-	}
+): Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched"> {
+	const warning: Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched"> = {
+		skillsUnresolved: [],
+		skillsUnmatched: [],
+	};
+	if (live === undefined) return warning;
 	for (const ref of refs) {
 		const hits = live.filter((skill) => matchesReference(ref, skill.name));
 		if (hits.length === 0) {
@@ -95,7 +103,22 @@ function resolveSkills(
 			else warning.skillsUnresolved.push({ reference: ref, suggestions: suggestNames(ref, live.map((s) => s.name)) });
 		}
 	}
-	return { filter: { refs, disabled }, warning };
+	return warning;
+}
+
+function resolveSkills(
+	declared: string[] | undefined,
+	disabled: string[],
+	live: LiveResources["skills"],
+): { filter?: SkillsFilter; warning: Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched"> } {
+	if (declared === undefined) {
+		// The profile declares nothing; an overlay may still hide skills.
+		return {
+			...(disabled.length > 0 ? { filter: { refs: "all" as const, disabled } } : {}),
+			warning: skillWarnings([], live),
+		};
+	}
+	return { filter: { refs: declared, disabled }, warning: skillWarnings(declared, live) };
 }
 
 function resolveMcp(
@@ -211,23 +234,33 @@ export function resolveSelection(input: {
 	return selection;
 }
 
-/** User-facing warning lines for one resolved selection. */
-export function formatSelectionWarnings(selection: ResolvedSelection): string[] {
+/** User-facing lines for one set of skill warnings. Shared by the startup
+ *  report and the first-turn re-check, so both read identically. */
+export function formatSkillWarnings(
+	profile: string,
+	warning: Pick<SelectionWarnings, "skillsUnresolved" | "skillsUnmatched">,
+): string[] {
 	const lines: string[] = [];
-	for (const unresolved of selection.warnings.skillsUnresolved) {
+	for (const unresolved of warning.skillsUnresolved) {
 		const hint =
 			unresolved.suggestions.length > 0
 				? ` — did you mean: ${unresolved.suggestions.map((name) => JSON.stringify(name)).join(", ")}?`
 				: "";
 		lines.push(
-			`profile "${selection.name}": skill ${JSON.stringify(unresolved.reference)} is not loaded in this session${hint}`,
+			`profile "${profile}": skill ${JSON.stringify(unresolved.reference)} is not loaded in this session${hint}`,
 		);
 	}
-	if (selection.warnings.skillsUnmatched.length > 0) {
+	if (warning.skillsUnmatched.length > 0) {
 		lines.push(
-			`profile "${selection.name}": skill glob(s) ${selection.warnings.skillsUnmatched.map((ref) => JSON.stringify(ref)).join(", ")} matched nothing`,
+			`profile "${profile}": skill glob(s) ${warning.skillsUnmatched.map((ref) => JSON.stringify(ref)).join(", ")} matched nothing`,
 		);
 	}
+	return lines;
+}
+
+/** User-facing warning lines for one resolved selection. */
+export function formatSelectionWarnings(selection: ResolvedSelection): string[] {
+	const lines: string[] = formatSkillWarnings(selection.name, selection.warnings);
 	if (selection.warnings.mcpUnmatched.length > 0) {
 		lines.push(
 			`profile "${selection.name}": MCP glob(s) ${selection.warnings.mcpUnmatched.map((ref) => JSON.stringify(ref)).join(", ")} matched nothing`,

package/src/runtime-state-store.ts

@@ -42,6 +42,19 @@ export interface RuntimeOverlay {
 	tools?: string[];
 }
 
+/** True when an overlay actually narrows the active profile. An overlay whose
+ *  fields were all removed again (`/profile customize enable …`) is not a
+ *  difference from the catalog, and `parseOverlay` drops an empty overlay on
+ *  read. A `tools: []` override is a difference: it selects no tools. */
+export function overlayNarrows(overlay: RuntimeOverlay | undefined): boolean {
+	if (overlay === undefined) return false;
+	return (
+		(overlay.disabledSkills?.length ?? 0) > 0 ||
+		(overlay.disabledMcp?.length ?? 0) > 0 ||
+		overlay.tools !== undefined
+	);
+}
+
 function parseOverlay(value: unknown): RuntimeOverlay | undefined {
 	if (!isRecord(value)) return undefined;
 	const overlay: RuntimeOverlay = {};

package/src/startup-selection.ts

@@ -105,10 +105,7 @@ export async function resolveStartupProfile(input: {
 	const catalog = await ProfileCatalog.load(input.agentDir, {
 		projectDir: input.projectTrusted ? input.cwd : undefined,
 	});
-	const warnings: string[] = [
-		...catalog.warnings,
-		...(await legacyRegistryWarnings(input)),
-	];
+	const warnings: string[] = await legacyRegistryWarnings(input);
 
 	if (input.requested !== undefined) {
 		if (catalog.resolve(input.requested) === undefined) {

package/src/switching/activate-profile.ts

@@ -53,7 +53,10 @@ export interface ActivationDeps {
 
 export interface ActivationResult {
 	selection: ResolvedSelection;
-	warnings: string[];
+	/** The overlay this activation applied; absent when the runtime runs the
+	 *  profile exactly as it is declared. Callers surface it (the footer badge)
+	 *  instead of re-reading the state file. */
+	overlay?: RuntimeOverlay;
 }
 
 /** Resolves a profile against the live resources without applying it.
@@ -65,7 +68,7 @@ export async function resolveProfileSelection(
 	name: string,
 	deps: Pick<ActivationDeps, "agentDir" | "cwd" | "projectTrusted" | "live" | "presetInputs">,
 	overlay?: RuntimeOverlay,
-): Promise<{ selection: ResolvedSelection; warnings: string[] }> {
+): Promise<ResolvedSelection> {
 	const catalog = await ProfileCatalog.load(deps.agentDir, {
 		projectDir: deps.projectTrusted ? deps.cwd : undefined,
 	});
@@ -76,8 +79,7 @@ export async function resolveProfileSelection(
 		);
 	}
 	const suppressTools = !deps.presetInputs.force && deps.presetInputs.explicit.tools;
-	const selection = resolveSelection({ profile, overlay, live: deps.live, suppressTools });
-	return { selection, warnings: [...catalog.warnings] };
+	return resolveSelection({ profile, overlay, live: deps.live, suppressTools });
 }
 
 /** Activates a profile: resolve, validate, optionally persist, apply. */
@@ -87,7 +89,7 @@ export async function activateProfile(
 	options?: { overlay?: RuntimeOverlay | null; persist?: boolean },
 ): Promise<ActivationResult> {
 	const overlay = options?.overlay ?? undefined;
-	const { selection, warnings } = await resolveProfileSelection(name, deps, overlay);
+	const selection = await resolveProfileSelection(name, deps, overlay);
 	const preset = decidePreset({ model: selection.model, ...deps.presetInputs });
 
 	// Validate before touching anything: the model preset is the only
@@ -109,5 +111,5 @@ export async function activateProfile(
 		throw new ActivationError(result.error ?? `profile "${name}" could not be applied`);
 	}
 
-	return { selection, warnings };
+	return { selection, ...(overlay === undefined ? {} : { overlay }) };
 }

package/src/switching/list-profiles.ts

@@ -24,20 +24,17 @@ export async function listProfiles(input: {
 	realAgentDir: string;
 	cwd: string;
 	projectTrusted: boolean;
-}): Promise<{ entries: ProfileListEntry[]; warnings: string[] }> {
+}): Promise<ProfileListEntry[]> {
 	const catalog = await ProfileCatalog.load(input.realAgentDir, {
 		projectDir: input.projectTrusted ? input.cwd : undefined,
 	});
-	return {
-		entries: catalog.list().map((profile) => ({
-			name: profile.name,
-			source: profile.source,
-			...(typeof profile.definition.label === "string" ? { label: profile.definition.label } : {}),
-			...(typeof profile.definition.description === "string" ? { description: profile.definition.description } : {}),
-			shadowsGlobal: profile.source === "project" && catalog.shadowsGlobal(profile.name),
-		})),
-		warnings: [...catalog.warnings],
-	};
+	return catalog.list().map((profile) => ({
+		name: profile.name,
+		source: profile.source,
+		...(typeof profile.definition.label === "string" ? { label: profile.definition.label } : {}),
+		...(typeof profile.definition.description === "string" ? { description: profile.definition.description } : {}),
+		shadowsGlobal: profile.source === "project" && catalog.shadowsGlobal(profile.name),
+	}));
 }
 
 export function formatProfileList(entries: ProfileListEntry[], activeProfile?: string): string {

package/src/switching/profile-wizard.ts

@@ -8,9 +8,14 @@
  * keeps the current value (prefill via placeholder); there is no
  * field-clearing gesture (delete + create instead). Any cancelled step
  * aborts the wizard — nothing is written.
+ *
+ * Create can start from a shipped preset (src/profile-presets.ts). A preset is
+ * prefilled form state only: the wizard copies its complete definition into the
+ * chosen catalog, and the new profile belongs to the user from then on.
  */
 
 import type { ProfileDefinition } from "../profile-catalog.ts";
+import { PROFILE_PRESETS, type ProfilePreset } from "../profile-presets.ts";
 import type { CatalogScope } from "./profile-crud.ts";
 
 export interface ProfileWizardUi {
@@ -22,6 +27,8 @@ export interface ProfileWizardResult {
 	scope: CatalogScope;
 	name: string;
 	definition: ProfileDefinition;
+	/** Name of the preset this definition was copied from, when any. */
+	preset?: string;
 }
 
 interface ExistingProfile {
@@ -108,23 +115,49 @@ async function captureDefinition(
 	return definition;
 }
 
-/** Create: scope first (project only when trusted), then name, then fields. */
+const BLANK_OPTION = "blank — start from an empty definition";
+
+/** One preset row. The caller identifies the preset by the option's INDEX, so
+ *  a preset named like another row's text cannot be misread. */
+function presetOption(preset: ProfilePreset): string {
+	const hint = preset.definition.description ?? preset.definition.label;
+	return hint !== undefined ? `${preset.name} — ${hint}` : preset.name;
+}
+
+/** Create: scope, optional preset, name, then fields. */
 export async function runProfileCreateWizard(
 	ui: ProfileWizardUi,
-	input: { projectTrusted: boolean },
+	input: { projectTrusted: boolean; presets?: readonly ProfilePreset[] },
 ): 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 presets = input.presets ?? PROFILE_PRESETS;
+	let preset: ProfilePreset | undefined;
+	if (presets.length > 0) {
+		const options = [BLANK_OPTION, ...presets.map(presetOption)];
+		const chosen = await ui.select("start from which preset?", options);
+		if (chosen === undefined) return undefined;
+		preset = presets[options.indexOf(chosen) - 1];
+	}
+
+	// An empty answer takes the preset's name, so Enter accepts the preset.
+	const name = await ui.input("profile name", preset?.name);
+	if (name === undefined) return undefined;
+	const resolvedName = name.trim().length > 0 ? name.trim() : preset?.name;
+	if (resolvedName === undefined) return undefined;
 
-	const definition = await captureDefinition(ui);
+	const definition = await captureDefinition(ui, preset?.definition);
 	if (definition === undefined) return undefined;
 
-	return { scope: scope as CatalogScope, name: name.trim(), definition };
+	return {
+		scope: scope as CatalogScope,
+		name: resolvedName,
+		definition,
+		...(preset !== undefined ? { preset: preset.name } : {}),
+	};
 }
 
 /** Edit: fields prefilled from the existing complete definition. */