pi-optchat 0.10.0 → 0.10.1

package/package.json

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

package/src/agents.ts

@@ -11,7 +11,7 @@ import { memoryTools, searchTool } from './tools.ts';
 import { VIEW, type Memory } from './memory.ts';
 import type { ModelChoice } from './compactor.ts';
 import { cachePayload } from './cache.ts';
-import { CUT_OFF, RunHistory, isRunning, transition, sessionMessages, savedSession, undelivered, type RunInfo, type RunState, type FinishReason } from './runs.ts';
+import { CUT_OFF, RunHistory, isRunning, transition, sessionMessages, savedSession, undelivered, sentText, type Guidance, type RunInfo, type RunState, type FinishReason } from './runs.ts';
 import { UsageLedger } from './usage.ts';
 import { fullChat, refreshFraction, textContent } from './transcript.ts';
 import { Type, type Static } from 'typebox';
@@ -23,9 +23,13 @@ import { THINKING } from './profiles.ts';
 export interface LiveRun {
   session: AgentSession; info: RunInfo; updated: number; streaming?: AgentMessage;
   tools: Map<string, { name: string; args: unknown; output?: unknown; started: number }>;
-  pendingReports: string[]; pendingGuidance: string[]; wake?: () => void; completion?: Promise<void>; primed?: Promise<unknown>;
+  pendingReports: string[]; pendingGuidance: Guidance[]; wake?: () => void; completion?: Promise<void>; primed?: Promise<unknown>;
   /** Set by the user's interrupt: the queued guidance the run continues with once its current step is aborted; with none, it pauses. */
-  interruption?: RunInfo['guidance'];
+  interruption?: Guidance[];
+  /** Guidance just handed to session.prompt(): the next user message is it, as Pi may rewrite the text (a /skill: line becomes the skill). */
+  prompting?: Guidance;
+  /** Every steer into Pi's queue, one at a time, so each knows which queued text is its own (see `steer`). */
+  steering: Promise<unknown>;
   /** Messages being steered back into Pi's queue after it was cleared; other queue changes wait for it. */
   requeueing?: Promise<void>;
   /** Shared by the children of one spawn whose reports are delivered together, in spawn order. */
@@ -210,8 +214,9 @@ export class Children {
       if (event.type === 'turn_end' || event.type === 'agent_settled') this.options.usage?.backfill(live.session.sessionManager.getEntries(), live.info.parentSession, 'subagent', live.info.id);
       if (event.type === 'message_start' && event.message.role === 'user') {
         const text = textContent(event.message.content);
-        const guidance = live.info.guidance.find(g => g.state === 'queued' && g.text === text);
-        if (guidance) { guidance.state = 'delivered'; this.save(live.info); }
+        const guidance = live.prompting ?? live.info.guidance.find(g => g.state === 'queued' && sentText(g) === text);
+        live.prompting = undefined;
+        if (guidance) { if (text !== guidance.text) guidance.sent = text; guidance.state = 'delivered'; this.save(live.info); }
       }
       if (event.type === 'tool_execution_start') live.tools.set(event.toolCallId, { name: event.toolName, args: event.args, started: Date.now() });
       if (event.type === 'tool_execution_update') {
@@ -288,7 +293,7 @@ export class Children {
           sessionManager: SessionManager.create(directory, join(this.profileDirectory, 'runs')) });
         const info: RunInfo = { id, task: task.task, cwd: directory, model: `${task.model.provider}/${task.model.id}`, thinking: session.thinkingLevel,
           parentSession: this.options.parentSession ?? '', parentId, depth, sessionFile: session.sessionFile, started: Date.now(), state: 'running', guidance: [], ...(connected ? { connected: true } : {}) };
-        const live: LiveRun = { session, info, updated: Date.now(), tools: new Map(), pendingReports: [], pendingGuidance: [] };
+        const live: LiveRun = { session, info, updated: Date.now(), tools: new Map(), pendingReports: [], pendingGuidance: [], steering: Promise.resolve() };
         launched.push(live); this.save(info); this.running.set(id, live);
         this.launching--; reserved--;
         session.subscribe(event => this.observe(live, event));
@@ -378,7 +383,7 @@ export class Children {
     if (!parentId) { await this.report(text); return true; }
     const parent = this.running.get(parentId);
     if (!parent || !['running', 'waiting', 'paused'].includes(parent.info.state)) return false;
-    if (parent.info.state === 'running') await parent.session.steer(text);
+    if (parent.info.state === 'running') await this.steer(parent, text);
     else { parent.pendingReports.push(text); parent.wake?.(); } // A paused parent keeps it until the user resumes it.
     this.changed();
     return true;
@@ -407,7 +412,7 @@ export class Children {
           // Read Pi's queue only once a rebuild has landed, and take the interrupt's messages off it so they arrive once.
           // Until this is done, tell() holds new messages in pendingGuidance, where the turn below or a pause picks them up.
           await live.requeueing;
-          const texts = new Set(guidance.map(g => g.text));
+          const texts = new Set(guidance.map(sentText));
           await this.requeue(live, session.clearQueue().steering.filter(text => !texts.has(text)));
           live.interruption = undefined;
           if (!guidance.length) {
@@ -425,7 +430,7 @@ export class Children {
           if (!transition(info, 'running')) continue; // A stop during the cleanup wins.
           for (const g of guidance) g.state = 'delivered';
           this.save(info);
-          await session.prompt(interruptedWith(guidance.map(g => g.text)));
+          await session.prompt(interruptedWith(guidance.map(sentText)));
           continue;
         }
         const paused = info.state === 'paused';
@@ -438,7 +443,9 @@ export class Children {
         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()!);
+          live.prompting = live.pendingGuidance.shift()!;
+          // An extension command sends no message at all, so this can't outlive the prompt and claim a later one.
+          try { await session.prompt(live.prompting.text); } finally { live.prompting = undefined; }
           continue;
         }
         if (live.pendingReports.length) {
@@ -474,7 +481,7 @@ export class Children {
           // Pi's queue must be empty before the handoff turn, or it would take a cancelled message as new input. Guidance in it is
           // already marked undelivered; the rest (a child's message) joins the reports the window never read.
           await live.requeueing;
-          const guidance = new Set(info.guidance.map(g => g.text));
+          const guidance = new Set(info.guidance.map(sentText));
           const unread = [...live.pendingReports.splice(0), ...session.clearQueue().steering.filter(text => !guidance.has(text))];
           if (unread.length) info.handoff.unread = unread;
           transition(info, info.handoff.reason === 'complete' ? 'completed' : 'interrupted');
@@ -539,12 +546,14 @@ export class Children {
     if (!live) throw new Error(`No running subagent ${id}.`);
     const text = live.info.connected && source === 'manager' ? `[Main agent guidance]\n${message.trim()}` : message.trim(); if (!message.trim()) throw new Error('Message is empty.');
     if (source === 'user') this.memory.append('user', `Direct guidance to subagent [${id}]: ${text}`);
-    const guidance: RunInfo['guidance'][number] = { text, date: Date.now(), state: 'queued', from: source };
+    const guidance: Guidance = { text, date: Date.now(), state: 'queued', from: source };
     live.info.guidance.push(guidance); this.save(live.info);
     try {
       await live.requeueing; // Keeps the queue in the order messages were sent.
-      if (live.info.state === 'running' && !live.interruption) await live.session.steer(text);
-      else { live.pendingGuidance.push(text); live.wake?.(); } // Waiting, paused or being interrupted: this message starts its next turn.
+      if (live.info.state === 'running' && !live.interruption) {
+        const sent = await this.steer(live, text);
+        if (sent !== undefined && sent !== text) guidance.sent = sent;
+      } else { live.pendingGuidance.push(guidance); live.wake?.(); } // Waiting, paused or being interrupted: this message starts its next turn.
     }
     catch (error) { guidance.state = 'undelivered'; this.save(live.info); throw error; }
     if (guidance.state === 'undelivered') throw new Error(`${id} finished before it read the message. Tell it again to resume it.`);
@@ -562,8 +571,8 @@ export class Children {
     // Nothing yields before the abort starts, so the run cannot finish in between and drop the messages.
     // They leave pendingGuidance and Pi's steering queue here, and execute() sends them in one prompt. Pi's queue must be empty
     // before the abort: after an aborted tool call Pi hands it to a request the abort cancels.
-    const texts = new Set(guidance.map(g => g.text));
-    live.pendingGuidance = live.pendingGuidance.filter(text => !texts.has(text));
+    live.pendingGuidance = live.pendingGuidance.filter(g => !guidance.includes(g));
+    const texts = new Set(guidance.map(sentText));
     // The rest of the queue (a child's tell_parent message) follows the interrupt's prompt, as reports to a paused run do.
     live.pendingReports.push(...live.session.clearQueue().steering.filter(text => !texts.has(text)));
     live.interruption = guidance;
@@ -578,11 +587,11 @@ export class Children {
     if (!live || text === undefined || live.requeueing || live.interruption) return undefined;
     // The queue holds only texts, so of equal ones the last is taken back, record and queue entry alike.
     const guidance = live.info.guidance.findLast(g => g.state === 'queued' && g.text === text)!;
-    const pending = live.pendingGuidance.lastIndexOf(guidance.text);
+    const pending = live.pendingGuidance.indexOf(guidance);
     if (pending >= 0) live.pendingGuidance.splice(pending, 1);
     else {
       const steering = live.session.getSteeringMessages();
-      const at = steering.lastIndexOf(guidance.text);
+      const at = steering.lastIndexOf(sentText(guidance));
       if (at < 0) return undefined; // Already on its way to the agent.
       // Pi cannot drop a single queued message: clear the queue and steer the rest back in order.
       void this.requeue(live, live.session.clearQueue().steering.filter((_, i) => i !== at));
@@ -590,9 +599,16 @@ export class Children {
     live.info.guidance.splice(live.info.guidance.indexOf(guidance), 1); this.save(live.info);
     return guidance.text;
   }
+  /** Pi's steer(), returning what Pi queued, which may differ from `text` (a /skill: line becomes the skill): that is what the agent receives. */
+  private steer(live: LiveRun, text: string) {
+    // One at a time, so the newest entry in Pi's queue is this one's.
+    const sent = live.steering.then(async () => await live.session.steer(text) === 'queued' ? live.session.getSteeringMessages().at(-1) : undefined);
+    live.steering = sent.catch(() => undefined);
+    return sent;
+  }
   private requeue(live: LiveRun, texts: string[]) {
     const work: Promise<void> = (async () => {
-      try { for (const text of texts) await live.session.steer(text); }
+      try { for (const text of texts) await this.steer(live, text); }
       catch (error) { this.warn(`Could not requeue a message for ${live.info.id}: ${String(error)}`); }
     })().finally(() => { if (live.requeueing === work) live.requeueing = undefined; });
     live.requeueing = work;
@@ -634,7 +650,7 @@ export class Children {
       const info: RunInfo = { ...rest, state: 'running', started: Date.now(), parentSession: this.options.parentSession ?? run.parentSession,
         guidance: [...run.guidance, { text: prompt, date: Date.now(), state: 'queued', from: 'manager' }] };
       try { this.save(info); } catch (error) { this.history.records.set(id, run); await this.shutdown(session); this.dispose(session); throw error; }
-      const live: LiveRun = { session, info, updated: Date.now(), tools: new Map(), pendingReports: [], pendingGuidance: [] };
+      const live: LiveRun = { session, info, updated: Date.now(), tools: new Map(), pendingReports: [], pendingGuidance: [], steering: Promise.resolve() };
       this.running.set(id, live);
       this.launching--; reserved = false;
       session.subscribe(event => this.observe(live, event));

package/src/runs.ts

@@ -20,9 +20,12 @@ export interface RunInfo {
   handoff?: { reason: FinishReason; text?: string; delivered?: boolean; unread?: string[] };
   /** Working when Pi closed or crashed: the next start resumes it (see `Children.resumeCutOff`). */
   cutOff?: boolean;
-  /** `from` is missing on runs saved before senders were recorded. */
-  guidance: { text: string; date: number; state: 'queued' | 'delivered' | 'undelivered'; from?: 'user' | 'manager' }[];
+  /** `from` is missing on runs saved before senders were recorded. `sent`: what Pi queued, when it rewrote `text` (a `/skill:` line becomes the skill itself). */
+  guidance: Guidance[];
 }
+export type Guidance = { text: string; date: number; state: 'queued' | 'delivered' | 'undelivered'; from?: 'user' | 'manager'; sent?: string };
+/** The text the agent receives, which is how Pi's queue and the session know the message. */
+export const sentText = (g: Guidance) => g.sent ?? g.text;
 const moves: Record<RunState, readonly RunState[]> = {
   running: ['waiting', 'paused', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'],
   waiting: ['running', 'paused', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'],
@@ -63,7 +66,7 @@ function isRun(value: unknown): value is RunInfo {
       && (value.handoff.unread === undefined || Array.isArray(value.handoff.unread) && value.handoff.unread.every(text => typeof text === 'string')))
     && 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'));
+    && 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') && (g.sent === undefined || typeof g.sent === 'string'));
 }
 export const CUT_OFF = 'Pi closed before this agent finished. Its partial transcript is retained.';
 export function sessionMessages(file: string): AgentMessage[] {

package/src/settings-page.ts

@@ -7,8 +7,8 @@ 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.' },
+  compactor: { label: 'Compactor model', description: 'Writes memory summaries, imports and fallback 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 new subagents.' },
 };
 const modelName = (choice: ModelChoice) => `${choice.provider}/${choice.model}`;
 export const showModel = (choice: ModelChoice) => `${modelName(choice)} · ${choice.thinking}`;

package/src/settings.ts

@@ -3,32 +3,32 @@ 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. 2: those subagents may start their own, and so on.',
-    applies: 'Applies to subagents started or resumed after this.' },
+    description: 'How deep subagents can nest. 1: only the main agent starts them.',
+    applies: 'Applies to new or resumed subagents.' },
   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.',
+    description: 'Subagents running at once, all levels together. Also caps chain depth.',
     applies: 'Applies to the next spawn.' },
   groupReports: { kind: 'toggle', label: 'Group subagent reports', default: false,
-    description: 'Off: each subagent reports as soon as it finishes, as in Victor\'s recipe. On: the subagents started by one spawn report together, in one message once the last of them finishes.',
+    description: 'On: subagents from one spawn report together, once the last finishes. Off: each reports when done (Victor\'s recipe).',
     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.',
+    description: 'Send your last request and its answer in full with the next turn, so follow-ups see the exact wording. Off: memory view only (Victor\'s recipe).',
     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.',
+    description: 'A larger exchange, usually a big paste, is left out; the model zooms 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.' },
+    description: 'Lets agents search original messages by plain text. Off: zoom and date only (Victor\'s recipe). Toggling re-caches the prompt once.',
+    applies: 'Applies from the next turn and to new or resumed subagents.' },
   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.`,
+    description: `Summary lines up to this size are kept instead of retried (the compactor aims for ${NODE}). ${NODE}: strict (Victor's recipe).`,
     applies: 'Applies to the next summary.' },
   jobs: { kind: 'number', label: 'Summaries at once', default: 8, min: 1, max: 64, unit: '',
-    description: 'Summaries built at once, by chat compaction and by an import. With N at once, a summary can see up to N−1 lines not summarized yet before it, so higher is faster but a little less accurate (at 8 that costs about 0.8 points per summary, #108). Higher also hits your provider\'s rate limits harder; the compactor retries what is refused. If your provider caps parallel requests, set it below that cap so the main turn has room.',
-    applies: 'Applies to the next import, and to chat once the profile opens again (e.g. after /reload).' },
+    description: 'Summaries built in parallel. Higher is faster, slightly less accurate and harder on rate limits; keep it below your provider\'s parallel cap.',
+    applies: 'Applies to the next import, and to chat after /reload.' },
   refreshAt: { kind: 'percent', label: 'Turn refresh threshold', default: 0.3, min: 0, max: 0.9,
-    description: 'Once the current turn\'s messages pass this share of the model\'s context window, they move into memory and the turn goes on with a fresh window: the rebuilt view, the task word for word, and its last tool call and result. 0%: off, as in Victor\'s recipe, and a long turn can run out of window. OPTCHAT_REFRESH_AT (a fraction, e.g. 0.3; 0 is off) overrides it. Subagents use Pi\'s own compaction at about the same point.',
-    applies: 'Applies from the next call, and to subagents started or resumed after this.' },
+    description: 'When a turn fills this share of the context window, it moves into memory and continues in a fresh window. 0%: off (Victor\'s recipe). OPTCHAT_REFRESH_AT overrides it.',
+    applies: 'Applies from the next call and to new or resumed subagents.' },
 } as const;
 
 export type SettingKey = keyof typeof SETTINGS;

package/src/window-bridge.ts

@@ -191,6 +191,10 @@ export async function serveWindows(directory: string, children: Children, availa
         if (task) { text = info.task; firstUser = false; }
         if (message.role === 'user') {
           // The task, and an interrupt, which continues with your queued messages, are yours too.
+          // Your messages show as you typed them, also inside an interrupt's prompt, not as the skill Pi expanded them into.
+          // Longest first: a skill sent without arguments is the start of the same skill sent with some.
+          const typed = info.guidance.flatMap(g => g.from === 'user' && g.sent ? [{ sent: g.sent, text: g.text }] : []).sort((a, b) => b.sent.length - a.sent.length);
+          for (const g of typed) text = text.replaceAll(g.sent, () => g.text);
           const yours = task || text.startsWith(INTERRUPTED) || info.guidance.some(g => g.from === 'user' && g.text === text.trim());
           if (text) send({ kind: 'event', name: 'message', from: yours ? 'user' : undefined, text: shorten(text, 200_000) });
           continue;