pi-jar 0.1.9 → 0.2.1

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. |
@@ -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. |
@@ -79,6 +80,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 +89,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.
+
+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.
+
 ## Welcome screen
 
 The welcome stays until your first prompt, then dissolves (or hides immediately with motion off).
@@ -115,7 +125,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 +223,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 +266,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/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

@@ -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,15 @@ 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 { 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";
 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 +100,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 +307,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 +524,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 +658,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,17 +707,91 @@ 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 profileSwitchBlocked = (ctx: ExtensionContext): string | undefined => {
+    if (switchingProfile || advisor.isBusy() || !ctx.isIdle?.() || working.phase !== "idle" || planMode.isEnabled() || goals?.isActive() || subagents.running() > 0) {
+      return "Finish the active agent/workflow before switching profiles";
+    }
+    if (conversationStarted(profileEntries(ctx)) || pinnedProfileId(profileEntries(ctx)) !== undefined) {
+      return "This session's profile is locked. Open a new session to switch profiles";
+    }
+    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;
+    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; }
+  };
+  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)); }
+      (next) => applyVisualSettings(next, ctx), loadedAccents(ctx), piPreferences(ctx), profileStore ? {
+        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) => {
@@ -675,7 +810,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 +879,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 +914,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 +1027,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 +1151,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.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",
   "repository": {