pi-jar 0.2.0 → 0.2.1

package/README.md

@@ -56,6 +56,7 @@ Pi only delivers mouse events in its **fullscreen** TUI mode. In regular mode th
 | `/plan [request]` | Enter plan mode (optionally sending the request). `/plan review` reopens the plan view; `/plan off` exits. |
 | `/goal <outcome>` | Start goal mode. `/goal` edits, `/goal status`, `/goal pause`, `/goal resume`, `/goal clear`. |
 | `/roles` | Role manager. `/roles set ROLE provider/model[:effort]\|@role [--project]`, `/roles clear ROLE`, `/roles <role>` activates, `/roles cycle`, `/roles list`. |
+| `/profiles` | Create or switch profiles. `/profiles new` creates (name and theme, then roles), `/profiles <name>` switches. |
 | `/advisor [focus]` | Ask the advisor for a second opinion on the current work; the answer joins the conversation. |
 | `/usage` · `/context` | Usage (cost, tokens per model, plan limits) and context-window breakdown in one tabbed panel. |
 | `/jar commit [note]` | Draft a commit message for the staged changes with the `commit` role, edit it, and commit. Offers `git add -A` when nothing is staged. |
@@ -92,7 +93,7 @@ Pi only delivers mouse events in its **fullscreen** TUI mode. In regular mode th
 
 Profiles keep separate themes, appearance settings, and model-role configurations. **Default** preserves your existing setup.
 
-Open `/jar settings` (or **Ctrl+Alt+S**) and choose **Profiles** to create or select a custom profile, or change its theme. The wizard lets you name it, choose its theme, configure roles, and review before saving. Cancelling leaves your existing setup unchanged.
+Run `/profiles` (or `/jar settings` → **Profiles**, **Ctrl+Alt+S**) to create a profile or switch to one. `/profiles new` creates directly and `/profiles <name>` switches. Creating asks only for a name and a theme; the new profile copies the current profile's appearance and model roles. In a fresh, idle session pi-jar then switches to it and opens the roles manager so you can set its models; otherwise it tells you to switch in a fresh session and run `/roles`. Cancelling leaves your existing setup unchanged.
 
 Press **Ctrl+Shift+Tab** to cycle profiles **only in a fresh, idle session**. Once the first prompt is sent, the session's profile is locked—even after the agent finishes—and restored when you resume it. Open a new session to switch. Active agents, subagents, and plan/goal workflows also block switching. Configure the selected profile's roles through `/roles`; changing one profile does not change another. The selected profile is remembered across restarts and shown on the welcome screen and beside the composer mascot: `mascot · (Profile) session_name`. Some terminals require an extended keyboard protocol to distinguish Ctrl+Shift+Tab.
 

package/docs/INTEGRATIONS.md

