pi-optchat 0.6.7 → 0.7.0

package/src/report-message.ts

@@ -4,8 +4,12 @@ import { REPORT_TYPE, textContent } from './transcript.ts';
 
 const HEAD = /^\[([0-9a-f]{8})\] (?:(Message from subagent \(still running\)|Connected agent message): )?/;
 
+/** Sent with a report: `count` subagent reports joined in one message, when one spawn's reports arrive together. */
+export interface ReportDetails { count?: number }
+
 /** Split "[id] Message from subagent (still running): body" into a short label and the body. */
-export function reportParts(text: string) {
+export function reportParts(text: string, count = 1) {
+  if (count > 1) return { label: `${count} subagent reports`, body: text };
   const match = HEAD.exec(text);
   if (!match) return { label: 'subagent', body: text };
   const kind = match[2] === undefined ? 'report' : match[2].startsWith('Message') ? 'still running' : 'connected window';
@@ -21,8 +25,8 @@ function darkBackground(theme: Theme) {
 }
 
 /** Background traffic: a dark neutral box with dim text, so it never looks like something the user typed. */
-export function reportBox(text: string, outputPad: number, theme: Theme) {
-  const { label, body } = reportParts(text);
+export function reportBox(text: string, outputPad: number, theme: Theme, count?: number) {
+  const { label, body } = reportParts(text, count);
   const box = new Box(outputPad, 1, darkBackground(theme));
   box.addChild(new Text(theme.fg('dim', `↳ ${label}`), 0, 0));
   box.addChild(new Markdown(body.trim(), 0, 0, getMarkdownTheme(), { color: text => theme.fg('muted', text) }));
@@ -30,5 +34,5 @@ export function reportBox(text: string, outputPad: number, theme: Theme) {
 }
 export const isReport = (text: string) => HEAD.test(text);
 export function registerReportRenderer(pi: ExtensionAPI) {
-  pi.registerMessageRenderer(REPORT_TYPE, (message, { outputPad }, theme) => reportBox(textContent(message.content), outputPad, theme));
+  pi.registerMessageRenderer<ReportDetails | undefined>(REPORT_TYPE, (message, { outputPad }, theme) => reportBox(textContent(message.content), outputPad, theme, message.details?.count));
 }

package/src/runs.ts

@@ -19,6 +19,18 @@ export interface RunInfo {
   /** `from` is missing on runs saved before senders were recorded. */
   guidance: { text: string; date: number; state: 'queued' | 'delivered' | 'undelivered'; from?: 'user' | 'manager' }[];
 }
+const moves: Record<RunState, readonly RunState[]> = {
+  running: ['waiting', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'],
+  waiting: ['running', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'],
+  stopping: ['stopped', 'failed', 'interrupted'],
+  // A finished run only takes the outcome of a connected handoff.
+  completed: ['interrupted'], failed: ['completed', 'interrupted'], stopped: ['completed', 'interrupted'], interrupted: ['completed'],
+};
+/** Every run state change goes through here, so a late stop cannot rewrite a finished run. Returns whether the run is now in `to` (true for a repeat, so a second stop can still abort a child that ignored the first). */
+export function transition(run: RunInfo, to: RunState) {
+  if (run.state !== to && !moves[run.state].includes(to)) return false;
+  run.state = to; return true;
+}
 export const isActiveRun = (run: RunInfo) => run.state === 'running' || run.state === 'waiting' || run.state === 'stopping';
 function isRun(value: unknown): value is RunInfo {
   return record(value) && ['id', 'task', 'cwd', 'model', 'thinking', 'parentSession'].every(k => typeof value[k] === 'string')
@@ -31,7 +43,7 @@ function isRun(value: unknown): value is RunInfo {
     && (value.handoff === undefined || record(value.handoff) && ['complete', 'disconnected', 'owner-stopped', 'failed'].includes(String(value.handoff.reason))
       && (value.handoff.text === undefined || typeof value.handoff.text === 'string')
       && (value.handoff.delivered === undefined || typeof value.handoff.delivered === 'boolean'))
-    && typeof value.depth === 'number' && Number.isInteger(value.depth) && value.depth >= 1 && value.depth <= 3
+    && typeof value.depth === 'number' && Number.isInteger(value.depth) && value.depth >= 1
     && (value.parentId === undefined || typeof value.parentId === 'string')
     && Array.isArray(value.guidance) && value.guidance.every(g => record(g) && typeof g.text === 'string' && typeof g.date === 'number' && ['queued', 'delivered', 'undelivered'].includes(String(g.state)) && (g.from === undefined || g.from === 'user' || g.from === 'manager'));
 }
@@ -57,7 +69,7 @@ export class RunHistory {
         this.records.set(run.id, run);
         if (isActiveRun(run)) {
           if (run.connected) run.handoff ??= { reason: 'owner-stopped' };
-          run.state = 'interrupted'; run.ended = Date.now();
+          transition(run, 'interrupted'); run.ended = Date.now();
           run.report = 'Pi closed before this agent finished. Its partial transcript is retained.';
           for (const g of run.guidance) if (g.state === 'queued') g.state = 'undelivered';
           this.save(run);

package/src/settings-page.ts

@@ -0,0 +1,164 @@
+import { Container, fuzzyFilter, getKeybindings, Input, SelectList, SettingsList, Spacer, Text, type Component, type SelectItem, type SettingItem } from '@earendil-works/pi-tui';
+import { DynamicBorder, type ExtensionContext, type Theme } from '@earendil-works/pi-coding-agent';
+import { defaults, THINKING, type ProfileConfig } from './profiles.ts';
+import { invalid, isNumberKey, SETTING_KEYS, SETTINGS, type NumberKey, type SettingKey } from './settings.ts';
+import type { ModelChoice } from './compactor.ts';
+import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
+
+type Role = 'compactor' | 'subagent';
+const ROLES: Record<Role, { label: string; description: string; applies: string }> = {
+  compactor: { label: 'Compactor model', description: 'Writes memory summaries, imports and connected-window handoffs. Shortcut: /optchat model.', applies: 'Applies to the next summary.' },
+  subagent: { label: 'Subagent model', description: 'Runs every subagent. Shortcut: /optchat agents model.', applies: 'Applies to subagents started after this.' },
+};
+const modelName = (choice: ModelChoice) => `${choice.provider}/${choice.model}`;
+const showModel = (choice: ModelChoice) => `${modelName(choice)} · ${choice.thinking}`;
+/** The value column: the model, then whether it is the default (shown short, without its provider). */
+const modelValue = (theme: Theme, role: Role, choice: ModelChoice) => `${showModel(choice)}${theme.fg('dim', showModel(choice) === showModel(defaults[role])
+  ? '  default' : `  default ${defaults[role].model} · ${defaults[role].thinking}`)}`;
+const show = (key: SettingKey, value: number | boolean) => {
+  const spec = SETTINGS[key];
+  return typeof value === 'boolean' ? value ? 'on' : 'off' : spec.kind === 'number' && spec.unit ? `${value} ${spec.unit}` : String(value);
+};
+
+interface Options {
+  profile: string; config: ProfileConfig;
+  /** Each model with the thinking levels Pi can send it (Sonnet 5.5 has no "off"). */
+  models: { name: string; thinking: readonly ThinkingLevel[] }[];
+  /** Saves the whole profile config; throws if it can't be written. */
+  save: (config: ProfileConfig) => void;
+}
+
+/** A titled step inside the page: what it changes, the control, and its keys. */
+function step(theme: Theme, title: string, description: string, control: Component, hint: string, extra: Component[] = []) {
+  const box = new Container();
+  for (const child of [new Text(theme.bold(theme.fg('accent', title)), 0, 0), new Spacer(1), new Text(theme.fg('muted', description), 0, 0),
+    new Spacer(1), control, ...extra, new Spacer(1), new Text(theme.fg('dim', hint), 0, 0)]) box.addChild(child);
+  return box;
+}
+const listTheme = (theme: Theme) => ({ selectedPrefix: (t: string) => theme.fg('accent', t), selectedText: (t: string) => theme.fg('accent', t),
+  description: (t: string) => theme.fg('muted', t), scrollInfo: (t: string) => theme.fg('muted', t),
+  noMatch: () => theme.fg('muted', '  No matching models. Pi lists the models you are logged in to.') });
+
+/** Whole numbers only: typing replaces the value, Enter saves it, a bad value stays on screen with the reason. */
+class NumberStep extends Container {
+  private readonly input: Input;
+  private readonly error = new Text('', 0, 0);
+  constructor(theme: Theme, key: NumberKey, current: number, submit: (value: number) => string | undefined, cancel: () => void) {
+    super();
+    const spec = SETTINGS[key];
+    // Empty with the current value as placeholder: typing starts a new value, Enter alone keeps the old one.
+    this.input = new Input({ placeholder: String(current), placeholderStyle: text => theme.fg('dim', text) }); this.input.focused = true;
+    this.input.onEscape = cancel;
+    this.input.onSubmit = text => {
+      if (!text.trim()) return cancel();
+      const value = /^\s*\d+\s*$/.test(text) ? Number(text) : NaN;
+      const problem = invalid(key, value) ?? submit(value);
+      if (problem) this.error.setText(theme.fg('error', problem));
+    };
+    this.addChild(step(theme, `${spec.label}${spec.unit ? ` (${spec.unit})` : ''}`, `${spec.description} Default ${show(key, spec.default)}.`,
+      this.input, 'Type a number · Enter to save · Esc to go back', [this.error]));
+  }
+  handleInput(data: string) { this.input.handleInput(data); }
+}
+
+/** Model first (type to filter), then thinking level; Esc goes back a step. */
+class ModelStep extends Container {
+  private active: { handleInput(data: string): void } = { handleInput: () => {} };
+  constructor(private readonly theme: Theme, private readonly role: Role, private readonly models: Options['models'], private readonly current: ModelChoice,
+    private readonly submit: (choice: ModelChoice) => string | undefined, private readonly cancel: () => void) {
+    super();
+    this.pickModel();
+  }
+  private pickModel() {
+    const { theme, current } = this, filter = new Input();
+    const items: SelectItem[] = this.models.map(({ name }) => ({ value: name, label: name }));
+    let list = new SelectList(items, 10, listTheme(theme));
+    const build = () => {
+      list = new SelectList(filter.getValue() ? fuzzyFilter(items, filter.getValue(), i => i.value) : items, 10, listTheme(theme));
+      list.onSelect = item => this.pickThinking(item.value); list.onCancel = this.cancel;
+      return list;
+    };
+    build(); list.setSelectedIndex(Math.max(0, this.models.findIndex(m => m.name === modelName(current))));
+    filter.focused = true;
+    const box = step(theme, ROLES[this.role].label, `${ROLES[this.role].description} Now ${showModel(current)}.`, filter, 'Type to filter · Enter to choose · Esc to go back', [new Spacer(1), list]);
+    this.show(box, data => {
+      const keys = getKeybindings();
+      if ((['tui.select.up', 'tui.select.down', 'tui.select.confirm', 'tui.select.cancel'] as const).some(k => keys.matches(data, k))) return list.handleInput(data);
+      filter.handleInput(data);
+      const index = box.children.indexOf(list); box.children[index] = build();
+    });
+  }
+  private pickThinking(model: string) {
+    const { theme, current } = this, error = new Text('', 0, 0);
+    const levels = this.models.find(m => m.name === model)?.thinking ?? THINKING;
+    const list = new SelectList(levels.map(value => ({ value, label: value })), levels.length, listTheme(theme));
+    list.setSelectedIndex(Math.max(0, levels.indexOf(current.thinking)));
+    list.onCancel = () => this.pickModel();
+    list.onSelect = item => {
+      const thinking = levels.find(level => level === item.value);
+      const slash = model.indexOf('/');
+      const problem = thinking && this.submit({ provider: model.slice(0, slash), model: model.slice(slash + 1), thinking });
+      if (problem) error.setText(theme.fg('error', problem));
+    };
+    this.show(step(theme, 'Thinking level', `For ${model}.`, list, 'Enter to save · Esc to go back', [error]), data => list.handleInput(data));
+  }
+  private show(box: Component, input: (data: string) => void) { this.clear(); this.addChild(box); this.active = { handleInput: input }; }
+  handleInput(data: string) { this.active.handleInput(data); }
+}
+
+/** The page itself: Pi's settings list over this profile's config, one row per setting, saved on change. */
+export function settingsPage(theme: Theme, o: Options, close: () => void, redraw = () => {}) {
+  const { config } = o;
+  const notice = new Text('', 2, 0);
+  const marker = (same: boolean, fallback: string) => theme.fg('dim', same ? '  default' : `  default ${fallback}`);
+  const value = (key: SettingKey, current: number | boolean) => `${show(key, current)}${marker(current === SETTINGS[key].default, show(key, SETTINGS[key].default))}`;
+  const apply = (patch: Partial<ProfileConfig>, what: string, applies: string) => {
+    try { o.save({ ...config, ...patch }); }
+    catch (error) { return `Could not save: ${error instanceof Error ? error.message : String(error)}`; }
+    Object.assign(config, patch);
+    notice.setText(theme.fg('success', `Saved ${what}. `) + theme.fg('muted', applies));
+    return undefined;
+  };
+  const models = (['compactor', 'subagent'] as const).map((role): SettingItem => {
+    const { label, description, applies } = ROLES[role];
+    return { id: role, label, description: `${description} Default ${showModel(defaults[role])}. ${applies}`,
+      currentValue: modelValue(theme, role, config[role]),
+      submenu: (_value, done) => new ModelStep(theme, role, o.models, config[role], choice => {
+        const problem = apply({ [role]: choice }, `${label.toLowerCase()} ${showModel(choice)}`, applies);
+        if (!problem) done(modelValue(theme, role, choice));
+        return problem;
+      }, () => done()),
+    };
+  });
+  const settings = SETTING_KEYS.map((key): SettingItem => {
+    const spec = SETTINGS[key], base = { id: key, label: spec.label, description: `${spec.description} ${spec.applies}` };
+    if (isNumberKey(key)) return { ...base, currentValue: value(key, config[key]),
+      submenu: (_value, done) => new NumberStep(theme, key, config[key], next => {
+        const problem = apply({ [key]: next }, `${spec.label.toLowerCase()} ${show(key, next)}`, spec.applies);
+        if (!problem) done(value(key, next));
+        return problem;
+      }, () => done()) };
+    return { ...base, currentValue: value(key, config[key]), values: [value(key, true), value(key, false)] };
+  });
+  const list = new SettingsList([...models, ...settings], 10, {
+    label: (text, selected) => selected ? theme.fg('accent', text) : text,
+    value: (text, selected) => selected ? theme.fg('accent', text) : theme.fg('muted', text),
+    description: text => theme.fg('dim', text), cursor: theme.fg('accent', '→ '), hint: text => theme.fg('dim', text),
+  }, (id, next) => {
+    // Only the on/off rows change here; the others save from their own step.
+    const key = SETTING_KEYS.find(k => k === id);
+    if (!key || isNumberKey(key)) return;
+    const on = next === value(key, true);
+    const problem = apply({ [key]: on }, `${SETTINGS[key].label.toLowerCase()} ${on ? 'on' : 'off'}`, SETTINGS[key].applies);
+    if (problem) { list.updateValue(key, value(key, config[key])); notice.setText(theme.fg('error', problem)); }
+  }, close);
+  const page = new Container();
+  for (const child of [new DynamicBorder(s => theme.fg('border', s)), new Text(`${theme.bold(theme.fg('accent', 'OptChat settings'))}${theme.fg('muted', ` · ${o.profile}`)}`, 1, 0),
+    new Text(theme.fg('dim', 'Saved as you change them · Victor\'s recipe by default, except Previous exchange and Summary size tolerance'), 1, 0),
+    new Spacer(1), list, notice, new DynamicBorder(s => theme.fg('border', s))]) page.addChild(child);
+  return Object.assign(page, { handleInput: (data: string) => { notice.setText(''); list.handleInput(data); redraw(); } });
+}
+
+export function showSettings(ctx: ExtensionContext, o: Options) {
+  return ctx.ui.custom<void>((tui, theme, _keys, done) => settingsPage(theme, o, () => done(undefined), () => tui.requestRender()));
+}

package/src/settings.ts

@@ -0,0 +1,48 @@
+import { NODE } from './memory.ts';
+
+/** Per-profile choices where OptChat departs from Victor's recipe. Each default is the recipe's behaviour unless noted. */
+export const SETTINGS = {
+  subagentLevels: { kind: 'number', label: 'Subagent levels', default: 1, min: 1, unit: '',
+    description: 'How many levels of subagents. 1: only the main agent starts subagents, as in Victor\'s recipe. 2: those subagents may start their own, and so on.',
+    applies: 'Applies to subagents started or resumed after this.' },
+  maxAgents: { kind: 'number', label: 'Max active agents', default: 8, min: 1, unit: '',
+    description: 'Subagents running at once in this profile, all levels together. It also caps how deep a chain can go.',
+    applies: 'Applies to the next spawn.' },
+  groupReports: { kind: 'toggle', label: 'Group subagent reports', default: true,
+    description: 'On: the subagents started by one spawn report together, in one message once the last of them finishes, as in Victor\'s recipe. Off: each subagent reports as soon as it finishes.',
+    applies: 'Applies to the next spawn.' },
+  previousExchange: { kind: 'toggle', label: 'Previous exchange', default: true,
+    description: 'Send your last request and its answer in full with the next turn, so a follow-up reads the exact wording. Off: memory view only, as in Victor\'s recipe. On by default: a study found it costs little and saves zooms.',
+    applies: 'Applies from the next turn.' },
+  previousExchangeKB: { kind: 'number', label: 'Previous exchange limit', default: 16, min: 1, unit: 'KB',
+    description: 'A larger last exchange, usually a big paste, is left out and the model zooms into memory instead.',
+    applies: 'Applies from the next turn.' },
+  memorySearch: { kind: 'toggle', label: 'Memory search', default: false,
+    description: 'Give agents a search tool that finds original messages by plain text, newest first, for exact names, numbers, paths or errors the view doesn\'t show. Off: zoom and date only, as in Victor\'s recipe. Turning it on or off makes the next turn re-cache its prompt once.',
+    applies: 'Applies from the next turn, and to subagents started or resumed after this.' },
+  summaryAcceptBytes: { kind: 'number', label: 'Summary size tolerance', default: NODE * 1.25, min: NODE, unit: 'bytes',
+    description: `The compactor is always asked for ${NODE}-byte lines; a longer line up to this size is kept instead of retried. ${NODE}: strict, as in Victor's recipe. The default saves retries for a little more view space.`,
+    applies: 'Applies to the next summary.' },
+} as const;
+
+export type SettingKey = keyof typeof SETTINGS;
+export type Settings = { -readonly [K in SettingKey]: (typeof SETTINGS)[K]['default'] extends boolean ? boolean : number };
+export type NumberKey = { [K in SettingKey]: Settings[K] extends number ? K : never }[SettingKey];
+export const SETTING_KEYS = Object.keys(SETTINGS) as SettingKey[];
+export const isNumberKey = (key: SettingKey): key is NumberKey => SETTINGS[key].kind === 'number';
+
+/** Why a value can't be used, or undefined if it can. Numbers are whole and at least their minimum. */
+export function invalid(key: SettingKey, value: unknown) {
+  if (isNumberKey(key)) { const { label, min } = SETTINGS[key]; return Number.isSafeInteger(value) && Number(value) >= min ? undefined : `${label} must be a whole number of ${min} or more.`; }
+  return typeof value === 'boolean' ? undefined : `${SETTINGS[key].label} must be true or false.`;
+}
+
+/** Missing keys take their defaults, so config files written before a setting existed keep working. */
+export function readSettings(value: Record<string, unknown>): Settings {
+  return Object.fromEntries(SETTING_KEYS.map(key => {
+    const raw = Object.hasOwn(value, key) ? value[key] : SETTINGS[key].default, problem = invalid(key, raw);
+    if (problem) throw new Error(problem);
+    return [key, raw];
+  })) as Settings;
+}
+export const DEFAULT_SETTINGS = readSettings({});

package/src/tools.ts

@@ -1,6 +1,28 @@
 import { Type } from 'typebox';
-import type { Memory } from './memory.ts';
+import { flat, start, type Memory } from './memory.ts';
 export const result = (text: string) => ({ content: [{ type: 'text' as const, text }], details: {} });
+export const SEARCH_PAGE = 20;
+const SNIPPET = 200;
+/** Added after the view doc when Memory search is on. */
+export const SEARCH_DOC = '\n\nsearch(text) finds the original messages that contain text, newest first. Use it for an exact name, number, PR, path or error the view doesn\'t show, then zoom(id, 1) to read a hit. A hit is one message: zoom around it too, especially the messages after it, where the outcome usually is.';
+
+/** One page of hits, each with its id, the view line holding it, its date and a snippet around the first match; at most ~5 KB. */
+export function searchPage(memory: Memory, text: string, before?: number) {
+  const hits = memory.search(text, before), older = before === undefined ? '' : 'older ';
+  if (!hits.length) return `No ${older}messages contain "${text}".`;
+  const page = hits.slice(0, SEARCH_PAGE), needle = text.toLowerCase();
+  const lines = page.map(entry => {
+    // Cut the original text, whose match may span lines, and flatten only the cut.
+    const at = Math.max(0, entry.text.toLowerCase().indexOf(needle) - SNIPPET / 4);
+    const snippet = flat(entry.text.slice(at, at + SNIPPET).replace(/^[\udc00-\udfff]|[\ud800-\udbff]$/g, ''));
+    // The live view, which may have folded since the turn's snapshot: its lines are built, so zoom always opens them.
+    const line = memory.covering(entry.i); // Named only when the hit is inside a summary line.
+    return `${entry.i}${line?.l ? ` (in ${start(line)}+${2 ** line.l})` : ''} · ${new Date(entry.date).toString().slice(0, 21)} · ${entry.kind}: ${at ? '…' : ''}${snippet}${at + SNIPPET < entry.text.length ? '…' : ''}`;
+  });
+  const more = hits.length > page.length ? `\nOlder matches: search again with before: ${page[page.length - 1].i}.` : '';
+  return `${hits.length} ${older}${hits.length === 1 ? 'message contains' : 'messages contain'} "${text}", newest first:\n${lines.join('\n')}${more}`;
+}
+
 export function memoryTools(memory: () => Memory) {
   return [
     { name: 'zoom', label: 'Zoom memory', description: 'Open the line id+n of the view into the two lines of n/2 under it; n = 1 gives the message whole.',
@@ -11,3 +33,8 @@ export function memoryTools(memory: () => Memory) {
       async execute(_id: string, args: { id: number }) { return result(memory().date(args.id)); } },
   ];
 }
+
+export const searchTool = (memory: () => Memory) => ({ name: 'search', label: 'Search memory',
+  description: `Find the original messages that contain text (plain text, any case), newest first, ${SEARCH_PAGE} at a time; before: id continues with older ones. zoom(id, 1) gives a hit whole.`,
+  parameters: Type.Object({ text: Type.String({ minLength: 1 }), before: Type.Optional(Type.Integer({ minimum: 0 })) }),
+  async execute(_id: string, args: { text: string; before?: number }) { return result(searchPage(memory(), args.text, args.before)); } });

package/src/transcript.ts

@@ -1,8 +1,9 @@
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
 import { getCurrentSystemMessage, type SystemMessage, type UserMessage } from '@earendil-works/pi-ai';
-import { cap, type Memory } from './memory.ts';
+import { CAP, cap, type Memory } from './memory.ts';
 import { record } from './cache.ts';
+import { DEFAULT_SETTINGS } from './settings.ts';
 
 export const RUN_BOUNDARY = 'optchat.run';
 /** Subagent traffic to the main agent: a custom message on screen, a plain user message to the model and memory. */
@@ -44,7 +45,7 @@ export function logMessage(memory: Memory, message: AgentMessage, receipt?: stri
 export function boundedMessage(message: AgentMessage): AgentMessage {
   if (message.role !== 'toolResult') return message;
   const text = message.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
-  if (text.length <= 30_000) return message;
+  if (text.length <= CAP) return message;
   return { ...message, content: [{ type: 'text', text: cap(text) }, ...message.content.filter(c => c.type === 'image')] };
 }
 /** The caller supplies a single settled run, including any steering after text-only replies. */
@@ -63,8 +64,18 @@ function completedExchange(history: readonly AgentMessage[]) {
   return [...requests, { ...answer, content }];
 }
 
-/** Recover the latest successful run on this branch, skipping failed and unfinished runs. */
-export function previousExchange(branch: readonly SessionEntry[]) {
+/** Default limit in bytes of text (16 KB, ~4,000 tokens). Most exchanges are 1-7 KB; a larger one, usually a big paste, is
+ * left out entirely and the model falls back to its summaries in the memory view, zooming for the full text if it needs it. */
+export const PREVIOUS_EXCHANGE = DEFAULT_SETTINGS.previousExchangeKB * 1000;
+
+/** The latest successful run on this branch, skipping failed and unfinished runs; none if it is over `limit` bytes. */
+export function previousExchange(branch: readonly SessionEntry[], limit = PREVIOUS_EXCHANGE) {
+  const exchange = latestExchange(branch);
+  const bytes = exchange.reduce((sum, message) => sum + Buffer.byteLength(textContent(message.content)), 0);
+  return bytes <= limit ? exchange : [];
+}
+
+function latestExchange(branch: readonly SessionEntry[]) {
   let end = -1;
   let legacyEnd = branch.length;
   const messages = (entries: readonly SessionEntry[]) => entries.flatMap(entry => entry.type === 'message' ? [asUser(entry.message)] : entry.type === 'custom_message' && entry.customType === REPORT_TYPE ? [asUser({ role: 'custom', customType: entry.customType, content: entry.content, display: entry.display, timestamp: Date.parse(entry.timestamp) })] : []);

package/src/usage.ts

@@ -36,27 +36,27 @@ export function addUsage(total: Usage, usage: Usage) {
 /** One profile's ledger. Stable message IDs make resume/backfill idempotent. */
 export class UsageLedger {
   readonly entries: UsageEntry[] = [];
-  readonly warnings: string[] = [];
+  private invalid = 0;
   private readonly ids = new Set<string>();
   private readonly cursors = new Map<string, number>();
   private readonly file: string;
   constructor(directory: string) {
     this.file = join(directory, 'usage.jsonl');
-    let invalid = 0;
     const contents = existsSync(this.file) ? readFileSync(this.file, 'utf8') : '';
     for (const line of contents.split('\n')) {
       if (!line.trim()) continue;
       try {
         const entry: unknown = JSON.parse(line);
-        if (!validEntry(entry)) { invalid++; continue; }
+        if (!validEntry(entry)) { this.invalid++; continue; }
         if (entry.id && this.ids.has(entry.id)) continue;
         this.entries.push(entry); if (entry.id) this.ids.add(entry.id);
-      } catch { invalid++; }
+      } catch { this.invalid++; }
     }
-    if (invalid) this.warnings.push(`${invalid} unreadable usage records excluded; totals may be incomplete.`);
     if (contents && !contents.endsWith('\n')) appendFileSync(this.file, '\n');
   }
+  get warnings() { return this.invalid ? [`${this.invalid} unreadable usage records excluded; totals may be incomplete.`] : []; }
   add(entry: UsageEntry) {
+    if (!validEntry(entry)) { this.invalid++; return; }
     if (entry.id && this.ids.has(entry.id)) return;
     appendJson(this.file, entry);
     this.entries.push(entry); if (entry.id) this.ids.add(entry.id);
@@ -86,7 +86,7 @@ export class UsageLedger {
   select(range: UsageRange, session: string, now = Date.now()) {
     const today = new Date(now); today.setHours(0, 0, 0, 0);
     const since = range === 'Last hour' ? now - 3600_000 : range === 'Today' ? today.getTime() : range === 'Last 7 days' ? now - 7 * 86400_000 : 0;
-    return this.entries.filter(e => range === 'This session' ? e.session === session : Date.parse(e.date) >= since && Date.parse(e.date) <= now);
+    return this.entries.filter(e => range === 'This session' ? e.session === session : range === 'All time' || (Date.parse(e.date) >= since && Date.parse(e.date) <= now));
   }
 }
 

package/src/window-bridge.ts

@@ -1,9 +1,9 @@
-import { chmodSync, existsSync, unlinkSync } from 'node:fs';
+import { chmodSync } from 'node:fs';
 import { createConnection, createServer, type Socket } from 'node:net';
 import type { Children } from './agents.ts';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { record } from './cache.ts';
-import { profileSocket } from './profiles.ts';
+import { checkSocketPath, profileSocket, removeStaleSocket } from './profiles.ts';
 import { textContent } from './transcript.ts';
 import { isActiveRun } from './runs.ts';
 
@@ -83,8 +83,8 @@ function wire(socket: Socket, receive: (frame: Frame) => void) {
 /** Call only while holding the profile lock. The owner hosts every child session. */
 export async function serveWindows(directory: string, children: Children, available: () => boolean,
   report: (text: string) => Promise<void>) {
-  const path = profileSocket(directory, 'windows');
-  if (existsSync(path)) unlinkSync(path); // A previous owner can no longer hold the profile lock.
+  const path = profileSocket(directory, 'windows'); checkSocketPath(path);
+  removeStaleSocket(path); // A previous owner can no longer hold the profile lock.
   const connections = new Set<Socket>();
   const work = new Set<Promise<void>>();
   let closing = false;