pi-jar 0.2.0 → 0.2.2

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.
 
@@ -268,14 +269,14 @@ This is a pi-jar enhancement: [pi-advisor](https://github.com/philipbrembeck/pi-
 - **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.
+- **`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; `report` returns an agent's latest full report (a synchronous `jar_delegate` result shares a 16k-character report budget across its runs and points here when it truncates). `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).
 - **Worktree finalization** — edits do not touch the parent merely because a worker settles or hibernates. On `jar_subagent stop`, pi-jar checks parent drift and reviewability, applies safe changes and adds them to `/diff`; conflicts remain isolated for retry or explicit discard. Failed worktree transcripts are compacted independently of finished history. Process closure is awaited before finalization, and failed multi-file application rolls back rather than leaving a partial result.
 - **`jar_democracy`** — **exceptional only**, for a persistent super-complex issue with several evidence-backed options after at least two distinct failed approaches. The moderator opens 2–8 options, resumes relevant idle/paused/hibernated fresh-context read-only scouts or spawns new scouts within the pool, and collects one private ballot per voter. A strict majority of invited voters wins; ties, plurality or missing/invalid ballots require user choice. Voting never implements its recommendation. A round has a 10-minute deadline and bounded rationales.
 - **`jar_discuss`** — session-local, parent-owned discussion broker over authenticated local IPC; no shared paper, lock or polling. `ask`/`answer` return stable IDs without echoing your text. `list` reads only relevant unread questions/answers and advances your cursor; `thread` (or `list` with `questionId`) reads one thread; `pending` shows counts without message bodies. `since: "d0"` rereads relevant mail. At most 128 messages, 1600 characters each and 128 KiB are retained; unread/unanswered questions block new posts instead of being silently lost. Messages do not wake idle agents; the next natural turn gets an unread notice.
 - **Activity view** — one split view (<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>A</kbd>, `/jar activity`, or a click on a footer row) for subagents, background shells and other extensions' teammates: list on the left, live details on the right (auto-follows; scroll up to pause, `f` to follow again). For a subagent the details show its task, its own checklist with subtasks, and a transcript like omp's: each tool call and message is one collapsed line that expands on demand (`Tab` into it, `↑↓`, `Enter`, or click) to show arguments and output, while streaming text shows live. `s` opens a steering input: type a message and press `Enter` to redirect the running subagent. `x` stops just that one. Finished runs stay listed for review.
 - **`/jar history`** — separate, read-only timeline of the active branch (paging, search, expandable details). Pi's native transcript is untouched.
-- Pi's built-in read/shell/edit/write tool cards render compactly: collapsed, each is one padded, state-colored card with its call line and a one-line summary (edit included), and partially streamed arguments never flicker to a fallback; the full output or diff stays one click or <kbd>Ctrl</kbd>+<kbd>O</kbd> away. Every requested frame re-renders the whole transcript, so background sources (subagent streams, shell changes, context and cost updates) share one adaptive repaint budget: at most every 250 ms below 300 branch entries, 500 ms below 800, 1 s below 2,000, and only on visible state changes beyond that; a frame Pi draws on its own satisfies pending updates. User actions and state changes (a subagent or shell starting, settling or failing) still repaint at once. The open activity view repaints live updates every 100 ms, slowing to 500 ms in very large sessions. Context usage is cached: session start, tree navigation, compaction, model changes, renames and the end of a run refresh it at once, while message ends recompute it at most every 750 ms. `/jar perf` shows the counters. The sliding bar some terminals show in the tab while the agent works is Pi's own `OSC 9;4` progress (`terminal.showTerminalProgress` in Pi settings), not pi-jar.
+- Pi's built-in read/shell/edit/write tool cards render compactly: collapsed, each is one padded, state-colored card with its call line and a one-line summary (edit included), and partially streamed arguments never flicker to a fallback; the full output or diff stays one click or <kbd>Ctrl</kbd>+<kbd>O</kbd> away. Every requested frame re-renders the whole transcript, so background sources (subagent streams, shell changes, context and cost updates) share one adaptive repaint budget: at most every 250 ms below 300 branch entries, 500 ms below 800, 1 s below 2,000, and only on visible state changes beyond that; a frame Pi draws on its own satisfies pending updates. User actions and state changes (a subagent or shell starting, settling or failing) still repaint at once. The open activity view repaints live updates every 100 ms, slowing to 500 ms in very large sessions. Context usage is cached: session start, tree navigation, compaction, model changes, renames and the end of a run refresh it at once, while message ends recompute it at most every 750 ms, widening up to 5 s when the measured computation is slow so sampling stays near a 1% duty cycle. `/jar perf` shows the counters. The sliding bar some terminals show in the tab while the agent works is Pi's own `OSC 9;4` progress (`terminal.showTerminalProgress` in Pi settings), not pi-jar.
 
 ## Settings
 