@@ -65,7 +65,7 @@ Hidden context messages (`pi-jar.plan-context`, `pi-jar.plan-reminder`, `pi-jar.
 | `jar_delegate` | up to four parallel subagents (`tasks: [{task, name?, role?}]`, `write?`) |
 | `jar_advisor` | second opinion from the `advisor` role (`question?`, `draft?`) |
 
-`jar_shell` events arrive as a visible `pi-jar.shell` custom message that triggers (or queues) an agent turn; when a subagent turn started by `jar_subagent resume` ends, a visible `pi-jar.subagent` message does the same. `jar_delegate` runs child processes with `PI_JAR_CHILD=1`, which keeps pi-jar in the child from registering `jar_delegate` again, and publishes each running subagent through the role contract above as `pi-jar.role.delegate-<batch>-<n>`. The advisor publishes `pi-jar.role.advisor` while it is consulting, and its `/advisor` and gate answers arrive as visible `pi-jar.advisor` custom messages.
+`jar_shell` events arrive as a visible `pi-jar.shell` custom message that triggers (or queues) an agent turn; subagent turn ends and `jar_subagent` control completions arrive as one coalesced, visible `pi-jar.subagent` message at the moderator's next turn boundary, or as a wake-up when it is idle. `jar_delegate` runs child processes with `PI_JAR_CHILD=1`, which keeps pi-jar in the child from registering `jar_delegate` again, and publishes each running subagent through the role contract above as `pi-jar.role.delegate-<batch>-<n>`. The advisor publishes `pi-jar.role.advisor` while it is consulting, and its `/advisor` and gate answers arrive as visible `pi-jar.advisor` custom messages.
 
 ## Commands that overlap other packages
 

package/docs/WORKFLOWS.md

@@ -143,7 +143,7 @@ watch matches  or  process exits  →  pi-jar.shell message  →  agent wakes (o
 - `jar_delegate` shares a session-wide **Max subagents** setting in `/jar settings`: exactly 2, 4, 6, 8 or 16, default 4. All retained live children (including idle/paused and live legacy one-shots) count; the moderator does not. Concurrent/reentrant batches reserve capacity atomically and reject over-cap requests before any launch. Lowering the limit preserves the fleet and prevents further spawning until room is available. `scout` runs `pi --mode rpc --no-session`, is read-only and defaults to the `scout` role. `fork` uses `--fork <parent-session>`, is read-only and defaults to `reviewer`. `worktree` uses the same real context fork, defaults to `worker`, and runs in a detached disposable Git worktree. Explicit `task.role` overrides those defaults; each role uses its primary/fallback candidates before falling back to the parent's current model.
 - Retained children do not exit on `agent_settled`. They become `idle`, keeping the same RPC process and model context. `jar_subagent pause` sends `clear_queue` + `abort` and leaves the agent `paused`; `resume` sends a new prompt to that same child. `steer` redirects a working child. `ask` pauses an active task, crosses a settled boundary, then starts a compact BTW-only prompt, so the old task report cannot be mistaken for the answer. It preserves the prior paused state and assigned scope for later resume.
 - `jar_subagent peek` is the moderator's cheap status surface and reads only task progress from memory: key, name, state, done/total checklist leaves, the in-progress task, current activity and the next three open tasks (no git, transcript or report reads). `stop` is destructive/final: abort an active operation if necessary, close the child, return a handoff (workspace, changed/applied files, remaining work, last report), and finalize safe worktree changes.
-- The moderator never has to poll: when a turn started by `jar_subagent resume` ends, pi-jar coalesces the settled agents into one visible `pi-jar.subagent` message (their `peek` progress plus the turn's report, clipped to 1200 characters) that triggers or queues a moderator turn. `pause`, `ask` and `stop` cancel that wake-up because the moderator is handling the agent directly.
+- The moderator never has to poll: settled turns and `pause`/`ask`/`stop` completions wait in pi-jar's own queue, never Pi's irrevocable follow-up queue. While the moderator is running they are coalesced into one visible `pi-jar.subagent` message (their `peek` progress plus the turn's report, clipped to 1200 characters) at the next turn boundary, so the final answer already reflects them instead of being followed by a fresh wake-up. Only events arriving while the moderator is idle wake a turn; an interrupted run keeps them for the next prompt. The message renders as a one-line summary (expand for the report). `pause`, `ask` and `stop` drop queued turn reports for the agent they control.
 - Nothing in the moderator path waits unbounded. `jar_subagent` returns as soon as the tool call is aborted (the child keeps its state); `pause` reports "not settled yet" after 15 s if the child ignores abort and still pauses when it settles; a working child that sends no RPC event for 10 minutes is killed as hung. After a child exits, its stdio gets 2 s to drain: a grandchild (MCP server, shell) that inherited the pipes cannot keep `stop` or session shutdown waiting for `close`.
 - Worktree setup snapshots the exact starting workspace: `HEAD` plus tracked dirty changes and non-ignored untracked files are committed only inside the detached worktree. The worktree persists across idle/pause/resume. On stop, the parent target must still byte/mode-match the snapshot and the change must be trackable by `/diff`; otherwise nothing is overwritten and the workspace/error is reported. Conflicted workspaces survive report-history trimming; after resolving parent drift, retry `stop`. Finalization waits for RPC stdio closure. Snapshot blobs preserve filesystem bytes without executing clean/smudge filters or hooks. The path guard handles Pi path normalization, rejects lexical/symlink/dangling-link escapes and Git control metadata, checks read-tool filename fallbacks (NFD, curly apostrophes, AM/PM spaces), and rechecks both source and destination ancestors during reconciliation. All replacements/rollback backups are prepared before parent mutation; failed multi-file application restores earlier files. Exceptional rollback failures explicitly report actual applied paths for recovery. Worktree children receive only `read,edit,write,grep,find,ls,jar_todo,jar_discuss`; shell tools are absent. This is filesystem-write isolation, not a network/process sandbox.
 - `jar_discuss` gives moderator and children a session-scoped structured paper. `ask` appends a question with stable id/from/to fields and `answer` references the question id (validated under the same lock as the write); both reply with the new id only, never echoing the text. Each process keeps an in-memory read cursor (the highest entry id it has been shown, reset when the paper path changes). `list` returns only unseen entries written by others — the newest that fit a 4000-character reply, each clipped to 400 characters, stating how many older entries it omitted — and advances the cursor; with nothing new it replies `No new entries (latest dN).` `since: "d12"` lists everything newer than that id instead (`since: "d0"` rereads the whole paper) and `questionId` reads one thread in full without moving the cursor. An `ask`/`answer` reply attaches unseen entries (≤1000 characters) only when all of them are relevant to the caller — answers to its questions or questions addressed to it — otherwise it adds `(N new entries; list to read)` and leaves the cursor alone, so nothing is skipped. Text is capped at 1600 characters per entry, at most 64 entries are retained, and the compact UTF-8 JSON paper is strictly bounded to 64 KiB with oldest-entry eviction and atomic rewrites. The file lock waits by yielding to the event loop (at most ~1 s), never blocking the UI. It is intentionally for terse inter-agent Q/A rather than another transcript; agents are told not to poll it.

package/extensions/index.ts

@@ -19,6 +19,7 @@ import { FOOTER_FIELDS } from "../src/footer-settings.ts";
 import { defaultVisualSettings, loadVisualSettings, saveVisualSettings, type JarVisualSettings } from "../src/settings.ts";
 import { ProfileStore, PROFILE_FILE, PROFILE_ENTRY, conversationStarted, pinnedProfileId } from "../src/profiles.ts";
 import { openJarSettings, type PiPreferences } from "../src/settings-ui.ts";
+import { openProfiles, type ProfileAction } from "../src/profile-ui.ts";
 import { pickSession } from "../src/session-ui.ts";
 import { fetchQuota, QuotaCache, type QuotaProvider } from "../src/quota.ts";
 import { ModelRoleManager } from "../src/model-roles.ts";
@@ -710,14 +711,19 @@ export default function piJar(pi: ExtensionAPI): void {
   };
 
   let switchingProfile = false;
-  const canSwitchProfile = (ctx: ExtensionContext) => {
+  const profileSwitchBlocked = (ctx: ExtensionContext): string | undefined => {
     if (switchingProfile || advisor.isBusy() || !ctx.isIdle?.() || working.phase !== "idle" || planMode.isEnabled() || goals?.isActive() || subagents.running() > 0) {
-      ctx.ui.notify("Finish the active agent/workflow before switching profiles", "warning"); return false;
+      return "Finish the active agent/workflow before switching profiles";
     }
     if (conversationStarted(profileEntries(ctx)) || pinnedProfileId(profileEntries(ctx)) !== undefined) {
-      ctx.ui.notify("This session's profile is locked. Open a new session to switch profiles", "warning"); return false;
+      return "This session's profile is locked. Open a new session to switch profiles";
     }
-    return true;
+    return undefined;
+  };
+  const canSwitchProfile = (ctx: ExtensionContext) => {
+    const blocked = profileSwitchBlocked(ctx);
+    if (blocked) ctx.ui.notify(blocked, "warning");
+    return !blocked;
   };
   const switchProfile = async (name: string, ctx: ExtensionContext) => {
     if (!profileStore || name === profileStore.activeName || !canSwitchProfile(ctx)) return;
@@ -754,29 +760,38 @@ export default function piJar(pi: ExtensionAPI): void {
       ctx.ui.notify(`Could not switch profile: ${(error as Error).message}`, "warning");
     } finally { switchingProfile = false; }
   };
+  const profileUi = (ctx: ExtensionContext, action?: ProfileAction) => {
+    if (!profileStore) { ctx.ui.notify("Profiles are unavailable in this session", "warning"); return Promise.resolve(); }
+    const store = profileStore;
+    return openProfiles(ctx, {
+      store, themes: ctx.ui.getAllThemes?.().map((theme) => theme.name) ?? [],
+      create: (name, theme) => store.add(name, theme, { ...visualSettings, accent: "follow" }, modelRoles.profileRoleConfig()),
+      switchBlocked: () => profileSwitchBlocked(ctx),
+      select: (name) => switchProfile(name, ctx),
+      openRoles: () => openRolesUi(ctx, modelRoles)
+    }, action);
+  };
   openSettings = async (ctx) => {
     if (settingsOpen) return;
     settingsOpen = true;
     try { await openJarSettings(ctx, () => visualSettings,
       (next) => applyVisualSettings(next, ctx), loadedAccents(ctx), piPreferences(ctx), profileStore ? {
-        store: profileStore, themes: ctx.ui.getAllThemes?.().map((theme) => theme.name) ?? [],
-        roles: () => modelRoles.profileRoleConfig(), roleManager: modelRoles,
-        create: (name, theme, settings, roles) => { const profile = profileStore!.add(name, theme, { ...settings, accent: "follow" }, roles); ctx.ui.notify(`Created profile ${name}; select it in a fresh session`, "info"); return profile; },
-        select: (name) => switchProfile(name, ctx),
-        setTheme: (name) => {
-          const previousTheme = ctx.ui.theme?.name;
-          const next = { ...visualSettings, accent: "follow" as const };
-          try { applyProfileTheme(name, ctx); profileStore!.update(profileStore!.activeName, { theme: name, settings: next }); }
-          catch (error) { if (previousTheme) applyProfileTheme(previousTheme, ctx); throw error; }
-          applyVisualSettings(next, ctx, { persist: false, accent: false });
-          if (profileStore!.active().id === "default") {
-            try { saveVisualSettings(getAgentDir(), next); }
-            catch { ctx.ui.notify("Theme saved, but legacy Default preferences could not be updated", "warning"); }
-          }
-        }
+        activeName: () => profileStore?.activeName ?? "Default",
+        open: (action) => profileUi(ctx, action)
       } : undefined); }
     finally { settingsOpen = false; }
   };
+  pi.registerCommand("profiles", {
+    description: "Create or switch pi-jar profiles: /profiles, /profiles new, /profiles <name>",
+    handler: async (args, ctx) => {
+      const target = args.trim();
+      if (!target) return profileUi(ctx);
+      if (["new", "create"].includes(target.toLowerCase())) return profileUi(ctx, "create");
+      const profile = profileStore?.list().find((item) => item.name.toLocaleLowerCase() === target.toLocaleLowerCase());
+      if (!profile) { ctx.ui.notify("Unknown profile: " + target, "warning"); return; }
+      await switchProfile(profile.name, ctx);
+    }
+  });
 
   /** Callers are lifecycle handlers that repaint once through sampleFooter. */
   const updateCost = (ctx: ExtensionContext) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jar",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A warm, role-aware Pi terminal workspace with switchable profiles, animated UI, plan and goal workflows, tasks, change review, model roles, background shells and subagents.",
   "type": "module",
   "license": "MIT",

package/src/delegate.ts

@@ -1258,6 +1258,9 @@ const peekRecord = (record: SubagentRecord): string => {
 const settledRecord = (record: SubagentRecord): string =>
   peekRecord(record) + (record.run.output ? `\nlast: ${cleanBlock(record.run.output, 1200)}` : "");
 
+/** One queued moderator notification; several coalesce into a single pi-jar.subagent message. */
+interface SubagentEvent { record: SubagentRecord; kind: "turn" | "control"; label: string; content: string; detail: Record<string, unknown> }
+
 /**
  * Every active worktree agent may still end up needing recovery, so admission reserves a recovery slot for
  * it: unresolved recovery workspaces never exceed RECOVERY_LIMIT, and none is ever deleted to make room.
@@ -1336,29 +1339,58 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
       (raw as { customType?: string }).customType !== "pi-jar.moderator-context" || (active && index === latest)) };
   });
 
-  /** Native RPC drives registry state; Pi's message bus delivers frozen completion events to the moderator. */
+  /** Native RPC drives registry state. Completion events wait in our own queue, never Pi's irrevocable
+   * follow-up queue: while the moderator runs they join the next turn boundary so its final answer already
+   * reflects them, instead of re-waking it after that answer. Only events arriving while idle wake a turn. */
   const eventBusAvailable = typeof pi.sendMessage === "function";
   const watched = new Map<string, SubagentRecord>();
-  const settledQueue = new Map<string, { record: SubagentRecord; content: string; turn: number }>();
+  const pendingEvents = new Map<string, SubagentEvent>();
   const deleteSettled = (key: string) => {
-    for (const [eventKey, event] of settledQueue) if (event.record.key === key) settledQueue.delete(eventKey);
+    for (const [id, event] of pendingEvents) if (event.kind === "turn" && event.record.key === key) pendingEvents.delete(id);
   };
-  let notifyTimer: NodeJS.Timeout | undefined;
-  const flushSettled = () => {
-    notifyTimer = undefined;
-    const records = [...settledQueue.values()].filter(({ record }) => registry.get(record.key) === record);
-    settledQueue.clear();
-    if (!records.length) return;
-    try {
-      pi.sendMessage?.({
-        customType: SUBAGENT_MESSAGE, display: true, details: {
-          keys: [...new Set(records.map(({ record }) => record.key))],
-          turns: records.map(({ record, turn }) => ({ key: record.key, turn }))
-        },
-        content: ["[PI-JAR SUBAGENT] A subagent turn ended. Review, then resume, ask or stop:", ...records.map(event => event.content)].join("\n\n")
-      }, { triggerTurn: true, deliverAs: "followUp" });
-    } catch (error) { console.error("pi-jar: could not deliver a subagent event", error); }
+  let moderatorActive = false;
+  let moderatorInterrupted = false;
+  let wakeTimer: NodeJS.Timeout | undefined;
+  const takeEvents = () => {
+    clearTimeout(wakeTimer);
+    wakeTimer = undefined;
+    const events = [...pendingEvents.values()].filter(({ record }) => registry.get(record.key) === record);
+    pendingEvents.clear();
+    if (!events.length) return;
+    const summary = cleanText(`Subagents · ${events.map(event => event.label).join(" · ")}`, 160);
+    return {
+      customType: SUBAGENT_MESSAGE, display: true, details: { summary, events: events.map(event => event.detail) },
+      content: [`[PI-JAR SUBAGENT] ${summary}`, ...events.map(event => event.content), "Review, then resume, ask or stop retained agents as needed."].join("\n\n")
+    };
+  };
+  const scheduleWake = () => {
+    if (moderatorActive || moderatorInterrupted || wakeTimer || !pendingEvents.size) return;
+    wakeTimer = setTimeout(() => {
+      wakeTimer = undefined;
+      if (moderatorActive || moderatorInterrupted) return;
+      const message = takeEvents();
+      if (!message) return;
+      try { pi.sendMessage?.(message, { triggerTurn: true }); }
+      catch (error) { console.error("pi-jar: could not deliver a subagent event", error); }
+    }, NOTIFY_COALESCE_MS);
+    wakeTimer.unref?.();
   };
+  const queueEvent = (id: string, event: SubagentEvent) => { pendingEvents.set(id, event); scheduleWake(); };
+  const boundary = (event: { outcome?: string; context?: { canContinue?: boolean } }) => {
+    if (event.outcome !== "completed" || event.context?.canContinue === false) return;
+    const message = takeEvents();
+    if (message) return { entries: [{ type: "custom_message" as const, ...message }], continue: true };
+  };
+  pi.registerMessageRenderer?.<{ summary?: string }>(SUBAGENT_MESSAGE, (message, { expanded }, theme) => {
+    const text = typeof message.content === "string" ? message.content : "Subagents";
+    const summary = message.details?.summary ?? text.split("\n", 1)[0] ?? "Subagents";
+    return new Text(expanded ? text : theme.fg("accent", cleanText(summary, 160)) + theme.fg("dim", " · expand for report"), 0, 0);
+  });
+  pi.on?.("agent_start", () => { moderatorActive = true; moderatorInterrupted = false; clearTimeout(wakeTimer); wakeTimer = undefined; });
+  pi.on?.("turn_end", boundary);
+  pi.on?.("agent_before_settle", (event) => { moderatorInterrupted = event.outcome !== "completed"; return boundary(event); });
+  // An interrupted run keeps its events for the user's next prompt rather than auto-waking.
+  pi.on?.("agent_settled", () => { moderatorActive = false; scheduleWake(); });
   registry.subscribe(() => {
     if (!watched.size) return;
     for (const [key, record] of watched) {
@@ -1367,14 +1399,11 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
       watched.delete(key);
       if (record.run.state !== "stopped") {
         // Freeze reports at the settled boundary. A fast resume must not overwrite a queued
-        // initial report, and multiple turns in the coalescing window must each be delivered.
-        settledQueue.set(`${key}:${record.run.resumes}`, { record, turn: record.run.resumes, content: settledRecord(record) });
+        // initial report, and multiple turns before delivery must each be delivered.
+        queueEvent(`${key}:${record.run.resumes}`, { record, kind: "turn", label: `${record.run.name} turn ended`,
+          content: settledRecord(record), detail: { key, turn: record.run.resumes } });
       }
     }
-    if (settledQueue.size && !notifyTimer) {
-      notifyTimer = setTimeout(flushSettled, NOTIFY_COALESCE_MS);
-      notifyTimer.unref?.();
-    }
   });
 
   const delegateTool: ToolDefinition<typeof Parameters> = {
@@ -1874,13 +1903,12 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
   const deliverControl = (record: SubagentRecord, operation: { id: string; action: string }, result: { content: Array<{ text: string }>; details?: unknown; isError?: boolean }) => {
     // A session switch discards the old fleet. Never wake a new session with stale handoffs.
     if (registry.get(record.key) !== record) return;
-    try {
-      pi.sendMessage({
-        customType: SUBAGENT_MESSAGE, display: true,
-        details: { operationId: operation.id, action: operation.action, key: record.key, status: result.isError ? "failed" : "completed", report: result.details },
-        content: `[PI-JAR SUBAGENT] ${operation.action} ${operation.id} completed:\n${result.content.map(part => part.text).join("\n")}`
-      }, { triggerTurn: true, deliverAs: "followUp" });
-    } catch (error) { console.error("pi-jar: could not deliver a control event", error); }
+    const status = result.isError ? "failed" : "completed";
+    // The stop handoff supersedes any queued turn report for the same agent.
+    if (operation.action === "stop") deleteSettled(record.key);
+    queueEvent(operation.id, { record, kind: "control", label: `${operation.action} ${record.run.name} ${status}`,
+      content: `${operation.action} ${operation.id} ${status}:\n${result.content.map(part => part.text).join("\n")}`,
+      detail: { operationId: operation.id, action: operation.action, key: record.key, status, report: result.details } });
   };
 
   pi.registerTool({

package/src/profile-ui.ts

@@ -0,0 +1,58 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { JarProfile, ProfileStore } from "./profiles.ts";
+
+export type ProfileAction = "create" | "switch";
+
+export interface ProfileUiOptions {
+  store: ProfileStore;
+  themes: readonly string[];
+  /** Copies the active profile's settings and roles into a new profile. */
+  create(name: string, theme: string): JarProfile;
+  /** Why the current session cannot switch profiles, or undefined when it can. */
+  switchBlocked(): string | undefined;
+  select(name: string): Promise<void>;
+  openRoles(): Promise<void>;
+}
+
+const CREATE = "+ Create profile…";
+const FOLLOW = "Follow Pi";
+
+/** Name and theme are the only creation questions; roles are configured afterwards in the roles UI. */
+export async function promptNewProfile(ctx: ExtensionContext, options: Pick<ProfileUiOptions, "store" | "themes" | "create">): Promise<JarProfile | undefined> {
+  const name = await ctx.ui.input("New profile name (1–32 characters)", "");
+  if (name === undefined) return undefined;
+  if (/[\u0000-\u001f\u007f-\u009f]/.test(name)) { ctx.ui.notify("Profile name cannot contain control characters", "warning"); return undefined; }
+  const normalized = name.trim().replace(/\s+/g, " ");
+  if (!normalized || normalized.length > 32 || /[\\/\0]/.test(normalized)) {
+    ctx.ui.notify("Profile name must be 1–32 characters and cannot contain slashes", "warning"); return undefined;
+  }
+  if (options.store.list().some((profile) => profile.name.toLocaleLowerCase() === normalized.toLocaleLowerCase())) {
+    ctx.ui.notify("A profile with that name already exists", "warning"); return undefined;
+  }
+  const selected = await ctx.ui.select("Choose a theme for " + normalized, [FOLLOW, ...options.themes.filter((item) => item !== "follow")]);
+  if (!selected) return undefined;
+  try { return options.create(normalized, selected === FOLLOW ? "follow" : selected); }
+  catch (error) { ctx.ui.notify("Could not create profile: " + (error as Error).message, "error"); return undefined; }
+}
+
+/** /profiles and the settings Profiles tab: create a profile or switch to one, nothing else. */
+export async function openProfiles(ctx: ExtensionContext, options: ProfileUiOptions, action?: ProfileAction): Promise<void> {
+  if (!ctx.hasUI || ctx.mode !== "tui") return;
+  const active = options.store.activeName;
+  if (action !== "create") {
+    const labels = new Map(options.store.list().map((profile) => [profile.name === active ? `${profile.name} (active)` : profile.name, profile.name]));
+    const choice = await ctx.ui.select(action === "switch" ? "Switch profile" : "Profiles", action === "switch" ? [...labels.keys()] : [CREATE, ...labels.keys()]);
+    if (!choice) return;
+    if (choice !== CREATE) { await options.select(labels.get(choice)!); return; }
+  }
+  const profile = await promptNewProfile(ctx, options);
+  if (!profile) return;
+  if (options.switchBlocked()) {
+    ctx.ui.notify(`Created profile ${profile.name} with ${active}'s model roles. Switch to it in a fresh session with /profiles, then set its roles with /roles.`, "info");
+    return;
+  }
+  await options.select(profile.name);
+  if (options.store.activeName !== profile.name) return;
+  ctx.ui.notify(`Created profile ${profile.name}. Its model roles start as a copy of ${active}'s; set them now in Roles (later: /roles).`, "info");
+  await options.openRoles();
+}

