pi-optchat 0.8.2 → 0.8.3

package/package.json

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

package/src/agents.ts

@@ -314,7 +314,10 @@ export class Children {
             // Nothing to hand over: the run waits for its next message instead of ending, and whoever waits on its report hears why.
             if (transition(info, 'paused')) {
               this.save(info);
-              if (!info.connected) await this.toParent(info.parentId, `[${info.id}] Interrupted by the user; it waits for their next message, so no report until then.`)
+              // In a grouped spawn the note takes the run's place, so its siblings' reports are not held until the user comes back; its later report arrives on its own.
+              const note = `[${info.id}] Interrupted by the user; it waits for their next message, so no report until then.`, batch = live.batch;
+              live.batch = undefined;
+              if (!info.connected) await (batch ? this.deliver(info, batch, note) : this.toParent(info.parentId, note))
                 .catch(error => this.warn(`Could not tell the parent about the interrupt: ${String(error)}`));
             }
             continue;
@@ -331,7 +334,8 @@ export class Children {
           continue;
         }
         const last = session.messages.findLast(m => m.role === 'assistant');
-        if (!paused && last?.role === 'assistant' && (last.stopReason === 'error' || last.stopReason === 'aborted')) break;
+        // An error ends the turn, not the run: children still at work report to it and it answers them, as the main agent does.
+        if (!paused && last?.role === 'assistant' && (last.stopReason === 'error' || last.stopReason === 'aborted') && !live.pendingReports.length && !this.directChildren(info.id).length) break;
         if (live.pendingGuidance.length) {
           transition(info, 'running'); this.save(info);
           await session.prompt(live.pendingGuidance.shift()!);
@@ -384,8 +388,10 @@ export class Children {
     // A metadata failure must not suppress delivery of the actual result.
     try { this.save(info); } catch (error) { this.warn(`Could not save run metadata: ${String(error)}`); }
     // A deleted run's transcript is gone.
-    let text = `[${info.id}] ${info.report}${this.deleting.has(info.id) ? '' : `\n\n${fullChat(info.id)}`}`;
-    const batch = live.batch;
+    await this.deliver(info, live.batch, `[${info.id}] ${info.report}${this.deleting.has(info.id) ? '' : `\n\n${fullChat(info.id)}`}`);
+  }
+  /** Sends a run's report to its parent; in a grouped spawn, only once every child of the spawn has one. */
+  private async deliver(info: RunInfo, batch: LiveRun['batch'], text: string) {
     let count: number | undefined;
     if (batch) {
       batch.reports.set(info.id, text);
@@ -395,7 +401,7 @@ export class Children {
     }
     if (info.parentId) {
       const parent = this.running.get(info.parentId);
-      if (parent && parent.info.state !== 'stopping') { parent.pendingReports.push(text); this.changed(); }
+      if (parent && parent.info.state !== 'stopping') { parent.pendingReports.push(text); parent.wake?.(); this.changed(); }
       return;
     }
     if (this.closing) this.memory.append('work', text);
@@ -548,7 +554,8 @@ export class Children {
     }
     if (orphans.length) lines.push(`Also cut off, but not resumed because their parent agent is not running: ${orphans.join(', ')}.`);
     if (!resumed.length && !lines.length) return;
-    await this.report([`Pi restarted while subagents were working.${resumed.length ? ` Resumed ${resumed.join(', ')} from where ${resumed.length > 1 ? 'they' : 'it'} left off; reports arrive as usual.` : ''}`, ...lines].join('\n'));
+    await this.report([`Pi restarted while subagents were working.${resumed.length ? ` Resumed ${resumed.join(', ')} from where ${resumed.length > 1 ? 'they' : 'it'} left off; ${this.settings.groupReports
+      ? 'grouped reports do not survive a restart, so each one reports on its own.' : 'reports arrive as usual.'}` : ''}`, ...lines].join('\n'));
   }
   async finish(id: string, reason: FinishReason) {
     const live = this.running.get(id);

package/src/compactor.ts

@@ -51,7 +51,8 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
     if (!model) throw new Error(`Compactor model unavailable: ${selected.provider}/${selected.model}. Use /optchat model.`);
     const thinking = reasoningFor(model, selected.thinking);
     const step = `${input.historical ? IMPORT_GUIDANCE + '\n\n' : ''}${compaction(input)}`;
-    const messages: Message[] = [{ role: 'user', content: [{ type: 'text', text: input.context }, { type: 'text', text: step }], timestamp: Date.now() }];
+    // OpenAI joins text blocks with nothing between them, so the task starts its own paragraph after the view.
+    const messages: Message[] = [{ role: 'user', content: [{ type: 'text', text: input.context }, { type: 'text', text: `\n\n${step}` }], timestamp: Date.now() }];
     const view = splitView(input.context);
     const prefix = model.api === 'anthropic-messages' && view.length > 1 ? `${model.provider}/${model.id}/${thinking ?? 'off'}\n${view.slice(0, -1).join('')}` : undefined;
     const tries: string[] = [];
@@ -71,6 +72,8 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
       } finally { warmed(false); }
       onUsage(reply);
       if (reply.stopReason === 'error' || reply.stopReason === 'aborted') throw new Error(reply.errorMessage ?? `Compactor ${reply.stopReason}`);
+      // A reply cut off at the token limit, or one that calls a tool, is no summary: ask again.
+      if (reply.stopReason === 'length' || reply.content.some(c => c.type === 'toolCall')) continue;
       // The compactions' view shows each line under its id+n| head, which a line can copy.
       const line = reply.content.filter(c => c.type === 'text').map(c => c.text).join('').trim().replace(/^\d+\+\d+\|\s*/, '');
       if (!line) throw new Error('Compactor returned no text.');
@@ -81,6 +84,7 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
       const cut = Buffer.from(line).subarray(0, NODE).toString('utf8').replace(/\uFFFD$/, '');
       messages.push({ role: 'user', content: tooLong(bytes(line), cut), timestamp: Date.now() });
     }
+    if (!tries.length) throw new Error('Compactor returned no whole line in 5 tries.');
     return tries.reduce((a, b) => bytes(a) <= bytes(b) ? a : b);
   };
 }

