pi-jar 0.1.9 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-jar
 
-A warm, role-aware TUI and workflow extension for [Pi](https://github.com/earendil-works/pi). pi-jar turns the terminal into a more expressive agent workspace with a living pixel-fire welcome, an adaptive composer, first-class **plan**, **goal** and **role** workflows, tracked tasks, reviewable changes, background shells and parallel subagents.
+A warm, role-aware TUI and workflow extension for [Pi](https://github.com/earendil-works/pi). pi-jar turns the terminal into a more expressive agent workspace with a living pixel-fire welcome, an adaptive composer, switchable **profiles**, first-class **plan**, **goal** and **role** workflows, tracked tasks, reviewable changes, background shells and parallel subagents.
 
 > Works with the current `@earendil-works/*` Pi API. Pi's core packages are peer dependencies (`"*"`), so pi-jar always runs against the Pi you have installed; it is tested against the latest release (0.87.x).
 
@@ -24,7 +24,7 @@ The showcase is captured from a real pi-jar terminal session: the torch-style `
 | **Commit** | `/jar commit [note]` drafts a message for the staged changes with the `commit` role, lets you edit it, then commits (never pushes). |
 | **Tasks & questions** | A Claude/omp-style `jar_todo` checklist with subtasks and per-task progress that the agent maintains itself, and `jar_ask` structured questions with options, multi-select and free-form answers. |
 | **Change review** | Every file the agent or its editing subagents change is remembered as it was; `/diff` (<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>D</kbd>) shows changed files (each counted once) next to a colored diff, with accept or revert per file or all at once. |
-| **Background shells** | `jar_shell` runs dev servers, watchers and long tests in the background; the agent is woken when a watch pattern matches or the process exits, so it never polls. Running shells get a footer row; click it (or <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>A</kbd>) to tail or kill them. |
+| **Background shells** | `jar_shell` runs dev servers, watchers and long tests in the background; watch/exit events wake an idle agent or reach it at the next safe turn boundary. Completion status appears immediately in the UI even during model reasoning. Running shells get a footer row; click it (or <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>A</kbd>) to tail or kill them. |
 | **Subagents** | The main agent becomes a moderator over a configurable retained pool (2, 4, 6, 8 or 16; default 4). `jar_delegate` starts `scout`, `fork` or sandboxed `worktree` agents and returns immediately, so the main agent can keep responding to user steering; Pi RPC event-bus messages deliver initial and resumed turn completions without polling. `jar_subagent` peeks, steers, asks BTW questions, pauses, resumes and stops them. Workers can exchange bounded structured Q/A through `jar_discuss`; worktree changes stay isolated until stop, then safely enter `/diff`. |
 | **Sessions & history** | Recent sessions (with their goal and plan) on the welcome card, one click from resuming; <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>H</kbd> searches earlier prompts; pasted images show as chips under the composer. |
 | **Footer & themes** | Responsive footer (model, effort, session, cwd, context, RAM, cost, quota, goal, roles, branch, live subagents and shells) with unicode, [Nerd Font](https://www.nerdfonts.com) or ascii icons, and seven dark themes. |
@@ -79,6 +79,7 @@ Pi only delivers mouse events in its **fullscreen** TUI mode. In regular mode th
 | Shortcut | Action |
 | --- | --- |
 | <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>S</kbd> | Open pi-jar settings |
+| <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Tab</kbd> | Cycle profiles (theme and model roles) |
 | <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>A</kbd> | Subagents and background shells (activity view) |
 | <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>R</kbd> | Refresh the welcome (new message and flame), or show it again |
 | <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>P</kbd> | Toggle plan mode |
@@ -87,6 +88,14 @@ Pi only delivers mouse events in its **fullscreen** TUI mode. In regular mode th
 | <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>H</kbd> | Search earlier prompts into the composer |
 | <kbd>Tab</kbd> / <kbd>→</kbd> in an empty composer | Accept the dim suggestion into the input (it is not sent) |
 
+## Profiles
+
+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.
+
+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.
+
 ## Welcome screen
 
 The welcome stays until your first prompt, then dissolves (or hides immediately with motion off).
@@ -115,7 +124,7 @@ The welcome stays until your first prompt, then dissolves (or hides immediately
   | proud | `(★ᴗ★)` | a goal was completed |
   | poked | `(^o^)` | you clicked it |
 
-  The title also shows Pi's session name (or a stable readable alias like `silver-lantern`). Toggle the mascot in settings; `/jar composer off` restores Pi's editor with your draft intact.
+  The title also shows the active profile in parentheses, then Pi's session name (or a stable readable alias like `silver-lantern`): `mascot · (Default) silver-lantern`. Toggle the mascot in settings; `/jar composer off` restores Pi's editor with your draft intact.
 
 ## Plan mode
 
@@ -213,7 +222,7 @@ Roles map a purpose to a model. They live in `~/.pi/agent/pi-jar-roles.json` (Pi
 
 The advisor is a second model (the `advisor` role; the current model if unassigned) that sees a fresh view of the recent conversation plus `git status` and a diff stat, but cannot run tools.
 
-- **`jar_advisor({ question?, draft? })`** — the agent is told to use it before risky or hard-to-reverse choices, after two failed attempts, and before declaring complex work done; it passes its own candidate as `draft`. Available in plan mode too.
+- **`jar_advisor({ question?, draft? })`** — starts a background second opinion and immediately returns a request ID. Use `action: "status"`, `"get"`, bounded `"wait"` (at most 30 seconds), or `"cancel"` with that ID; a pending receipt is **not** reviewed approval. Advice arrives at a safe model boundary or wakes an idle agent, with immediate UI completion feedback. Requests have a 60-second deadline and bounded context; `/advisor` and automatic stuck-work gates are non-blocking too. Get completed advice before consequential decisions. Available in plan mode too.
 - **`/advisor [focus]`** — ask on demand; the answer is added to the conversation (visible) for the agent's next turn.
 - **Gates** — when the agent makes the same tool call three times within its last eight calls, the call is blocked and the advisor's review is returned instead; after three failing tool results in a row, the advice is steered into the running turn. At most two automatic consultations per prompt.
 - Settings → Pi toggles the advisor and the gates. Advisor calls are counted in `/usage`. The footer and welcome show it as a working teammate while it thinks.
@@ -256,7 +265,8 @@ This is a pi-jar enhancement: [pi-advisor](https://github.com/philipbrembeck/pi-
   Use `parent` with `append` to add a genuinely new subtask to active work; `start`, `done`, `open`, `edit`, `list`, `add` and `delete` remain available.
 - **`jar_ask`** — structured questions: numbered options with descriptions, single or multi-select, *Type your own answer* (multi-line, paste-friendly) and *Chat about this* to discuss before choosing.
 - **`/diff`** — review what the agent (and its editing subagents) changed since the first edit to each file: files with `+/−` counts on the left, a full-path header and numbered, colored diff on the right. Changed lines get a colored rail and tinted background, replaced lines highlight the changed words, code is syntax-highlighted for known languages, and collapsed regions are labeled `┄ N unchanged lines ┄`. `/` filters files; `t` switches unified and aligned side-by-side views (unified below 70 columns), `←`/`→` (or `[`/`]`) change the context from 0 lines to the whole file, `w` wraps long lines, and `n`/`p`, `Home`/`End` navigate. Large changes offer summary or explicit windowed review (`v`), with clearly labeled coarse fallback and existing safety limits—not arbitrary-file streaming. See [diff review](docs/DIFF-REVIEW.md). `a` accept (keep, stop tracking), `r` then `y` revert (restore the original, or remove a file it created), `A`/`R` for all. The footer shows `± N files · /diff` while anything is unreviewed; each file counts once no matter who edited it. Only `edit`/`write` changes inside the project are tracked; shell-made changes are not.
-- **`jar_shell`** — `start` (optional `name`, `watch` regex, `notify`, task/service `purpose`), `list`, `peek`, bounded `wait`, `output`, `kill`. ANSI-stripped logs have per-job caps and a 4 MiB aggregate budget; surfaced finished jobs compact to a 32 KiB tail. Live jobs retain useful tails and are never killed to reclaim logs. Watch/exit notifications are compact and coalesced; reads acknowledge observed events. Each running shell gets a footer row and an activity view (`/jar shells`) with `x` kill and `f` follow. All shells stop when the session ends.
+- **Context diet (opt-in)** — `/jar settings` → **Pi** → **Context diet (prior-turn reasoning)**. Saved independently per profile; OFF by default. Removes eligible thinking blocks from completed earlier user turns only in outgoing context, never from stored history. Current reasoning signatures, user requests, tool arguments/results, and workflow state remain intact; ambiguous tool chains are left unchanged. Opaque signature character counts are diagnostics, not token savings. Existing SoL-Pi observation packing remains responsible for tool-result projection.
+- **`jar_shell`** — `start` (optional `name`, `watch` regex, `notify`, task/service `purpose`), `list`, `peek`, bounded `wait`, `output`, `kill`. ANSI-stripped logs have per-job caps and a 4 MiB aggregate budget; surfaced finished jobs compact to a 32 KiB tail. Live jobs retain useful tails and are never killed to reclaim logs. Watch/exit notifications are compact and coalesced; reads acknowledge observed events. Active model responses cannot be interrupted by a completion event: the UI previews status without consuming it, and model delivery waits for a safe boundary. When no useful work remains, use bounded `wait` for the relevant finite jobs rather than waiting for an automatic wake-up. Each running shell gets a footer row and an activity view (`/jar shells`) with `x` kill and `f` follow. All shells stop when the session ends.
 - **`jar_delegate`** — spawns retained, session-scoped subagents up to **Max subagents** in `/jar settings` (2, 4, 6, 8 or 16; default 4). Idle, paused and hibernated agents count toward this pool; over-cap batches are rejected. `scout` is fresh/read-only, `fork` inherits conversation read-only, and `worktree` forks context into a path-guarded Git worktree. Settled retained agents close their Pi process after 30 seconds of quiet while keeping their private session and workspace; `resume`/`ask` relaunch that same session. Launch returns before startup or the first turn completes, including legacy one-shot `write: true` mode.
 - **`jar_subagent`** — `peek` reports progress, including the workspace path and changed files for recovery records; `steer` redirects a running worker; `resume` relaunches an idle/paused/hibernated agent. `ask`, `pause` and `stop` return accepted receipts immediately; answers and final handoffs arrive as `pi-jar.subagent` events. `stop` reconciles safe worktree changes; conflicts remain private and can be retried with `stop` after resolving parent drift. `discard` removes an unresolved recovery worktree without applying it. At most four active/recovery worktrees are admitted; resolve or discard one before starting another. Session shutdown reports paths of any preserved worktrees. Controls do not poll the child.
 - **Subagent capabilities** — each task can set `tools` or `inheritTools: true`; known-tool mode filters and child guards remain in force. See [tool capabilities](docs/SUBAGENT-TOOLS.md).

package/extensions/index.ts

@@ -1,5 +1,5 @@
 import { getAgentDir, SessionManager, SettingsManager, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { basename } from "node:path";
+import { basename, join } from "node:path";
 import { execFile } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { Key, truncateToWidth, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
@@ -17,12 +17,14 @@ import { GOAL_ENTRY, GoalStore } from "../src/goals.ts";
 import { GoalLoop } from "../src/goal-loop.ts";
 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 { pickSession } from "../src/session-ui.ts";
 import { fetchQuota, QuotaCache, type QuotaProvider } from "../src/quota.ts";
 import { ModelRoleManager } from "../src/model-roles.ts";
 import { jarCommit } from "../src/commit.ts";
 import { registerAdvisor } from "../src/advisor.ts";
+import { registerContextDiet } from "../src/context-diet.ts";
 import { registerInfoPanels } from "../src/info-panels.ts";
 import { SideUsage } from "../src/side-model.ts";
 import { PlanMode } from "../src/plan.ts";
@@ -97,6 +99,7 @@ export default function piJar(pi: ExtensionAPI): void {
   installCompactBuiltinTools(pi);
   let demo = false;
   let visualSettings = defaultVisualSettings();
+  let profileStore: ProfileStore | undefined;
   let animations = visualSettings.animations;
   let enabled = visualSettings.ui;
   let disposeFooter: (() => void) | undefined;
@@ -303,10 +306,52 @@ export default function piJar(pi: ExtensionAPI): void {
   registerAskTool(pi);
   const modelRoles = new ModelRoleManager(pi);
   const sideUsage = new SideUsage();
-  registerAdvisor(pi, modelRoles, { enabled: () => visualSettings.advisor, gates: () => visualSettings.advisorGates, usage: sideUsage });
+  registerContextDiet(pi, () => visualSettings.contextDiet === true);
+  const advisor = registerAdvisor(pi, modelRoles, { enabled: () => !delegatedChild && visualSettings.advisor, gates: () => !delegatedChild && visualSettings.advisorGates, usage: sideUsage });
   registerInfoPanels(pi, { side: sideUsage, quotaEnabled: () => quotaCache?.enabled ?? false,
     quota: (ctx) => quotaCache?.get(ctx.model?.provider, welcomeStatuses(), Date.now()) });
-  modelRoles.register((ctx) => openRolesUi(ctx, modelRoles), { activateDefault: () => !delegatedChild });
+  let followingTheme: string | undefined;
+  const profileEntries = (ctx: ExtensionContext): readonly unknown[] => {
+    try { return ctx.sessionManager.getEntries?.() ?? sessionBranch(ctx); } catch { return sessionBranch(ctx); }
+  };
+  const applyProfileTheme = (name: string, ctx: ExtensionContext) => {
+    if (!ctx.hasUI || ctx.mode !== "tui" || typeof ctx.ui.setTheme !== "function") return;
+    const target = name === "follow" ? followingTheme ?? "system" : name;
+    if (!ctx.ui.getTheme?.(target)) throw new Error(`Theme ${target} is not loaded`);
+    const result = ctx.ui.setTheme(target);
+    if (result && !result.success) throw new Error(result.error ?? `Could not apply theme ${target}`);
+  };
+  const initializeProfiles = (ctx: ExtensionContext) => {
+    const previousTheme = ctx.ui.theme?.name;
+    followingTheme ??= previousTheme ?? "system";
+    try {
+      if (!existsSync(join(getAgentDir(), PROFILE_FILE))
+        && (!ctx.hasUI || ctx.mode !== "tui" || typeof ctx.ui.getAllThemes !== "function")) {
+        profileStore = undefined; visualSettings = loadVisualSettings(getAgentDir()); return undefined;
+      }
+      modelRoles.load(ctx.cwd);
+      const legacyAccent = loadVisualSettings(getAgentDir()).accent;
+      const legacyTheme = accentTheme(legacyAccent);
+      const initialTheme = legacyAccent !== "follow" && ctx.ui.getTheme?.(legacyTheme) ? legacyTheme : previousTheme ?? "system";
+      const store = new ProfileStore(getAgentDir(), initialTheme, modelRoles.profileRoleConfig());
+      const entries = profileEntries(ctx);
+      const id = pinnedProfileId(entries) ?? (conversationStarted(entries) ? "default" : store.active().id);
+      const profile = store.list().find((item) => item.id === id);
+      if (!profile) throw new Error("This session's profile is no longer available");
+      applyProfileTheme(profile.theme, ctx);
+      if (store.activeName !== profile.name) store.activate(profile.name);
+      profileStore = store;
+      visualSettings = profile.settings;
+      composer.setProfile(profile.name);
+      return { roles: profile.roles, profileId: profile.id };
+    } catch (error) {
+      if (previousTheme) { try { applyProfileTheme(previousTheme, ctx); } catch {} }
+      profileStore = undefined; visualSettings = loadVisualSettings(getAgentDir()); composer.setProfile("Default");
+      ctx.ui.notify(`Could not load profiles: ${(error as Error).message}`, "warning");
+      return undefined;
+    }
+  };
+  modelRoles.register((ctx) => openRolesUi(ctx, modelRoles), { activateDefault: () => !delegatedChild, beforeSessionStart: initializeProfiles });
   let delegateController: DelegateController | undefined;
   registerDelegate(pi, modelRoles, subagents, { changes: () => changes, changed: refreshChanges,
     discussionEnv: (key, name) => discussion?.childEnv(key, name),
@@ -478,7 +523,7 @@ export default function piJar(pi: ExtensionAPI): void {
           const quota = footerSettings.quota ? quotaCache?.get(ctx.model?.provider, statuses, Date.now()) : undefined;
           const open = todos?.all().filter((item) => !item.done) ?? [];
           const lines = welcomeLines(width, welcomeFrame, (color, text) => (ctx.ui.theme ?? theme).fg(color, text), {
-            ...info, settingsClickable: tui.mode !== "regular", roles: live.roles,
+            ...info, model: ctx.model?.id, profile: profileStore?.activeName ?? "Default", settingsClickable: tui.mode !== "regular", roles: live.roles,
             quota: quota?.week?.used ?? quota?.fiveHour?.used,
             effort: ctx.model?.reasoning === false ? "off" : pi.getThinkingLevel?.(),
             ...(modelRoles.activeRole() ? { activeRole: modelRoles.activeRole()! } : {}),
@@ -612,11 +657,26 @@ export default function piJar(pi: ExtensionAPI): void {
     }
   };
 
-  const applyVisualSettings = (next: JarVisualSettings, ctx: ExtensionContext) => {
+  const persistVisualPreferences = (next: JarVisualSettings, ctx: ExtensionContext, theme?: string) => {
+    if (profileStore) {
+      try { profileStore.update(profileStore.activeName, { settings: next, ...(theme ? { theme } : {}) }); }
+      catch (error) { ctx.ui.notify("Profile preferences changed for this session but could not be saved: " + (error as Error).message, "warning"); return; }
+    }
+    if (!profileStore || profileStore.active().id === "default") {
+      try { saveVisualSettings(getAgentDir(), next); }
+      catch { ctx.ui.notify("Visual preferences changed for this session but could not be saved", "warning"); }
+    }
+  };
+  const accentTheme = (accent: JarVisualSettings["accent"]) => accent === "follow" ? "follow" : accent === "default" ? "pi-jar-dark" : `pi-jar-dark-${accent}`;
+  const applyVisualSettings = (next: JarVisualSettings, ctx: ExtensionContext, options: { persist?: boolean; accent?: boolean } = {}) => {
     const wasEnabled = enabled;
     const hadMotion = animations;
+    const accentChanged = next.accent !== visualSettings.accent;
     const quotaShown = !!footerTui && footerSettings.quota;
-    if (next.accent !== visualSettings.accent && next.accent !== "follow" && !selectAccent(ctx, next.accent)) {
+    if (options.accent !== false && accentChanged && next.accent === "follow") {
+      try { applyProfileTheme("follow", ctx); } catch (error) { ctx.ui.notify(String(error), "warning"); return; }
+    }
+    if (options.accent !== false && accentChanged && next.accent !== "follow" && !selectAccent(ctx, next.accent)) {
       ctx.ui.notify(`Accent ${next.accent} is not loaded`, "warning");
       return;
     }
@@ -646,15 +706,75 @@ export default function piJar(pi: ExtensionAPI): void {
     welcomeTui?.requestRender();
     // Quota shown again (field or UI back on): hiding it stopped lookups and dropped the cache.
     if (!quotaShown) refreshQuota(ctx);
-    try { saveVisualSettings(getAgentDir(), next); }
-    catch { ctx.ui.notify("Visual preferences changed for this session but could not be saved", "warning"); }
+    if (options.persist !== false) persistVisualPreferences(next, ctx, accentChanged ? accentTheme(next.accent) : undefined);
   };
 
+  let switchingProfile = false;
+  const canSwitchProfile = (ctx: ExtensionContext) => {
+    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;
+    }
+    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 true;
+  };
+  const switchProfile = async (name: string, ctx: ExtensionContext) => {
+    if (!profileStore || name === profileStore.activeName || !canSwitchProfile(ctx)) return;
+    const store = profileStore;
+    const previous = store.active();
+    const previousTheme = ctx.ui.theme?.name;
+    const previousModel = ctx.model;
+    const previousRole = modelRoles.activeRole();
+    const previousThinking = pi.getThinkingLevel();
+    const next = store.list().find((profile) => profile.name === name);
+    if (!next) { ctx.ui.notify("Unknown profile: " + name, "warning"); return; }
+    switchingProfile = true;
+    try {
+      applyProfileTheme(next.theme, ctx);
+      store.activate(name);
+      modelRoles.invalidateTemporaryRestores();
+      modelRoles.load(ctx.cwd, next.roles, next.id);
+      composer.setProfile(next.name);
+      applyVisualSettings(next.settings, ctx, { persist: false, accent: false });
+      if (!await modelRoles.activate("default", ctx, true)) ctx.ui.notify("Profile loaded, but its default model is unavailable; keeping the current model", "warning");
+      repaint("profile"); welcomeTui?.requestRender();
+      ctx.ui.notify(`Profile: ${next.name}`, "info");
+    } catch (error) {
+      try { if (store.activeName !== previous.name) store.activate(previous.name); } catch {}
+      if (previousTheme) { try { applyProfileTheme(previousTheme, ctx); } catch {} }
+      modelRoles.load(ctx.cwd, previous.roles, previous.id);
+      try {
+        if (previousModel && ctx.model !== previousModel && !await pi.setModel(previousModel)) throw new Error("Previous model is unavailable");
+        pi.setThinkingLevel(previousThinking);
+        modelRoles.restoreActiveRole(previousRole, ctx);
+      } catch { ctx.ui.notify("Could not restore the previous model after the failed profile switch", "warning"); }
+      composer.setProfile(previous.name);
+      applyVisualSettings(previous.settings, ctx, { persist: false, accent: false });
+      ctx.ui.notify(`Could not switch profile: ${(error as Error).message}`, "warning");
+    } finally { switchingProfile = false; }
+  };
   openSettings = async (ctx) => {
     if (settingsOpen) return;
     settingsOpen = true;
     try { await openJarSettings(ctx, () => visualSettings,
-      (next) => applyVisualSettings(next, ctx), loadedAccents(ctx), piPreferences(ctx)); }
+      (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"); }
+          }
+        }
+      } : undefined); }
     finally { settingsOpen = false; }
   };
 
@@ -675,7 +795,8 @@ export default function piJar(pi: ExtensionAPI): void {
   };
   pi.on("session_start", (_event, ctx) => {
     sideUsage.clear();
-    visualSettings = loadVisualSettings(getAgentDir());
+    if (!profileStore) initializeProfiles(ctx);
+    composer.setProfile(profileStore?.activeName ?? "Default");
     setIconSet(visualSettings.icons);
     animations = visualSettings.animations;
     enabled = visualSettings.ui;
@@ -743,7 +864,7 @@ export default function piJar(pi: ExtensionAPI): void {
     composer.setMascot(visualSettings.mascot);
     if (visualSettings.composer && enabled) composer.enable(ctx);
     suggest.sync();
-    if (visualSettings.accent !== "follow") selectAccent(ctx, visualSettings.accent);
+    if (!profileStore && visualSettings.accent !== "follow") selectAccent(ctx, visualSettings.accent);
     if (branch.length >= LARGE_SESSION_ENTRIES) {
       try {
         const prefs = piPreferences(ctx)?.get();
@@ -778,11 +899,20 @@ export default function piJar(pi: ExtensionAPI): void {
     welcomeTui.requestRender();
   };
   pi.on("input", (event, ctx) => {
+    if (profileStore && !conversationStarted(profileEntries(ctx))) {
+      const id = profileStore.active().id;
+      if (pinnedProfileId(profileEntries(ctx)) !== id) pi.appendEntry?.(PROFILE_ENTRY, { version: 1, id });
+    }
     if (event.source !== "interactive") return;
     dismissWelcome(ctx);
     if (!todosAcknowledged && todos?.all().every((item) => item.done)) { todosAcknowledged = true; updateTaskWidget(ctx); }
   });
-  pi.on("agent_start", (_event, ctx) => { dismissWelcome(ctx); working.start(); applyWorking(ctx); refreshQuota(ctx); });
+  pi.on("agent_start", (_event, ctx) => {
+    if (profileStore && pinnedProfileId(profileEntries(ctx)) !== profileStore.active().id) {
+      pi.appendEntry?.(PROFILE_ENTRY, { version: 1, id: profileStore.active().id });
+    }
+    dismissWelcome(ctx); working.start(); applyWorking(ctx); refreshQuota(ctx);
+  });
   pi.on("turn_start", (_event, ctx) => { working.start(); applyWorking(ctx); });
   pi.on("message_end", (event, ctx) => {
     // Every message (user, assistant, tool result) moves the context window, and a tool-heavy turn
@@ -882,6 +1012,15 @@ export default function piJar(pi: ExtensionAPI): void {
       if (picked !== undefined) ctx.ui.setEditorText(picked);
     }
   });
+  pi.registerShortcut?.(Key.ctrlShift("tab"), {
+    description: "Switch pi-jar profile",
+    handler: async (ctx) => {
+      if (!ctx.hasUI || ctx.mode !== "tui" || !profileStore || settingsOpen) return;
+      const profiles = profileStore.list();
+      const index = profiles.findIndex((profile) => profile.name === profileStore!.activeName);
+      if (profiles.length > 1) await switchProfile(profiles[(index + 1) % profiles.length]!.name, ctx);
+    }
+  });
   pi.registerShortcut?.(Key.ctrlAlt("m"), {
     description: "Cycle pi-jar model roles",
     handler: async (ctx) => { await modelRoles.cycle(ctx); repaint("roles"); }
@@ -997,8 +1136,7 @@ export default function piJar(pi: ExtensionAPI): void {
         const applied = selectAccent(ctx, selected);
         if (applied) {
           visualSettings = { ...visualSettings, accent: selected as JarVisualSettings["accent"] };
-          try { saveVisualSettings(getAgentDir(), visualSettings); }
-          catch { ctx.ui.notify("Accent changed for this session but could not be saved", "warning"); }
+          persistVisualPreferences(visualSettings, ctx, accentTheme(visualSettings.accent));
           applyWorking(ctx);
         }
         const valid = selected === "default" || ACCENT_NAMES.some((name) => name === selected);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-jar",
-  "version": "0.1.9",
-  "description": "A warm, role-aware Pi terminal workspace with animated UI, plan and goal workflows, tasks, change review, model roles, background shells and subagents.",
+  "version": "0.2.0",
+  "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",
   "repository": {