package/src/settings-ui.ts

@@ -3,9 +3,7 @@ import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent } fr
 import { FOOTER_FIELDS, type FooterField } from "./footer-settings.ts";
 import { ICON_SETS } from "./icons.ts";
 import { GOAL_ROUND_CHOICES, MAX_SUBAGENT_CHOICES, type JarAccent, type JarVisualSettings } from "./settings.ts";
-import { createProfileWizard } from "./profile-wizard.ts";
-import type { JarProfile, ProfileStore } from "./profiles.ts";
-import type { RoleConfig, ModelRoleManager } from "./model-roles.ts";
+import type { ProfileAction } from "./profile-ui.ts";
 
 const LABELS: Record<FooterField, string> = {
   model: "Model", effort: "Model effort", sessionName: "Session name", cwd: "Working directory",
@@ -29,13 +27,13 @@ export async function openJarSettings(
   update: (settings: JarVisualSettings) => void,
   availableAccents: readonly string[],
   pi?: PiPreferences,
-  profiles?: { store: ProfileStore; themes: readonly string[]; roles: () => RoleConfig; roleManager?: ModelRoleManager; create: (name: string, theme: string, settings: JarVisualSettings, roles: RoleConfig) => JarProfile; select(name: string): Promise<void>; setTheme(name: string): void }
+  profiles?: { activeName(): string; open(action: ProfileAction): Promise<void> }
 ): Promise<void> {
   if (!ctx.hasUI || ctx.mode !== "tui") return;
   const PAGES: Page[] = profiles ? ["appearance", "footer", "pi", "profiles"] : ["appearance", "footer", "pi"];
   let lastPage: Page = "appearance";
   while (true) {
-  const action = await ctx.ui.custom<"create" | "switch" | "theme" | undefined>((tui, theme, _keys, done) => {
+  const action = await ctx.ui.custom<ProfileAction | undefined>((tui, theme, _keys, done) => {
     let page: Page = lastPage;
     let selected = 0;
     let width = 64;
@@ -43,7 +41,7 @@ export async function openJarSettings(
       name === "default" || ["gray", "pink", "teal", "azure", "violet", "amber"].includes(name))];
     let choosing: "goalRounds" | "maxSubagents" | undefined;
     const choices = () => choosing === "maxSubagents" ? MAX_SUBAGENT_CHOICES : GOAL_ROUND_CHOICES;
-    const fields = () => choosing ? choices().length : page === "footer" ? FOOTER_FIELDS.length : page === "pi" ? 7 : page === "profiles" ? 3 : 7;
+    const fields = () => choosing ? choices().length : page === "footer" ? FOOTER_FIELDS.length : page === "pi" ? 7 : page === "profiles" ? 2 : 7;
     const finishChoice = () => { selected = choosing === "maxSubagents" ? 3 : 2; choosing = undefined; };
     const piError = (error: unknown) => ctx.ui.notify("Could not change Pi setting: " + (error as Error).message, "error");
     const explainPool = () => choosing === "maxSubagents" || (page === "pi" && !choosing && selected === 3);
@@ -58,7 +56,7 @@ export async function openJarSettings(
         finishChoice();
       } else if (page === "profiles") {
         lastPage = page;
-        done(index === 0 ? "switch" : index === 1 ? "theme" : "create");
+        done(index === 0 ? "switch" : "create");
         return;
       } else if (page === "footer") {
         const field = FOOTER_FIELDS[index];
@@ -165,9 +163,8 @@ export async function openJarSettings(
             row(5, "Advisor gates (loops, repeated failures)", state.advisorGates ? "ON" : "OFF", state.advisorGates),
           row(6, "Context diet (prior-turn reasoning)", state.contextDiet ? "ON" : "OFF", state.contextDiet)
           ] : page === "profiles" ? [
-            row(0, "Active profile", profiles!.store.activeName, true),
-            row(1, "Theme", profiles!.store.active().theme, true),
-            row(2, "Create profile…", "OPEN", true)
+            row(0, "Switch profile…", profiles!.activeName(), true),
+            row(1, "Create profile…", "OPEN", true)
           ] : [
             row(0, "Accent", state.accent === "follow" ? "FOLLOW PI" : state.accent.toUpperCase(), true),
             row(1, "Motion", state.animations ? "ON" : "OFF", state.animations),
@@ -186,7 +183,7 @@ export async function openJarSettings(
             : choosing ? " Select a value; Enter/click to save, Esc to cancel"
             : page === "footer" ? ` Footer fields ${start + 1}–${start + rows.length}/${fields()}`
             : page === "pi" ? " Fullscreen mode enables clicks and copy-on-select"
-            : page === "profiles" ? " Switch only in a fresh, idle session" : " Accent cycles through loaded themes")),
+            : page === "profiles" ? " Switch only in a fresh, idle session; roles via /roles" : " Accent cycles through loaded themes")),
           ...rows,
           line(theme.fg("dim", choosing ? " ↑↓: choose · Enter/click: save · Esc: cancel"
             : " Tab: section · ↑↓: choose · Enter/click: change · Esc")),
@@ -196,16 +193,9 @@ export async function openJarSettings(
     };
   });
   if (!action || !profiles) return;
-  try {
-    if (action === "create") {
-      await createProfileWizard(ctx, profiles.store, { themes: profiles.themes, settings: { ...current(), accent: "follow" }, roles: profiles.roles(), roleManager: profiles.roleManager, create: profiles.create });
-    } else if (action === "switch") {
-      const name = await ctx.ui.select("Choose a profile", profiles.store.list().map((profile) => profile.name));
-      if (name) await profiles.select(name);
-    } else {
-      const name = await ctx.ui.select("Profile theme", ["Follow Pi", ...profiles.themes.filter((name) => name !== "follow")]);
-      if (name) profiles.setTheme(name === "Follow Pi" ? "follow" : name);
-    }
-  } catch (error) { ctx.ui.notify("Could not change profile: " + (error as Error).message, "error"); }
+  try { await profiles.open(action); }
+  catch (error) { ctx.ui.notify("Could not change profile: " + (error as Error).message, "error"); }
+  // A new profile hands off to the roles UI; reopening settings over it would bury that step.
+  if (action === "create") return;
   }
 }

package/src/profile-wizard.ts

@@ -1,61 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { JarVisualSettings } from "./settings.ts";
-import type { JarProfile, ProfileStore } from "./profiles.ts";
-import { isRoleName, normalizeSpec, type RoleConfig, type ModelRoleManager } from "./model-roles.ts";
-
-export interface ProfileWizardOptions {
-  themes: readonly string[];
-  settings: JarVisualSettings;
-  roles: RoleConfig;
-  roleManager?: ModelRoleManager;
-  create(name: string, theme: string, settings: JarVisualSettings, roles: RoleConfig): JarProfile;
-}
-
-/** Every step is cancellable; creation happens only after the final confirmation. */
-export async function createProfileWizard(ctx: ExtensionContext, store: ProfileStore, options: ProfileWizardOptions): Promise<JarProfile | undefined> {
-  if (!ctx.hasUI || ctx.mode !== "tui") return undefined;
-  const name = await ctx.ui.input("New profile name (1–32 characters)", "");
-  if (name === undefined) return undefined;
-  if (/[\u0000-\u001f\u007f-\u009f]/.test(name)) { ctx.ui.notify("Profile name cannot contain control characters", "warning"); return undefined; }
-  const normalized = name.trim().replace(/\s+/g, " ");
-  if (!normalized || normalized.length > 32 || /[\\/\0]/.test(normalized)) {
-    ctx.ui.notify("Profile name must be 1–32 characters and cannot contain slashes", "warning"); return undefined;
-  }
-  if (store.list().some((profile) => profile.name.toLocaleLowerCase() === normalized.toLocaleLowerCase())) {
-    ctx.ui.notify("A profile with that name already exists", "warning"); return undefined;
-  }
-  if (!options.themes.length) { ctx.ui.notify("No themes are available for profiles", "warning"); return undefined; }
-  const selectedTheme = await ctx.ui.select("Choose a theme for " + normalized, ["Follow Pi", ...options.themes.filter((item) => item !== "follow")]);
-  if (!selectedTheme) return undefined;
-  const theme = selectedTheme === "Follow Pi" ? "follow" : selectedTheme;
-  const roles = structuredClone(options.roles);
-  const roleNames = options.roleManager?.list().map((role) => role.role) ?? [];
-  if (options.roleManager) {
-    for (const role of roleNames) {
-      const current = roles.roles[role];
-      const answer = await ctx.ui.input(`${role} role assignment (blank keeps current${current ? `: ${current}` : ""}; none clears)`, "");
-      if (answer === undefined) return undefined;
-      if (!answer.trim()) continue;
-      if (answer.trim().toLowerCase() === "none") { delete roles.roles[role]; continue; }
-      const model = normalizeSpec(answer.trim());
-      if (!model) { ctx.ui.notify("Enter a valid provider/model, @role, *, or none for " + role, "warning"); return undefined; }
-      roles.roles[role] = model;
-    }
-  } else {
-    const roleInput = await ctx.ui.input("Role assignments as role=provider/model, comma-separated (optional)", "");
-    if (roleInput === undefined) return undefined;
-    for (const assignment of roleInput.split(",").map((item) => item.trim()).filter(Boolean)) {
-    const split = assignment.indexOf("=");
-    if (split <= 0) { ctx.ui.notify("Use role=provider/model for each assignment", "warning"); return undefined; }
-    const role = assignment.slice(0, split).trim().toLowerCase();
-    const model = normalizeSpec(assignment.slice(split + 1).trim());
-    if (!isRoleName(role) || !model) { ctx.ui.notify("Invalid role assignment: " + assignment, "warning"); return undefined; }
-    roles.roles[role] = model;
-    }
-  }
-  const roleSummary = Object.entries(roles.roles).map(([role, target]) => `${role} → ${target}`).join("\n") || "No roles assigned";
-  const confirmed = await ctx.ui.confirm("Create profile", `${normalized}\nTheme: ${theme === "follow" ? "Follow Pi" : theme}\n${roleSummary}`);
-  if (!confirmed) return undefined;
-  try { return options.create(normalized, theme, options.settings, roles); }
-  catch (error) { ctx.ui.notify("Could not create profile: " + (error as Error).message, "error"); return undefined; }
-}