package/src/index.ts

@@ -31,6 +31,7 @@ import { openConnectedWindow, registerConnectedRenderer } from './connected-wind
 import { createHandoffSummarizer } from './handoff.ts';
 import { mainTitle, TabTitle } from './title.ts';
 import { showModelPicker, showSettings } from './settings-page.ts';
+import { showMenu } from './menu.ts';
 
 const binding = 'optchat.profile';
 const CONNECT_MODES = ['auto', 'join', 'off'] as const;
@@ -48,6 +49,15 @@ const promptFor = (prompt: string, { previousExchange, memorySearch }: ProfileCo
   allowSearch(toggle(toggle(prompt, CONTINUITY, previousExchange, VIEW_DOC), SEARCH_DOC, memorySearch, previousExchange ? VIEW_DOC + CONTINUITY : VIEW_DOC), memorySearch);
 interface Active { name: string; dir: string; config: ProfileConfig; memory: Memory; inbox: Inbox; children: Children; usage: UsageLedger; unlock: () => Promise<void> }
 
+/** OptChat's own version, read from the package.json beside src/ (in the checkout and the npm package alike); none if unreadable. */
+export const version = ((): string | undefined => {
+  try {
+    const data: unknown = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    return data && typeof data === 'object' && 'version' in data && typeof data.version === 'string' ? data.version : undefined;
+  } catch { return undefined; }
+})();
+const brand = version ? `OptChat v${version}` : 'OptChat';
+
 export default function optchat(pi: ExtensionAPI) {
   let active: Active | undefined;
   let remote: Awaited<ReturnType<typeof openConnectedWindow>> | undefined;
@@ -209,7 +219,7 @@ export default function optchat(pi: ExtensionAPI) {
       closeWindows = await serveWindows(dir, children, () => !stopping && !importing && !pendingImport(dir), deliverReport);
       untitle = children.subscribe(() => showTitle(ctx)); showTitle(ctx);
       status(ctx);
-      ctx.ui.notify(`OptChat · ${name} · ${memory.root.length} messages\nCompactor: ${config.compactor.provider}/${config.compactor.model} (${config.compactor.thinking})`, 'info');
+      ctx.ui.notify(`${brand} · ${name} · ${memory.root.length} messages\nCompactor: ${config.compactor.provider}/${config.compactor.model} (${config.compactor.thinking})`, 'info');
       const queuedReports = [...reports];
       if (!pendingImport(dir)) {
         const recover = (work: Promise<void>, what: string) => work.catch(error => ctx.ui.notify(`${what}: ${errorText(error)}`, 'error'));
@@ -474,8 +484,8 @@ export default function optchat(pi: ExtensionAPI) {
     let action = args.trim();
     if (!action) {
       const a = active;
-      const info = a ? `${a.name} · ${a.memory.root.length} messages · ${a.memory.pending} pending\nCompactor: ${a.config.compactor.model} (${a.config.compactor.thinking})\nAgents: ${a.config.subagent.model} (${a.config.subagent.thinking})\n${a.memory.lastError ?? ''}` : 'No active profile';
-      action = await ctx.ui.select(`OptChat\n${info}`, ['profile', 'settings', 'model', 'agents', 'usage', 'activity', 'instructions', 'browse', 'import']) ?? '';
+      action = await showMenu(ctx, brand, a && { profile: a.name, messages: a.memory.root.length, pending: a.memory.pending,
+        compactor: a.config.compactor, agents: a.config.subagent, error: a.memory.lastError }) ?? '';
     }
     if (action === 'import') {
       const a = required();

package/src/memory.ts

@@ -334,7 +334,7 @@ export class Memory {
     if (n === 1) {
       const { kind, text } = this.root[id], page = Math.min(limit ?? PAGE, PAGE);
       if (!Number.isSafeInteger(page) || page < 1) throw new Error('limit must be a positive integer.');
-      if (offset === undefined && text.length <= page) return `${id}+0|${kind}: ${text}`;
+      if (offset === undefined && text.length <= page) return `${id}+1|${kind}: ${text}`;
       if (offset !== undefined && (!Number.isSafeInteger(offset) || offset < 0 || offset >= Math.max(1, text.length)))
         throw new Error(`Message ${id} has ${text.length} characters; offset must be 0 to ${Math.max(0, text.length - 1)}.`);
       // Never split a surrogate pair: a page starts on its first half and ends after its second.
@@ -343,7 +343,7 @@ export class Memory {
       // A one-unit page on a pair takes the whole pair, so the next offset always moves forward.
       if (to < text.length && /[\ud800-\udbff]/.test(text[to - 1])) to += to - 1 === from ? 1 : -1;
       const hint = text.length <= PAGE ? `\n[note: this message is only ${text.length.toLocaleString('en-US')} characters and fits in one zoom; offset/limit are for messages over ${PAGE.toLocaleString('en-US')}]` : '';
-      return `${id}+0|${kind}: ${text.slice(from, to)}\n[showing characters ${from}-${to} of ${text.length}${to < text.length ? `; next page: offset ${to}` : ''}]${hint}`;
+      return `${id}+1|${kind}: ${text.slice(from, to)}\n[showing characters ${from}-${to} of ${text.length}${to < text.length ? `; next page: offset ${to}` : ''}]${hint}`;
     }
     if (offset !== undefined) throw new Error('offset and limit page one message: use them with n = 1.');
     const l = Math.log2(n) - 1, i = 2 * id / n;

package/src/menu.ts

@@ -0,0 +1,61 @@
+import { Box, SelectList, Spacer, Text } from '@earendil-works/pi-tui';
+import type { ExtensionContext, Theme } from '@earendil-works/pi-coding-agent';
+import type { ModelChoice } from './compactor.ts';
+import { count, oneLine } from './inspector.ts';
+import { frame, showModel } from './settings-page.ts';
+
+/** What `/optchat` offers, in menu order; each is also `/optchat <action>`. */
+export const ACTIONS = ['profile', 'settings', 'model', 'agents', 'usage', 'activity', 'instructions', 'browse', 'import'] as const;
+export type MenuAction = typeof ACTIONS[number];
+const DESCRIPTIONS: Record<MenuAction, string> = {
+  profile: 'Switch or create a profile',
+  settings: 'Models, subagent limits, memory options',
+  model: 'Compactor model and effort',
+  agents: 'Live agent tree and saved runs',
+  usage: 'Token usage and cost estimates',
+  activity: 'Memory gauge and running agents',
+  instructions: 'Edit this profile\'s AGENTS.md',
+  browse: 'Open a readable snapshot of memory',
+  import: 'Import history, or resume a paused import',
+};
+
+export interface MenuStatus { profile: string; messages: number; pending: number; compactor: ModelChoice; agents: ModelChoice; error?: string }
+/** The status block as label and value; the plain menu outside the TUI shows the same rows. */
+export const statusRows = (s: MenuStatus) => [
+  ['Memory', `${count(s.messages)} messages · ${count(s.pending)} pending`],
+  // config.json only checks these are strings, so one with a newline or escape code must not break the block.
+  ['Compactor', oneLine(showModel(s.compactor))],
+  ['Agents', oneLine(showModel(s.agents))],
+] as const;
+const failing = (error: string) => `Summaries failing: ${oneLine(error)}`;
+
+/** Framed like the settings page: title, the profile's status as aligned rows, then the actions with what each opens. */
+export function optchatMenu(theme: Theme, title: string, status: MenuStatus | undefined, close: (action?: MenuAction) => void, redraw = () => {}) {
+  const list = new SelectList(ACTIONS.map(value => ({ value, label: value, description: DESCRIPTIONS[value] })), ACTIONS.length, {
+    selectedPrefix: t => theme.fg('accent', t), selectedText: t => theme.fg('accent', t),
+    description: t => theme.fg('muted', t), scrollInfo: t => theme.fg('muted', t), noMatch: t => theme.fg('muted', t) },
+    { minPrimaryColumnWidth: 1, maxPrimaryColumnWidth: Math.max(...ACTIONS.map(a => a.length)) + 4 });
+  list.onSelect = item => close(ACTIONS.find(a => a === item.value));
+  list.onCancel = () => close();
+  const rows = status ? statusRows(status) : [];
+  const labels = Math.max(0, ...rows.map(([label]) => label.length));
+  const facts = status ? rows.map(([label, value]) => new Text(`${theme.fg('muted', label.padEnd(labels))}  ${value}`, 1, 0)) : [new Text(theme.fg('muted', 'No active profile'), 1, 0)];
+  if (status?.error) facts.push(new Text(theme.fg('warning', failing(status.error)), 1, 0));
+  const actions = new Box(1, 0); actions.addChild(list);
+  const page = frame(theme, title, status?.profile, [new Spacer(1), ...facts, new Spacer(1), actions, new Spacer(1),
+    new Text(theme.fg('dim', '↑↓ select · Enter open · Esc close'), 1, 0)]);
+  return Object.assign(page, { handleInput: (data: string) => {
+    // j and k move too, as in Pi's own select dialog that this menu replaces.
+    const step = data === 'j' ? 1 : data === 'k' ? -1 : 0, at = ACTIONS.findIndex(a => a === list.getSelectedItem()?.value);
+    if (step) list.setSelectedIndex(Math.max(0, Math.min(ACTIONS.length - 1, at + step)));
+    else list.handleInput(data);
+    redraw();
+  } });
+}
+
+/** The menu in interactive Pi; elsewhere (RPC hosts) Pi's plain select with the same facts and actions. */
+export function showMenu(ctx: ExtensionContext, title: string, status: MenuStatus | undefined): Promise<MenuAction | undefined> {
+  if (ctx.mode === 'tui') return ctx.ui.custom<MenuAction | undefined>((tui, theme, _keys, done) => optchatMenu(theme, title, status, done, () => tui.requestRender()));
+  const facts = status ? [status.profile, ...statusRows(status).map(([label, value]) => `${label}: ${value}`), ...status.error ? [failing(status.error)] : []] : ['No active profile'];
+  return ctx.ui.select([title, ...facts].join('\n'), [...ACTIONS]).then(choice => ACTIONS.find(a => a === choice));
+}

package/src/settings-page.ts

@@ -11,7 +11,7 @@ const ROLES: Record<Role, { label: string; description: string; applies: string
   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}`;
+export 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}`)}`;
@@ -114,9 +114,9 @@ function update(o: Options, patch: Partial<ProfileConfig>) {
   return undefined;
 }
 /** Bordered, titled like Pi's own dialogs. */
-function frame(theme: Theme, title: string, profile: string, body: Component[]) {
+export function frame(theme: Theme, title: string, profile: string | undefined, body: Component[]) {
   const page = new Container();
-  for (const child of [new DynamicBorder(s => theme.fg('border', s)), new Text(`${theme.bold(theme.fg('accent', title))}${theme.fg('muted', ` · ${profile}`)}`, 1, 0),
+  for (const child of [new DynamicBorder(s => theme.fg('border', s)), new Text(`${theme.bold(theme.fg('accent', title))}${profile ? theme.fg('muted', ` · ${profile}`) : ''}`, 1, 0),
     ...body, new DynamicBorder(s => theme.fg('border', s))]) page.addChild(child);
   return page;
 }

package/src/store.ts

@@ -1,4 +1,4 @@
-import { closeSync, existsSync, fstatSync, fsyncSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, writeFileSync, writeSync } from 'node:fs';
+import { closeSync, existsSync, fstatSync, fsyncSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, truncateSync, writeFileSync, writeSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import type { Entry, Summary } from './memory.ts';
 
@@ -61,7 +61,8 @@ export function atomicWrite(file: string, text: string | Uint8Array) {
   try { fsyncSync(parent); } finally { closeSync(parent); }
 }
 const otherWriter = (file: string) => new Error(`Another process wrote ${file}. Close every other Pi on this profile and restart Pi; nothing was written.`);
-/** With `size`, refuses to append unless the file still has that size. A last line left without its newline is ended first. Returns the new size. */
+/** With `size`, refuses to append unless the file still has that size. A last line left without its newline is ended first. A write
+ * cut short is truncated away before the error is thrown. Returns the new size. */
 export function appendJson(file: string, value: unknown, size?: number) {
   const fd = openSync(file, 'a+', 0o600);
   try {
@@ -69,7 +70,10 @@ export function appendJson(file: string, value: unknown, size?: number) {
     if (size !== undefined && length !== size) throw otherWriter(file);
     const torn = length > 0 && readSync(fd, last, 0, 1, length - 1) === 1 && last[0] !== 0x0a;
     const data = Buffer.from((torn ? '\n' : '') + JSON.stringify(value) + '\n');
-    if (writeSync(fd, data) !== data.length) throw new Error(`Incomplete write: ${file}`);
+    // A cut-short write is undone, so the file keeps the size the caller checks against. Windows refuses to truncate through an
+    // append handle, so this goes by path; if the undo fails too, the write's own error is still the one thrown.
+    try { if (writeSync(fd, data) !== data.length) throw new Error(`Incomplete write: ${file}`); }
+    catch (error) { try { truncateSync(file, length); } catch {} throw error; }
     fsyncSync(fd);
     return fstatSync(fd).size;
   } finally { closeSync(fd); }

package/src/transcript.ts

@@ -171,7 +171,9 @@ export function buildContext(canonical: AgentMessage[], run: AgentMessage[], vie
   const messages = [...previous, ...run].filter(m => m.role !== 'system').map(message => {
     if (message.role !== 'user' || injected) return message;
     injected = true;
-    return { ...message, content: [{ type: 'text' as const, text: view }, ...(typeof message.content === 'string' ? [{ type: 'text' as const, text: message.content }] : message.content)] };
+    // OpenAI joins text blocks with nothing between them, so the user's words start their own paragraph after the view.
+    const [first, ...rest] = typeof message.content === 'string' ? [{ type: 'text' as const, text: message.content }] : message.content;
+    return { ...message, content: [{ type: 'text' as const, text: view }, ...first?.type === 'text' ? [{ ...first, text: `\n\n${first.text}` }] : first ? [first] : [], ...rest] };
   });
   return [head, ...messages, ...status && messages.at(-1)?.role !== 'toolResult' ? [{ role: 'user' as const, content: [{ type: 'text' as const, text: status }], timestamp: 0 }] : []];
 }