package/docs/EFFICIENCY_PLAN.md

@@ -0,0 +1,59 @@
+# Efficiency Plan
+
+## Status
+
+Triaged against the 0.2.1 codebase and partly implemented in v0.2.2. Most of the original proposal was either already shipped by the long-session work ([LONG_SESSION_PERFORMANCE_PLAN.md](./LONG_SESSION_PERFORMANCE_PLAN.md), 0.1.9–0.2.1) or costs more in complexity and risk than it saves. Only items with a measurable win and no behavior change were taken.
+
+## Goal
+
+Keep long sessions fast and cheap without losing stored history or changing what the model sees unless the user opted in.
+
+## Implemented in 0.2.2
+
+### Adaptive context sampling (was item 8)
+
+`ContextSampler` (`src/perf.ts`) now widens its mid-turn throttle from the measured cost of `getContextUsage()` instead of a fixed 750 ms: the window is `max(750 ms, 100 × median sample time)`, capped at 5 s. Mid-turn sampling therefore stays near a 1% duty cycle whatever the session size; cheap sessions keep the 750 ms cadence, and lifecycle boundaries (start, tree, compact, model, rename, settle) still refresh immediately. Measured cost is used rather than entry-count tiers because it is the quantity being bounded and needs no extra wiring. `/jar perf` shows the current window.
+
+### Profile pin lookup without a copy (part of item 9)
+
+`pinnedProfileId` walks the branch backwards in place instead of allocating `[...entries].reverse()`. `conversationStarted` already exits at the first user message, so it needed no change; neither runs per frame, so no incremental cache was added.
+
+### Cache-stable workflow prompts (follow-up)
+
+Plan and goal prompts used to be pruned to the newest copy on every call. Removing an earlier copy changes the conversation prefix, so each new turn (or goal round) re-sent the whole previous run uncached. `src/workflow-context.ts` now projects them so that every keep/drop decision depends only on earlier messages: identical plan/goal context is sent once, sent reminders and continuations stay in place, and leaving the mode drops them all once. It runs on Pi's message list before provider conversion, so it helps every provider that caches by prefix (Anthropic explicit breakpoints, OpenAI/DeepSeek/Gemini automatic prefix caching, Bedrock). Appending the context at the tail was rejected: pi-ai places the Anthropic cache breakpoint on the last message, so a moving tail would defeat the cache entirely.
+
+### Unset side roles are visible (follow-up)
+
+`askRole` notifies once per role when an unassigned role (advisor, commit, …) ran on the current main model, with the `/roles set` command to fix it. Behaviour is unchanged.
+
+### Bounded synchronous subagent results (follow-up)
+
+A synchronous `jar_delegate` result shares a 16k-character report budget across its runs (at least 2k each) instead of up to 12k per run. Truncated reports name `jar_subagent report <key>`, a new read-only action returning the full stored report. Event messages were already capped at 1.2k.
+
+### Cheaper subagent subscriber (follow-up)
+
+The footer's per-tick registry listener reads `DelegateRegistry.stateSignature()` straight from the map instead of `records()` (a second sweep, a sort and two arrays per 50 ms tick).
+
+## Already covered — dropped
+
+| Item | Why |
+| --- | --- |
+| 5. Tier subagent events | Already tiered: tool `onUpdate` ≤ 1 s, footer status only on state change, key/state changes are `transition` and everything else `background` in `RenderScheduler` (250 ms–1 s by session size, transitions-only beyond), Activity view coalesces at 100–500 ms. The 50 ms stream tick only feeds that scheduler. |
+| 6. Footer snapshot | `renderFooterLayout` already memoizes on a key of width/theme/view; repaints between changes are cache hits. A versioned snapshot would need change notifications from every source for a microsecond saving. |
+| 7. Bounded advisor fingerprints | `callKey` already keeps a 200-char prefix plus a SHA-1 of large inputs, so the loop window never pins large payloads. Prefix/suffix-only hashing would let distinct writes collide and trigger false loop alerts. |
+
+## Deferred
+
+| Item | Why |
+| --- | --- |
+| 1. Single Context Projector | The four `context` hooks (child automation filter, diet, plan, goal) are each one `customType` scan that allocates only when something is stale — negligible next to request serialization. Merging them couples independent modules for no measurable gain. Revisit only if `/jar perf` shows context hooks in a profile. |
+| 2. Context Diet v2 (`stripper` model, `DietSnapshot`) | A model-written summary replaces exact history with a lossy one, adds a side call per compression and duplicates Pi's own compaction. Needs its own design (fidelity, resumability, cache-hit impact) before code. |
+| 3. Diet-aware delegation | Depends on item 2. Today `scout` already starts fresh and `fork` is an explicit mode; changing the defaults alters subagent results. |
+| 4. Strict utility roles | Side calls without a role use the current model by design (`askRole`); making them fail or go deterministic breaks advisor and commit messages for users without roles. Addressed instead by the one-time notice above. |
+| 10. Compact workflow history | Rewriting persisted session history is ruled out; provider context is handled by the cache-stable projection above. |
+
+## Success criteria
+
+- Mid-turn context sampling cost stays bounded (~1% duty cycle) as sessions grow; visible in `/jar perf`.
+- Plan/goal sessions keep prefix-cache hits across turns and rounds on every provider.
+- Stored session history is unchanged.

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

