pi-optchat 0.9.1 → 0.9.2

package/docs/connected-windows.md

@@ -18,7 +18,7 @@ If you open the same profile in a second terminal, Pi offers to connect it to th
 
 - Run `/complete` when done. The window closes, remaining work stops, and the compactor writes a handoff for the main agent: decisions, changes, evidence, failures, unfinished work, and links to the transcripts.
 - Closing or force-quitting the window also produces a handoff, marked **interrupted**.
-- If the original window is closed cleanly, handoffs are delivered on next start. If it is killed, reopening the profile recovers unfinished handoffs (work is not restarted).
+- If the original window is closed cleanly or reloaded, it doesn't wait for the compactor: handoffs, including one still being written after `/complete`, are written and delivered on next start. If it is killed, reopening the profile recovers unfinished handoffs (work is not restarted).
 - Closing the original window, or running `/reload` in it, ends every connected conversation; Pi gives no chance to warn before a reload. The connected window then shows **disconnected**. `/new` there starts over: after the profile picker if Pi was started without `--optchat-profile`, a profile still open elsewhere offers **Start a connected subagent conversation here** again, and a free one opens in this window.
 
 ### Handoff limits

package/package.json

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

package/src/agents.ts

@@ -49,7 +49,7 @@ interface Options { parentSession?: string; usage?: UsageLedger; createSession?:
   hold?: (batch: string, texts: string[]) => void;
   /** Read on every spawn, so a changed profile setting applies to the next one. Missing settings take their defaults. */
   settings?: () => Partial<Settings>;
-  summarizeHandoff?: (run: RunInfo, messages: AgentMessage[], descendants?: HandoffEvidence[]) => Promise<string> }
+  summarizeHandoff?: (run: RunInfo, messages: AgentMessage[], descendants?: HandoffEvidence[], signal?: AbortSignal) => Promise<string> }
 
 // Subagents load the user's installed extensions, except any copy of OptChat itself: they get memory tools directly and must not open a profile.
 const packageName = (path: string): string | undefined => {
@@ -133,6 +133,8 @@ export class Children {
   private settling = 0;
   private readonly launches = new Set<Promise<unknown>>();
   private readonly completions = new Set<Promise<void>>();
+  /** Aborted when Pi starts closing: see deferHandoffs(). */
+  private readonly deferring = new AbortController();
   constructor(private readonly memory: Memory, private readonly registry: ModelRegistry,
     private readonly choice: () => ModelChoice, private readonly instructions: () => string,
     private readonly report: (text: string, options?: { once?: boolean; count?: number }) => Promise<void>, private readonly warn: (text: string) => void,
@@ -681,6 +683,8 @@ export class Children {
     const handoff = run.handoff;
     if (!handoff || handoff.delivered) return;
     if (!handoff.text) {
+      const deferred = this.deferring.signal;
+      if (deferred.aborted) return;
       const evidence = [run, ...this.history.descendants(run.id)].map((record): HandoffEvidence => {
         try { return { run: record, messages: this.messages(record.id) }; }
         catch (error) { return { run: record, messages: [], transcriptError: String(error) }; }
@@ -688,8 +692,9 @@ export class Children {
       let summary: string;
       try {
         if (!this.options.summarizeHandoff) throw new Error('No handoff summarizer configured');
-        summary = await this.options.summarizeHandoff(run, evidence[0].messages, evidence.slice(1));
+        summary = await this.options.summarizeHandoff(run, evidence[0].messages, evidence.slice(1), deferred);
       } catch (error) {
+        if (deferred.aborted) return;
         summary = `Automatic summary unavailable: ${String(error)}\nInitial request: ${run.task}\nLast recorded result: ${run.report ?? 'No final answer recorded.'}\nUndelivered guidance: ${run.guidance.filter(g => g.state === 'undelivered').map(g => g.text).join('\n')}\nRead the saved transcript or run metadata for the full work and user corrections.`;
       }
       const source = evidence.map(({ run: record, transcriptError }) => {
@@ -747,8 +752,11 @@ export class Children {
       if (!reports) this.memory.append('work', `[${id}] deleted by the user`);
     } finally { for (const run of marked) this.deleting.delete(run); this.changed(); }
   }
+  /** Pi is closing: a handoff not written yet is left undelivered for the next start's recoverHandoffs(), and one being
+   * written is aborted, so closing or /reload never waits on a model call. */
+  deferHandoffs() { this.deferring.abort(); }
   async close() {
-    this.closing = true;
+    this.closing = true; this.deferHandoffs();
     // Only work in progress is picked up at the next start: not paused runs waiting for the user, runs being stopped, or connected windows (they hand off).
     for (const { info } of this.running.values()) if (!info.connected && (info.state === 'running' || info.state === 'waiting')) info.cutOff = true;
     await Promise.allSettled([...this.running.keys()].map(id => this.stop(id, 'pi')));

package/src/handoff.ts

@@ -31,7 +31,7 @@ function formatEvidence({ run, messages, transcriptError }: HandoffEvidence) {
 /** Summarize in one call when possible; otherwise fold chunks with the prior handoff included in the budget. */
 export function createHandoffSummarizer(registry: ModelRegistry, choice: () => ModelChoice,
   usage: (message: AssistantMessage) => void, retryDelays?: readonly number[]) {
-  return async (run: RunInfo, messages: AgentMessage[], descendants: HandoffEvidence[] = []) => {
+  return async (run: RunInfo, messages: AgentMessage[], descendants: HandoffEvidence[] = [], signal?: AbortSignal) => {
     const selected = choice(), model = registry.find(selected.provider, selected.model);
     if (!model) throw new Error('Profile compactor model unavailable');
     const transcript = Buffer.from([{ run, messages }, ...descendants].map(formatEvidence).join('\n\n'));
@@ -53,7 +53,7 @@ export function createHandoffSummarizer(registry: ModelRegistry, choice: () => M
       const reply = await retryTransient(() => registry.streamSimple(model, {
         systemPrompt: HANDOFF,
         messages: [{ role: 'user', timestamp: Date.now(), content: prefix + transcript.subarray(offset, end).toString('utf8') }],
-      }, { reasoning: reasoningFor(model, selected.thinking), maxTokens, signal: AbortSignal.timeout(300_000) }).result(), usage, retryDelays);
+      }, { reasoning: reasoningFor(model, selected.thinking), maxTokens, signal: AbortSignal.any([AbortSignal.timeout(300_000), ...signal ? [signal] : []]) }).result(), usage, retryDelays, signal);
       if (reply.stopReason === 'error' || reply.stopReason === 'aborted') throw new Error(reply.errorMessage ?? reply.stopReason);
       if (reply.stopReason === 'length') throw new Error('Handoff hit the model output limit before finishing');
       summary = textContent(reply.content).trim();

package/src/index.ts

@@ -198,6 +198,8 @@ export default function optchat(pi: ExtensionAPI) {
     if (!active) return;
     const old = active;
     try {
+      // Ending connected windows and recovery must not wait on handoff summaries: the next start writes and delivers them.
+      old.children.deferHandoffs();
       await closeWindows?.(); closeWindows = undefined;
       await recovery;
       await old.children.close(); flush(); if (!pendingImport(old.dir)) old.inbox.recover(old.memory);