pi-optchat 0.9.0 → 0.9.2

package/README.md

@@ -75,11 +75,11 @@ Details, errors and join rules: [docs/connected-windows.md](docs/connected-windo
 
 | Role | Default | Change with |
 | --- | --- | --- |
-| Main agent | Whatever is selected in Pi | `/model` |
+| Main agent | Whatever is selected in Pi, then the profile's last pick | `/model` |
 | Subagents | Anthropic Opus 5.5, high | `/optchat agents model` |
 | Compactor (summaries, imports, handoffs) | Anthropic Sonnet 5.5, medium | `/optchat model` |
 
-Subagent and compactor settings are saved per profile and do not follow the main model. If you use other providers, change them before chatting. Authentication uses Pi's existing provider login.
+All three are saved per profile. The main agent's model and thinking level are saved whenever you change them in Pi and picked again when the profile opens, unless the saved model is no longer available. This includes resumed sessions: the profile's pick replaces the one the session last used. On Pi's command line, `--model` (or `--provider`) keeps that model, `--thinking` that level, and `--models` keeps a saved model only if it is in that list. Subagent and compactor settings do not follow the main model. If you use other providers, change them before chatting. Authentication uses Pi's existing provider login.
 
 Compression and subagents make extra model requests with your provider credentials.
 
@@ -202,7 +202,7 @@ Profile data lives in `~/.optchat/profiles/<name>/` (override the root with `OPT
 | `active-memory.json`, `memories/<id>/` | After an import: pointer to the active `main/` and `tree/`. Older generations are kept. |
 | `imports/pending.json` | Resumable import state |
 | `AGENTS.md` | Profile instructions |
-| `config.json` | Compactor and subagent models |
+| `config.json` | Main, compactor and subagent models, and settings |
 | `pending-inputs.json`, `pending-reports.json` | Recovery journals |
 | `runs/` | Subagent sessions and run metadata |
 | `usage.jsonl` | Usage ledger |

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.0",
+  "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

@@ -4,11 +4,11 @@ import { join } from 'node:path';
 import { hostname } from 'node:os';
 import { getSupportedThinkingLevels } from '@earendil-works/pi-ai';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
-import { parseSkillBlock, type ExtensionAPI, type ExtensionContext, type ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import { parseArgs, parseSkillBlock, type ExtensionAPI, type ExtensionContext, type ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 import { Memory } from './memory.ts';
 import { atomicWrite, storeFor } from './store.ts';
-import { createCompressor } from './compactor.ts';
+import { createCompressor, type ModelChoice } from './compactor.ts';
 import { createProfile, holdProfile, instructions, isWindows, lastProfile, listProfiles, loadConfig, profilePath, rememberProfile, saveConfig, ProfileBusyError, type ProfileConfig } from './profiles.ts';
 import { allowSearch, CONTINUITY, IMPORT_GUIDANCE, MASTER, modelsHint, SEARCH_DOC, TURN_REFRESHED, VIEW_DOC } from './prompts.ts';
 import { cachePayload, record } from './cache.ts';
@@ -114,6 +114,39 @@ export default function optchat(pi: ExtensionAPI) {
     try { return await joinHeadless(profilePath(name)); }
     catch (error) { process.exitCode = 1; throw error; }
   };
+  // The main model follows the profile: each pick in Pi is saved to its config.json, and opening the profile picks it again.
+  // `--model`/`--provider`/`--thinking` on Pi's command line win over the saved choice for as long as this Pi runs; `--models` only keeps a saved model inside its scope.
+  const launch = parseArgs(process.argv.slice(2)), pinnedModel = launch.model !== undefined || launch.provider !== undefined;
+  // `restored`: where the last restore left Pi. Pi fires thinking_level_select without awaiting it, so a handler may run after the restore; that state isn't a pick.
+  let restoring = false, restored: ModelChoice | undefined;
+  const sameChoice = (a: ModelChoice | undefined, b: ModelChoice) => a?.provider === b.provider && a.model === b.model && a.thinking === b.thinking;
+  const mainChoice = ({ model }: ExtensionContext): ModelChoice | undefined => model && { provider: model.provider, model: model.id, thinking: pi.getThinkingLevel() };
+  const rememberMain = (ctx: ExtensionContext) => {
+    // Read Pi's state, not the event: a model switch reports its thinking level before the model, and a late handler sees where both ended up.
+    const a = active, main = mainChoice(ctx);
+    if (restoring || !a || !main || sameChoice(restored, main)) return;
+    restored = undefined;
+    if (sameChoice(a.config.main, main)) return;
+    try { saveConfig(a.dir, { ...a.config, main }); a.config.main = main; }
+    catch (error) { ctx.ui.notify(`Could not save the main model to ${a.name}: ${errorText(error)}`, 'error'); }
+  };
+  pi.on('model_select', (_event, ctx) => rememberMain(ctx));
+  pi.on('thinking_level_select', (_event, ctx) => rememberMain(ctx));
+  const restoreMain = async (ctx: ExtensionContext, { name, config: { main } }: Active) => {
+    restored = undefined;
+    if (!main || pinnedModel || launch.models && !ctx.scopedModels.some(({ model }) => model.provider === main.provider && model.id === main.model)) return;
+    const model = ctx.modelRegistry.find(main.provider, main.model), thinking = launch.thinking ?? main.thinking;
+    restoring = true;
+    try {
+      const current = ctx.model?.provider === main.provider && ctx.model.id === main.model;
+      if (!model || !current && !await pi.setModel(model).catch(() => false)) {
+        ctx.ui.notify(`${name}'s main model ${main.provider}/${main.model} is unavailable; keeping ${ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : 'Pi\'s default'}.`, 'warning');
+        return;
+      }
+      pi.setThinkingLevel(thinking);
+      restored = mainChoice(ctx);
+    } finally { restoring = false; }
+  };
   const required = () => { if (!active) throw new Error('Choose an OptChat profile first: /optchat profile'); return active; };
   const status = (ctx: ExtensionContext) => {
     const a = active;
@@ -165,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);
@@ -219,6 +254,7 @@ export default function optchat(pi: ExtensionAPI) {
       atomicWrite(pending, JSON.stringify(reports));
       rememberProfile(name);
       active = { name, dir, config, memory, inbox, children, usage, unlock }; fault = undefined; idle = () => ctx.isIdle();
+      await restoreMain(ctx, active);
       if (ctx.mode === 'tui') unmountNavigation = mountNavigation(ctx, children, memory, shortcut, page => { void inspect(ctx, page); });
       // A one-shot run (`pi -p`, JSON) exits after its own prompt, which would end every conversation connected to it.
       if (ctx.mode !== 'print' && ctx.mode !== 'json') closeWindows = await serveWindows(dir, children, () => !stopping && !importing && !pendingImport(dir), deliverReport);

package/src/profiles.ts

@@ -12,7 +12,8 @@ export const isWindows = process.platform === 'win32';
 const PIPE_PREFIX = '\\\\.\\pipe\\';
 
 export const dataHome = () => resolve(process.env.OPTCHAT_HOME ?? join(homedir(), '.optchat'));
-export interface ProfileConfig extends Settings { compactor: ModelChoice; subagent: ModelChoice }
+/** `main` is the last model and thinking level picked in Pi while this profile was open; absent until one is picked. */
+export interface ProfileConfig extends Settings { compactor: ModelChoice; subagent: ModelChoice; main?: ModelChoice }
 export const defaults: ProfileConfig = {
   compactor: { provider: 'anthropic', model: 'claude-sonnet-5-5', thinking: 'medium' },
   subagent: { provider: 'anthropic', model: 'claude-opus-5-5', thinking: 'high' },
@@ -50,8 +51,9 @@ function modelChoice(value: unknown): value is ModelChoice {
 }
 export function loadConfig(dir: string): ProfileConfig {
   const value: unknown = JSON.parse(readFileSync(join(dir, 'config.json'), 'utf8'));
-  if (!record(value) || !modelChoice(value.compactor) || !modelChoice(value.subagent)) throw new Error(`Invalid profile config: ${dir}/config.json`);
-  try { return { compactor: value.compactor, subagent: value.subagent, ...readSettings(value) }; }
+  if (!record(value) || !modelChoice(value.compactor) || !modelChoice(value.subagent) || value.main !== undefined && !modelChoice(value.main)) throw new Error(`Invalid profile config: ${dir}/config.json`);
+  const { compactor, subagent, main } = value;
+  try { return { compactor, subagent, ...main && { main }, ...readSettings(value) }; }
   catch (error) { throw new Error(`Invalid profile config: ${dir}/config.json: ${error instanceof Error ? error.message : String(error)}`); }
 }
 export function instructions(dir: string) { return readFileSync(join(dir, 'AGENTS.md'), 'utf8'); }