pi-optchat 0.6.6 → 0.6.7

package/README.md

@@ -105,7 +105,9 @@ Set a different shortcut with `OPTCHAT_INSPECT_KEY=ctrl+shift+a pi`. If another
 
 Guidance shows as queued until delivered, or undelivered if the child stops first. Guidance you send is also saved in main memory. Reasoning is not shown. Transcripts stay browsable after restart, and browsing them makes no model calls.
 
-**Usage** shows this session, last hour, today, last 7 days, or all time (**Left/Right**). It breaks down main agent, subagents, compactor, and imports by model: uncached input, output, cache reads/writes, and estimated cost.
+**Usage** shows this session, last hour, today, last 7 days, or all time (**Left/Right**): one row per role and model (main agent, subagents, compactor, imports) with estimated cost, share of the total, output tokens, and how much input came from the cache. Costs are API prices, not your subscription bill.
+
+![Usage page](docs/screenshots/usage.png)
 
 - Costs are API-rate estimates, not your subscription bill. Unknown rates show zero.
 - Record counts are not request counts; retries and tool overhead can add records.
@@ -187,7 +189,7 @@ To delete a profile, delete its folder. Your original Pi sessions are kept in Pi
 
 ## How it differs from the recipe
 
-The recipe's four prompts are kept verbatim in `src/prompts.ts`, along with its numbers: 512-byte summary nodes, a 128,000-byte memory view, binary merges, 8 compression workers, fixed retry delays, 5 shortening attempts, and a 30,000-character tool output cap. Anthropic requests get stable cache breakpoints on the view. See `docs/victor-recipe.md` for notes.
+The recipe's four prompts are kept verbatim in `src/prompts.ts`, along with its numbers: 512-byte summary nodes (summaries up to 640 bytes are accepted without a retry), a 128,000-byte memory view, binary merges, 8 compression workers, fixed retry delays, 5 shortening attempts, and a 30,000-character tool output cap. Anthropic requests get stable cache breakpoints on the view, and when that view is not cached yet, one compactor call goes first and the others wait until it starts answering, so they read the cache instead of each writing it. See `docs/victor-recipe.md` for notes.
 
 Each run's context is the memory view, the previous exchange, and your new message. Deliberate additions:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-optchat",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "type": "module",
   "pi": {
     "extensions": [

package/src/agent-view.ts

@@ -3,7 +3,7 @@ import {
   createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition,
   type ExtensionContext,
 } from '@earendil-works/pi-coding-agent';
-import { Editor, Spacer, matchesKey, truncateToWidth, visibleWidth, type Component, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from '@earendil-works/pi-tui';
+import { Editor, Spacer, compositeTuiLine, matchesKey, truncateToWidth, visibleWidth, type Component, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from '@earendil-works/pi-tui';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { Children } from './agents.ts';
 import type { RunInfo } from './runs.ts';
@@ -297,10 +297,27 @@ export class AgentView implements Component, Focusable {
   }
 }
 
+/**
+ * Pi never composites overlays onto rows holding a terminal image (earendil-works/pi#6995), so images in the
+ * main chat would show through the full-screen view. While it is open, image rows under overlays are blanked.
+ * If Pi renames the hook, this quietly does nothing.
+ */
+export function hideImagesUnderOverlays(tui: TUI) {
+  Object.assign(tui, { compositeLineAt: (...[base, ...rest]: Parameters<typeof compositeTuiLine>) =>
+    compositeTuiLine(/\x1b_G|\x1b\]1337;File=/.test(base) ? '' : base, ...rest) });
+  return () => { Reflect.deleteProperty(tui, 'compositeLineAt'); };
+}
+
 /** Swaps the whole screen to the subagent's conversation; Pi restores the main chat on close. */
-export function showAgentView(ctx: ExtensionContext, options: { id: string; children: Children; signal?: AbortSignal }) {
-  return ctx.ui.custom<void>((tui, theme, keybindings, done) => new AgentView({ ...options, tui,
-    rows: () => tui.terminal.rows, redraw: () => tui.requestRender(), done: () => done(undefined),
-    color: (tone, text) => theme.fg(tone, text), isExpandKey: data => keybindings.matches(data, 'app.tools.expand'),
-  }), { overlay: true, overlayOptions: { width: '100%', maxHeight: '100%', row: 0, col: 0 } });
+export async function showAgentView(ctx: ExtensionContext, options: { id: string; children: Children; signal?: AbortSignal }) {
+  let restore = () => {};
+  try {
+    return await ctx.ui.custom<void>((tui, theme, keybindings, done) => {
+      restore = hideImagesUnderOverlays(tui);
+      return new AgentView({ ...options, tui,
+        rows: () => tui.terminal.rows, redraw: () => tui.requestRender(), done: () => done(undefined),
+        color: (tone, text) => theme.fg(tone, text), isExpandKey: data => keybindings.matches(data, 'app.tools.expand'),
+      });
+    }, { overlay: true, overlayOptions: { width: '100%', maxHeight: '100%', row: 0, col: 0 } });
+  } finally { restore(); }
 }

package/src/compactor.ts

@@ -3,32 +3,71 @@ import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
 import { COMPACT } from './prompts.ts';
 import { bytes, NODE, type Compressor } from './memory.ts';
-import { cachePayload } from './cache.ts';
+import { cachePayload, splitView } from './cache.ts';
 import { IMPORT_GUIDANCE } from './import/guidance.ts';
 
 export interface ModelChoice { provider: string; model: string; thinking: ThinkingLevel }
 const scaleBase = 'user: Keep work and personal memory separate; use a binary summary tree and inspect original messages before acting. talk: Implemented the append-only log with durable writes and a stable view. echo: Checked caching, chronological summaries, cancellation, and profile locks. user: Main agent uses Opus; compactor uses Sonnet at medium effort. work: Worker completed the parser; tests cover invalid records and repeated imports. talk: The browser opens original messages, preserving dates and sources.';
 export const SCALE = scaleBase.padEnd(NODE, '.').slice(0, NODE);
+/** The model is asked for 512 bytes; a small overshoot costs less view space than a retry costs money. */
+export const ACCEPTED = NODE * 1.25;
+const WARM_MS = 4 * 60_000; // Anthropic's short cache lives 5 minutes from its last use.
+
+/** Parallel calls can't read a cache entry that isn't written yet, so one call primes a cold prefix and the rest wait until it answers. */
+function primeFirst() {
+  const warm = new Map<string, number | Promise<void>>();
+  return async (prefix: string, signal: AbortSignal) => {
+    for (let state = warm.get(prefix); state !== undefined; state = warm.get(prefix)) {
+      if (typeof state === 'number') { if (Date.now() - state < WARM_MS) break; warm.delete(prefix); continue; }
+      // A cancelled waiter leaves at once instead of waiting for someone else's primer.
+      signal.throwIfAborted();
+      let wake = () => {};
+      const aborted = new Promise<void>(resolve => { wake = resolve; });
+      signal.addEventListener('abort', wake, { once: true });
+      await Promise.race([state, aborted]);
+      signal.removeEventListener('abort', wake);
+      signal.throwIfAborted();
+    }
+    let release = () => {};
+    const pending = warm.has(prefix) ? undefined : new Promise<void>(resolve => { release = resolve; });
+    if (pending) warm.set(prefix, pending);
+    return (ok: boolean) => {
+      if (ok) { for (const [k, at] of warm) if (typeof at === 'number' && Date.now() - at >= WARM_MS) warm.delete(k); warm.set(prefix, Date.now()); }
+      else if (warm.get(prefix) === pending) warm.delete(prefix);
+      release();
+    };
+  };
+}
 export function createCompressor(registry: ModelRegistry, choice: () => ModelChoice,
   onUsage: (message: AssistantMessage) => void = () => {}): Compressor {
+  const gate = primeFirst();
   return async (input, signal) => {
     const selected = choice();
     const model = registry.find(selected.provider, selected.model);
     if (!model) throw new Error(`Compactor model unavailable: ${selected.provider}/${selected.model}. Use /optchat model.`);
     const step = `${input.historical ? IMPORT_GUIDANCE + '\n\n' : ''}For scale, this line is exactly 512 bytes:\n${SCALE}\n\n${input.merge ? 'Merge these two lines into one' : 'Compress this message into one line'}, in at most 512 bytes:\n${input.source}`;
     const messages: Message[] = [{ role: 'user', content: [{ type: 'text', text: input.context }, { type: 'text', text: step }], timestamp: Date.now() }];
+    const view = splitView(input.context);
+    const prefix = model.api === 'anthropic-messages' && view.length > 1 ? `${model.provider}/${model.id}/${selected.thinking}\n${view.slice(0, -1).join('')}` : undefined;
     const tries: string[] = [];
     for (let attempt = 0; attempt < 5; attempt++) {
-      const reply = await registry.streamSimple(model, { systemPrompt: COMPACT, messages }, {
-        reasoning: selected.thinking === 'off' ? undefined : selected.thinking, signal, cacheRetention: 'short',
-        onPayload: payload => model.api === 'anthropic-messages' ? cachePayload(payload) : payload,
-      }).result();
+      const warmed = prefix ? await gate(prefix, signal) : () => {};
+      let reply: AssistantMessage;
+      try {
+        const stream = registry.streamSimple(model, { systemPrompt: COMPACT, messages }, {
+          reasoning: selected.thinking === 'off' ? undefined : selected.thinking, signal, cacheRetention: 'short',
+          onPayload: payload => model.api === 'anthropic-messages' ? cachePayload(payload) : payload,
+        });
+        // The cache entry is usable once the model starts answering.
+        for await (const event of stream) if (event.type !== 'start') { warmed(event.type !== 'error'); break; }
+        reply = await stream.result();
+      } finally { warmed(false); }
       onUsage(reply);
       if (reply.stopReason === 'error' || reply.stopReason === 'aborted') throw new Error(reply.errorMessage ?? `Compactor ${reply.stopReason}`);
       const line = reply.content.filter(c => c.type === 'text').map(c => c.text).join('').trim();
       if (!line) throw new Error('Compactor returned no text.');
       tries.push(line);
-      if (bytes(line) <= NODE) break;
+      if (bytes(line) <= ACCEPTED) break;
       messages.push(reply);
       const cut = Buffer.from(line).subarray(0, NODE).toString('utf8').replace(/\uFFFD$/, '');
       messages.push({ role: 'user', content: `That line is ${bytes(line)} bytes; the limit is 512. It must end where it is cut here:\n${cut}| ← LIMIT`, timestamp: Date.now() });

package/src/inspector.ts

@@ -2,11 +2,23 @@ import { matchesKey, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithA
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
 import type { Children } from './agents.ts';
 import { isActiveRun } from './runs.ts';
-import { ranges, summarizeUsage, type UsageLedger, type UsageRange } from './usage.ts';
+import type { Usage } from '@earendil-works/pi-ai';
+import { ranges, summarizeUsage, type UsageLedger, type UsageRange, type UsageRole } from './usage.ts';
 
 export const clean = (text: string) => text.replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, '').replace(/\t/g, '  ');
 export const oneLine = (text: string) => clean(text).replace(/\n/g, ' ');
 export const count = (n: number) => n.toLocaleString('en-US');
+const units = ['', 'k', 'M', 'B'];
+/** 950, 12.3k, 164k, 2.4M: enough precision to compare rows at a glance. A value that rounds to 1000 moves up a unit. */
+export const short = (n: number) => {
+  let unit = 0, value = n;
+  const round = (v: number) => v >= 100 || !unit ? Math.round(v) : Number(v.toFixed(1));
+  while (unit < units.length - 1 && round(value) >= 1000) { value /= 1000; unit++; }
+  return `${round(value)}${units[unit]}`;
+};
+const dollars = (n: number) => `$${n.toFixed(2)}`;
+const cached = (u: Usage) => { const input = u.input + u.cacheRead + u.cacheWrite; return `${input ? Math.round(100 * u.cacheRead / input) : 0}%`; };
+const roleNames: Record<UsageRole, string> = { main: 'main', subagent: 'subagents', compactor: 'compactor', import: 'import' };
 export const elapsed = (ms: number) => ms < 60_000 ? `${Math.max(0, Math.floor(ms / 1000))}s` : `${Math.floor(ms / 60_000)}m ${Math.floor(ms / 1000) % 60}s`;
 /** Shortens plain text with an ellipsis, preferring a word boundary. */
 export function fit(text: string, width: number) {
@@ -23,7 +35,7 @@ const spread = (left: string, right: string, width: number) => {
 export type InspectorPage = 'agents' | 'usage';
 /** Closing the panel either picks the subagent model or opens one agent's conversation. */
 export type InspectorAction = 'model' | { open: string };
-type Tone = 'accent' | 'muted' | 'dim' | 'error' | 'border';
+type Tone = 'accent' | 'muted' | 'dim' | 'error' | 'warning' | 'border';
 interface Options {
   profile: string; session: string; children: Children; usage: UsageLedger; page: InspectorPage;
   rows: () => number; redraw: () => void; done: (action?: InspectorAction) => void;
@@ -96,24 +108,34 @@ export class Inspector implements Component, Focusable {
       this.scroll = Math.max(0, Math.min(this.scroll, this.lineCount - this.height));
     }
   }
-  private usageLines() {
-    const { usage, session, context } = this.options;
+  /** Period tabs, one headline, then an aligned table with a row per role and model. */
+  private usageLines(width: number) {
+    const { usage, session, context, color } = this.options;
     const entries = usage.select(this.range, session);
     const { total, groups } = summarizeUsage(entries);
-    const input = total.input + total.cacheRead + total.cacheWrite;
-    const lines = [`← → period: ${this.range}`, '', `Total processed: ${count(total.totalTokens)} tokens · ${entries.length} usage records`,
-      `Input: ${count(input)} · Output: ${count(total.output)}`,
-      `Cache read: ${count(total.cacheRead)} · Cache write: ${count(total.cacheWrite)} · Hit rate: ${input ? (100 * total.cacheRead / input).toFixed(1) : '0'}%`,
-      `Estimated API-equivalent cost: $${total.cost.total.toFixed(4)}`, '',
-      'ROLE / MODEL — input · output · cache read/write · estimated cost'];
-    for (const g of groups) lines.push(`${g.role} / ${g.model}\n  ${count(g.usage.input)} uncached input · ${count(g.usage.output)} out · ${count(g.usage.cacheRead)}/${count(g.usage.cacheWrite)} cache · $${g.usage.cost.total.toFixed(4)} · ${g.requests} records`);
+    // No-break spaces keep a label like "Last 7 days" on one line when the tabs wrap.
+    const tabs = ranges.map(r => r.replaceAll(' ', '\u00a0')).map((r, i) => ranges[i] === this.range ? color('accent', `[${r}]`) : color('dim', r)).join('  ');
+    const lines = [...wrapTextWithAnsi(tabs, width), ''];
+    if (!entries.length) lines.push(color('muted', 'No usage in this period.'));
+    else {
+      lines.push(`${color('accent', dollars(total.cost.total))} estimated · ${short(total.totalTokens)} tokens · ${cached(total)} cached`, '');
+      const order = ['main', 'subagent', 'compactor', 'import'] as const;
+      const sorted = groups.sort((a, b) => order.indexOf(a.role) - order.indexOf(b.role) || b.usage.cost.total - a.usage.cost.total);
+      const rows = sorted.map((g, i) => [i && sorted[i - 1].role === g.role ? '' : roleNames[g.role], oneLine(g.model), dollars(g.usage.cost.total),
+        `${total.cost.total ? Math.round(100 * g.usage.cost.total / total.cost.total) : 0}%`, short(g.usage.output), cached(g.usage)]);
+      const header = ['', 'model', 'cost', 'share', 'out', 'cached'];
+      const widths = header.map((h, c) => Math.max(h.length, ...rows.map(r => r[c].length)));
+      // The model column goes first when the screen is too narrow for every column.
+      const columns = widths.reduce((sum, w) => sum + w + 2, 0) - 2 <= width ? [0, 1, 2, 3, 4, 5] : [0, 2, 3, 4, 5];
+      const line = (cells: string[]) => columns.map(c => c < 2 ? cells[c].padEnd(widths[c]) : cells[c].padStart(widths[c])).join('  ').trimEnd();
+      lines.push(color('dim', line(header)), ...rows.map(r => {
+        const text = line(r); return color('muted', text.slice(0, widths[0])) + text.slice(widths[0]);
+      }));
+    }
     const current = context();
-    lines.push('', `Current parent context (Pi estimate): ${current == null ? 'unavailable' : `${count(current)} tokens`} — separate from cumulative usage.`,
-      'Costs use model API rates when available; not your subscription bill or remaining allowance.',
-      'Usage updates when responses finish. Tool overhead may be a usage record without a request count.',
-      'Main tracking starts with this version; the resumed parent session and saved children are backfilled.',
-      'Older compactor/child records without a parent session appear only in date-based totals.', ...usage.warnings);
-    return lines.join('\n');
+    if (current != null) lines.push('', `${color('muted', 'Context now')} ${short(current)} tokens`);
+    lines.push('', color('dim', 'Estimated at API prices, not your subscription bill.'), ...usage.warnings.map(w => color('warning', w)));
+    return lines.flatMap(l => l ? wrapTextWithAnsi(l, width) : ['']);
   }
   render(width: number): string[] {
     const { color, children, profile } = this.options;
@@ -121,11 +143,11 @@ export class Inspector implements Component, Focusable {
     let title = `OptChat · ${profile} · ${this.page === 'usage' ? 'Usage' : 'Agents'}`;
     let info: string, body: string[], hint: string;
     if (this.page === 'usage') {
-      const lines = wrapTextWithAnsi(clean(this.usageLines()), inner); this.lineCount = lines.length;
+      const lines = this.usageLines(inner); this.lineCount = lines.length;
       this.scroll = Math.max(0, Math.min(this.scroll, lines.length - this.height));
       body = lines.slice(this.scroll, this.scroll + this.height);
       info = `${this.scroll + 1}–${Math.min(this.scroll + this.height, lines.length)} / ${lines.length}`;
-      hint = '←→ period · ↑↓/PgUp/PgDn scroll · Tab agents · Esc close';
+      hint = '←→ period · ↑↓ scroll · Tab agents · Esc close';
     } else {
       const list = children.history.list();
       if (!this.selected) this.selected = list[0]?.id;

package/src/usage.ts

@@ -91,13 +91,13 @@ export class UsageLedger {
 }
 
 export function summarizeUsage(entries: UsageEntry[]) {
-  const total = emptyUsage(), groups = new Map<string, { role: UsageRole; model: string; requests: number; usage: Usage }>();
+  const total = emptyUsage(), groups = new Map<string, { role: UsageRole; model: string; usage: Usage }>();
   for (const entry of entries) {
-    const model = entry.provider ? `${entry.provider}/${entry.model}` : entry.model;
-    const key = `${entry.role}:${model}`;
+    // By model name alone: older compactor records lack a provider and must still land in the same row.
+    const key = `${entry.role}:${entry.model}`;
     let group = groups.get(key);
-    if (!group) { group = { role: entry.role, model, requests: 0, usage: emptyUsage() }; groups.set(key, group); }
-    group.requests++; addUsage(group.usage, entry.usage); addUsage(total, entry.usage);
+    if (!group) { group = { role: entry.role, model: entry.model, usage: emptyUsage() }; groups.set(key, group); }
+    addUsage(group.usage, entry.usage); addUsage(total, entry.usage);
   }
   return { total, groups: [...groups.values()] };
 }