@@ -68,7 +68,7 @@ State (`pi-jar.plan` entries, v2: `enabled`, `steps`, `text`, `path`, `title`) f
 - **Task gate:** with no open task, `write`/`edit` are blocked, and so are shell commands that are not on the read-only allowlist during the implement phase. During the audit, edits are blocked but verification commands are allowed.
 - **Roles per round:** implement rounds run on the `implement` role and the audit round on `advisor` (each only if assigned). The previous model and effort are restored when the run settles.
 - **Completion:** `jar_goal complete` requires the audit phase, no open tasks, and non-empty evidence. It ends the turn, records the evidence, and Ember shows `(★ᴗ★)`.
-- **Context hygiene:** only the newest goal context and continuation messages are kept in the prompt.
+- **Context hygiene:** repeated identical goal context is sent once, and goal prompts already sent are never removed from the middle of the prompt while the goal runs, so any provider's prefix cache (Anthropic, OpenAI, Gemini, Bedrock, …) keeps hitting. A completed goal drops them all.
 
 Goal events (`pi-jar.goal`, v2: `set`, `status`, `round`) are append-only session entries; v1 `set`/`clear` still replay.
 
@@ -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";
@@ -230,7 +231,7 @@ export default function piJar(pi: ExtensionAPI): void {
   let subagentSignature = "";
   subagents.subscribe(() => {
     if (!footerTui) return;
-    const signature = subagents.records().map(({ key, run }) => `${key}:${run.state}`).join(" ");
+    const signature = subagents.stateSignature();
     repaint("subagents", signature === subagentSignature ? "background" : "transition");
     subagentSignature = signature;
   });
@@ -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.2",
   "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/advisor.ts

@@ -239,7 +239,7 @@ export function registerAdvisor(pi: ExtensionAPI, roles: ModelRoleManager, optio
         }
         const selectedRoles = { resolve: () => primary, fallbackSpecs: () => fallbacks,
           resolveSpec: (spec: string) => targets.get(spec)!() } as unknown as ModelRoleManager;
-        const selectedContext = { model: ctx.model, modelRegistry: ctx.modelRegistry } as ExtensionContext;
+        const selectedContext = { model: ctx.model, modelRegistry: ctx.modelRegistry, ui: ctx.ui } as ExtensionContext;
         const conversation = transcript(sessionBranch(ctx) as readonly Entry[], 12_000);
         const git = await gitState(ctx, controller.signal);
         controller.signal.throwIfAborted();

package/src/delegate.ts

@@ -41,6 +41,9 @@ const allowedInMode = (mode: DelegateExecutionMode, name: string) => !RECURSIVE_
 export type DelegateMode = "scout" | "fork" | "worktree";
 type DelegateExecutionMode = DelegateMode | "direct";
 const MAX_OUTPUT_CHARS = 12_000;
+/** Shared budget for the reports one synchronous jar_delegate result returns; the rest stays one jar_subagent report away. */
+const MAX_RESULT_REPORT_CHARS = 16_000;
+const MIN_RUN_REPORT_CHARS = 2000;
 /** A working child that sends no RPC event for this long is treated as hung and killed. */
 const IDLE_TIMEOUT_MS = 10 * 60_000;
 /** After exit, grandchildren (MCP servers, shells) can hold the stdio pipes open; stop waiting for close. */
@@ -1090,6 +1093,12 @@ export class DelegateRegistry {
     for (const record of records) this.entries.set(record.key, { record });
     this.notify();
   }
+  /** Key/state of every record in insertion order: a cheap change test for per-tick listeners (no sweep, sort or copies). */
+  stateSignature(): string {
+    let signature = "";
+    for (const [key, { record }] of this.entries) signature += key + ":" + record.run.state + " ";
+    return signature;
+  }
   notify(): void {
     this.sweep();
     for (const listener of this.listeners) {
@@ -1124,7 +1133,7 @@ const fileList = (files: readonly string[], limit: number) => files.slice(0, lim
 const todoLine = (todo: Todo) => `${todo.parentId ? "    " : "  "}${todo.status === "completed" ? "[x]" : todo.status === "in_progress" ? "[~]" : "[ ]"} ${todo.title}`;
 
 /** What the parent agent reads back: the run's facts (time, tools, files, tasks, failures), then its own report. */
-export function runReport(run: DelegateRun, now = Date.now()): string {
+export function runReport(run: DelegateRun, now = Date.now(), outputLimit = MAX_OUTPUT_CHARS, key?: string): string {
   const counts = Object.entries(run.toolCounts).sort((a, b) => b[1] - a[1]).map(([name, count]) => `${name}×${count}`).join(", ");
   const facts = [
     run.startedAt !== undefined ? `took ${duration((run.endedAt ?? now) - run.startedAt)}` : "never started",
@@ -1143,7 +1152,10 @@ export function runReport(run: DelegateRun, now = Date.now()): string {
   }
   const failures = run.transcript.filter((entry): entry is ToolEntry => entry.kind === "tool" && entry.status === "error").slice(-5);
   if (failures.length) lines.push(`- failed tool calls: ${failures.map((entry) => cleanText(`${entry.name} ${entry.hint}`, 80)).join("; ")}`);
-  lines.push("", run.output || "(no report)");
+  const output = run.output.length > outputLimit
+    ? run.output.slice(0, outputLimit) + `\n… [report truncated; jar_subagent report ${key ?? run.name} returns the full text]`
+    : run.output;
+  lines.push("", output || "(no report)");
   return lines.join("\n");
 }
 
@@ -1258,6 +1270,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 +1351,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 +1411,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> = {
@@ -1780,7 +1821,9 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
         flushUpdate();
         toolReturned = true;
       }
-      return { content: [{ type: "text", text: runs.map((run) => runReport(run)).join("\n\n") }], details: details(),
+      const outputLimit = Math.max(MIN_RUN_REPORT_CHARS, Math.floor(MAX_RESULT_REPORT_CHARS / Math.max(1, runs.length)));
+      const keys = new Map(records.map(({ key, run }) => [run, key]));
+      return { content: [{ type: "text", text: runs.map((run) => runReport(run, Date.now(), outputLimit, keys.get(run))).join("\n\n") }], details: details(),
         ...(runs.some((run) => run.state === "failed") ? { isError: true } : {}) };
       } finally { releaseReservation(); }
     },
@@ -1874,13 +1917,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({
@@ -1889,7 +1931,7 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
     description: "Non-blocking moderator control for retained subagents. peek, steer, resume and discard return immediately. ask, pause and stop return an accepted operation receipt; the final answer or handoff arrives as a pi-jar.subagent event. Settled agents hibernate (process closed, context and workspace kept); resume and ask relaunch them transparently. Stop completion safely reconciles worktree changes; acceptance does not mean changes are applied yet. discard removes an unresolved worktree recovery workspace without applying it.",
     promptSnippet: "Use jar_subagent as the moderator control plane. Prefer peek over rereading transcripts; reuse paused/idle/hibernated agents with resume; stop finished workers to reconcile their work.",
     promptGuidelines: [
-      "peek returns only task progress, plus workspace and changed files for unresolved worktree recovery records. Do not poll: initial/resumed turns and control completions send pi-jar.subagent events. Stop returns an accepted receipt first, then changed files and the full handoff in its completion event.",
+      "peek returns only task progress, plus workspace and changed files for unresolved worktree recovery records. report returns an agent's latest full report when a result or event shows only part of it. Do not poll: initial/resumed turns and control completions send pi-jar.subagent events. Stop returns an accepted receipt first, then changed files and the full handoff in its completion event.",
       "Use steer for active direction and ask for a brief BTW question. ask, pause and stop do not wait on the child; continue responding to the user until their completion event arrives.",
       "Pause when an agent should stop spending tokens but keep its context/workspace. Resume the same agent later instead of spawning a replacement; a hibernated agent resumes exactly like an idle one.",
       "Stop when an agent is no longer needed. Stop aborts any active turn, retires the process, reports progress/workspace/changes/remaining work, and reconciles safe worktree changes into /diff. On a failed/conflicted worktree recovery record, stop retries reconciliation; discard it only when its changes are not wanted."
@@ -1897,7 +1939,7 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
     parameters: Type.Object({
       action: Type.Union([
         Type.Literal("peek"), Type.Literal("steer"), Type.Literal("ask"),
-        Type.Literal("pause"), Type.Literal("resume"), Type.Literal("stop"), Type.Literal("discard")
+        Type.Literal("pause"), Type.Literal("resume"), Type.Literal("stop"), Type.Literal("discard"), Type.Literal("report")
       ]),
       agent: Type.Optional(Type.String({ description: "Subagent key or unique name. Omit only for peek to show all retained agents." })),
       message: Type.Optional(Type.String({ description: "Direction, BTW question, or resume instruction." }))
@@ -1914,6 +1956,7 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
       const agent = params.agent ?? "";
       const record = registry.resolve(agent);
       if (!record) return { content: [{ type: "text", text: "Subagent not found or name is ambiguous: " + agent }], isError: true };
+      if (params.action === "report") return { content: [{ type: "text", text: runReport(record.run) }] };
       const stopping = pendingControls.get(record.key + ":stop");
       const controlling = pendingControls.get(record.key + ":control");
       if (stopping || (controlling && params.action !== "stop")) {

package/src/goal-loop.ts

@@ -5,6 +5,7 @@ import type { Goal, GoalStore } from "./goals.ts";
 import type { ModelRoleManager } from "./model-roles.ts";
 import { isSafePlanCommand } from "./plan-utils.ts";
 import type { Todo, TodoStore } from "./tasks.ts";
+import { projectWorkflowMessages } from "./workflow-context.ts";
 
 export const GOAL_TOOL = "jar_goal";
 export const DEFAULT_GOAL_ROUNDS = 8;
@@ -267,31 +268,16 @@ export class GoalLoop {
       return { message: { customType: CONTEXT_TYPE, content: this.context(goal), display: false } };
     });
 
-    // Keep only the newest goal context and continuation. Context rewrites apply to a single LLM
-    // call, so prune on every call; scan in place and allocate only when something is stale.
+    // Never drop an already-sent goal prompt mid-history while the goal runs: that would re-bill the
+    // previous run uncached. Repeated identical context is sent once; a finished goal drops all.
     this.pi.on("context", async (event) => {
       const goal = this.goal();
       const active = !!goal && goal.status !== "complete";
-      let latestContext = -1;
-      let latestContinuation = -1;
-      let needsPrune = false;
-      for (let index = event.messages.length - 1; index >= 0; index--) {
-        const type = (event.messages[index] as { customType?: string }).customType;
-        if (type === CONTEXT_TYPE) {
-          if (!active || latestContext >= 0) needsPrune = true;
-          else latestContext = index;
-        } else if (type === CONTINUATION_TYPE) {
-          if (!active || latestContinuation >= 0) needsPrune = true;
-          else latestContinuation = index;
-        }
-      }
-      if (!needsPrune) return;
-      return { messages: event.messages.filter((raw, index) => {
-        const type = (raw as { customType?: string }).customType;
-        if (type === CONTEXT_TYPE) return active && index === latestContext;
-        if (type === CONTINUATION_TYPE) return active && index === latestContinuation;
-        return true;
-      }) };
+      const messages = projectWorkflowMessages(event.messages, {
+        [CONTEXT_TYPE]: { keep: active, dedupe: true },
+        [CONTINUATION_TYPE]: { keep: active }
+      });
+      if (messages) return { messages };
     });
 
     this.pi.on("agent_before_settle", async (event, ctx) => {

package/src/perf.ts

@@ -185,6 +185,9 @@ export class RenderScheduler {
 
 /** Mid-turn context recomputation happens at most this often; boundaries refresh at once. */
 export const CONTEXT_SAMPLE_MS = 750;
+/** Costly samples widen the window to keep mid-turn sampling near a 1% duty cycle, up to this cap. */
+export const CONTEXT_SAMPLE_MAX_MS = 5000;
+const CONTEXT_SAMPLE_DUTY = 100;
 export interface ContextUsageLike { percent?: number | null }
 export interface ContextSamplingStats {
   label: string;
@@ -197,6 +200,8 @@ export interface ContextSamplingStats {
   /** Median over the latest samples. */
   medianMs?: number;
   lastSampleAgeMs?: number;
+  /** Current mid-turn throttle window, widened from the median sample cost. */
+  windowMs: number;
   dirty: boolean;
   pending: boolean;
 }
@@ -253,20 +258,31 @@ export class ContextSampler {
       const before = this.current;
       this.sample();
       if (this.current !== before) this.changed();
-    }, Math.max(0, (this.lastSampleAt ?? Number.NEGATIVE_INFINITY) + this.throttleMs - this.now()));
+    }, Math.max(0, (this.lastSampleAt ?? Number.NEGATIVE_INFINITY) + this.windowMs() - this.now()));
     this.timer.unref?.();
   }
 
   stats(): ContextSamplingStats {
-    const sorted = [...this.durations].sort((a, b) => a - b);
+    const median = this.medianMs();
     return {
       label: this.current, ...this.counts,
-      ...(sorted.length ? { medianMs: sorted[Math.floor(sorted.length / 2)]! } : {}),
+      ...(median !== undefined ? { medianMs: median } : {}),
       ...(this.lastSampleAt !== undefined ? { lastSampleAgeMs: this.now() - this.lastSampleAt } : {}),
-      dirty: this.stale, pending: this.timer !== undefined
+      windowMs: this.windowMs(), dirty: this.stale, pending: this.timer !== undefined
     };
   }
 
+  private medianMs(): number | undefined {
+    if (!this.durations.length) return undefined;
+    return [...this.durations].sort((a, b) => a - b)[Math.floor(this.durations.length / 2)]!;
+  }
+
+  /** Cost-adaptive: large sessions whose usage walk is slow sample less often mid-turn. */
+  private windowMs(): number {
+    const cost = (this.medianMs() ?? 0) * CONTEXT_SAMPLE_DUTY;
+    return Math.max(this.throttleMs, Math.min(CONTEXT_SAMPLE_MAX_MS, Math.round(cost)));
+  }
+
   /** Session shutdown: no timer, and no reference to the old session's context. */
   dispose(): void {
     clearTimeout(this.timer);
@@ -386,6 +402,7 @@ export function formatPerf(snapshot: PerfSnapshot): string {
     ["dirty marks", count(sampling.marks)],
     ["total time", ms(sampling.totalMs)],
     ["max time", ms(sampling.maxMs) + (sampling.medianMs !== undefined ? ` (median ${ms(sampling.medianMs)})` : "")],
+    ["window", ms(sampling.windowMs) + " mid-turn"],
     ["last sample age", sampling.lastSampleAgeMs !== undefined ? age(sampling.lastSampleAgeMs) : "never"],
     ["pending", sampling.pending ? "sample scheduled" : sampling.dirty ? "yes" : "no"]
   ]);

package/src/plan.ts

@@ -11,6 +11,7 @@ import { extractApproachSteps, isSafePlanCommand, PLAN_TEMPLATE, planTextFromSte
 import { cleanText } from "./status.ts";
 import { sessionBranch } from "./session-branch.ts";
 import { type TodoStore } from "./tasks.ts";
+import { projectWorkflowMessages } from "./workflow-context.ts";
 
 export const PLAN_ENTRY = "pi-jar.plan";
 export const PLAN_SUBMIT_TOOL = "jar_plan_submit";
@@ -417,30 +418,14 @@ export class PlanMode {
       return { message: { customType: "pi-jar.plan-context", content: this.context(), display: false } };
     });
 
-    // Keep plan-only prompt messages bounded. When plan mode is active, retain only the newest
-    // context and newest reminder; when it is off, remove all stale plan prompt messages. Context
-    // rewrites apply to a single LLM call, so this runs on every call.
+    // Plan context is identical every turn: send its first copy only, keeping the cached prefix
+    // stable. Reminders stay in place while active; leaving plan mode drops all of them.
     this.pi.on("context", async (event) => {
-      let latestContext = -1;
-      let latestReminder = -1;
-      let needsPrune = false;
-      for (let index = event.messages.length - 1; index >= 0; index--) {
-        const type = (event.messages[index] as { customType?: string }).customType;
-        if (type === "pi-jar.plan-context") {
-          if (!this.enabled || latestContext >= 0) needsPrune = true;
-          else latestContext = index;
-        } else if (type === "pi-jar.plan-reminder") {
-          if (!this.enabled || latestReminder >= 0) needsPrune = true;
-          else latestReminder = index;
-        }
-      }
-      if (!needsPrune) return;
-      return { messages: event.messages.filter((raw, index) => {
-        const type = (raw as { customType?: string }).customType;
-        if (type === "pi-jar.plan-context") return this.enabled && index === latestContext;
-        if (type === "pi-jar.plan-reminder") return this.enabled && index === latestReminder;
-        return true;
-      }) };
+      const messages = projectWorkflowMessages(event.messages, {
+        "pi-jar.plan-context": { keep: this.enabled, dedupe: true },
+        "pi-jar.plan-reminder": { keep: this.enabled }
+      });
+      if (messages) return { messages };
     });
 
     this.pi.on("input", (event) => {

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/profiles.ts

@@ -16,7 +16,8 @@ export function conversationStarted(entries: readonly unknown[]): boolean {
     || (entry.type === "message" && isPlainObject(entry.message) && entry.message.role === "user")));
 }
 export function pinnedProfileId(entries: readonly unknown[]): string | undefined {
-  for (const entry of [...entries].reverse()) {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
     if (isPlainObject(entry) && entry.type === "custom" && entry.customType === PROFILE_ENTRY
       && isPlainObject(entry.data) && entry.data.version === 1 && typeof entry.data.id === "string") return entry.data.id;
   }

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/side-model.ts

@@ -26,6 +26,19 @@ export class SideUsage {
 
 export interface SideAnswer { text: string; model: string }
 
+/** Roles already told, this process, that they ran on the current (main) model. */
+const unsetRoleNotices = new Set<string>();
+
+/** An unassigned side role silently costs main-model prices; say so once per role. */
+function noteCurrentModel(ctx: ExtensionContext, role: string, model: string): void {
+  if (unsetRoleNotices.has(role)) return;
+  unsetRoleNotices.add(role);
+  try {
+    ctx.ui?.notify(`${role} role is unset, so it used the current model (${model}). `
+      + `Assign a cheaper one with /roles set ${role} PROVIDER/MODEL.`, "info");
+  } catch { /* the notice is advisory */ }
+}
+
 /**
  * Ask the model assigned to `role` (or the current model) a one-shot question outside the
  * conversation. Tries configured fallbacks in order on failure; cancellation never retries.
@@ -71,6 +84,7 @@ export async function askRole(ctx: ExtensionContext, roles: ModelRoleManager, us
       }
       text = text.trim();
       if (!text) throw new Error(`${name} returned an empty answer`);
+      if (!assigned) noteCurrentModel(ctx, role, name);
       return { text, model: name };
     } catch (error) {
       signal?.throwIfAborted();

package/src/workflow-context.ts

@@ -0,0 +1,37 @@
+/** How one hidden workflow message type is projected into provider context. */
+export interface WorkflowMessageRule {
+  /** False drops every message of this type (its mode is off). */
+  keep: boolean;
+  /** Drop a message whose content repeats the previously kept one of the same type. */
+  dedupe?: boolean;
+}
+
+/**
+ * Provider-context projection for hidden workflow prompts (plan/goal context, reminders,
+ * continuations). Pi caches the conversation prefix, so a message once sent must keep being sent:
+ * every keep/drop decision depends only on the messages before it, never on later ones. Dropping
+ * an older copy when a newer one arrives would change the prefix and re-bill the whole previous
+ * run uncached. Returns undefined when nothing changes.
+ */
+export function projectWorkflowMessages<T>(messages: T[], rules: Readonly<Record<string, WorkflowMessageRule>>): T[] | undefined {
+  const last = new Map<string, string>();
+  let projected: T[] | undefined;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index]!;
+    const type = (message as { customType?: string }).customType;
+    const rule = type === undefined ? undefined : rules[type];
+    let keep = true;
+    if (rule) {
+      if (!rule.keep) keep = false;
+      else if (rule.dedupe) {
+        const raw = (message as { content?: unknown }).content;
+        const content = typeof raw === "string" ? raw : JSON.stringify(raw ?? "");
+        if (last.get(type!) === content) keep = false;
+        else last.set(type!, content);
+      }
+    }
+    if (!keep) projected ??= messages.slice(0, index);
+    else projected?.push(message);
+  }
+  return projected;
+}

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