pi-jar 0.2.1 → 0.2.2

package/README.md

@@ -269,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/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.
 

package/extensions/index.ts

@@ -231,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;
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jar",
-  "version": "0.2.1",
+  "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");
 }
 
@@ -1809,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(); }
     },
@@ -1917,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."
@@ -1925,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." }))
@@ -1942,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/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/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;
+}