pi-optchat 0.6.7 → 0.6.8

package/src/index.ts

@@ -3,12 +3,12 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { hostname } from 'node:os';
 import { createHash } from 'node:crypto';
-import type { AgentMessage, ThinkingLevel } from '@earendil-works/pi-agent-core';
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { parseSkillBlock, type ExtensionAPI, type ExtensionContext, type ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 import { Memory } from './memory.ts';
 import { createCompressor } from './compactor.ts';
-import { atomicWrite, createProfile, instructions, lastProfile, listProfiles, loadConfig, lockProfile, profilePath, rememberProfile, saveConfig, ProfileBusyError, type ProfileConfig } from './profiles.ts';
+import { atomicWrite, createProfile, instructions, lastProfile, listProfiles, loadConfig, lockProfile, profilePath, rememberProfile, saveConfig, ProfileBusyError, THINKING, type ProfileConfig } from './profiles.ts';
 import { MASTER, VIEW_DOC } from './prompts.ts';
 import { cachePayload, record } from './cache.ts';
 import { asUser, boundedMessage, buildContext, logMessage, previousExchange, REPORT_TYPE, RUN_BOUNDARY, textContent, typedText } from './transcript.ts';
@@ -29,8 +29,12 @@ import { serveWindows } from './window-bridge.ts';
 import { openConnectedWindow, registerConnectedRenderer } from './connected-window.ts';
 import { createHandoffSummarizer } from './handoff.ts';
 import { mainTitle, TabTitle } from './title.ts';
+import { showSettings } from './settings-page.ts';
 
 const binding = 'optchat.profile';
+const CONTINUITY = '\n\nFor conversational continuity, the memory view may be followed by the immediately preceding completed exchange (its user requests and final answer, in full text; left out when very long), then the new input. Use that exact wording to understand follow-ups; older exchanges and previous tool output remain accessible through memory and zoom.';
+/** A report run while idle reuses the last built prompt, so a Previous exchange change since then is applied here. */
+const continuity = (prompt: string, on: boolean) => on === prompt.includes(CONTINUITY) ? prompt : on ? prompt.replace(VIEW_DOC, VIEW_DOC + CONTINUITY) : prompt.replace(CONTINUITY, '');
 interface Active { name: string; dir: string; config: ProfileConfig; memory: Memory; inbox: Inbox; children: Children; usage: UsageLedger; unlock: () => Promise<void> }
 
 export default function optchat(pi: ExtensionAPI) {
@@ -141,13 +145,13 @@ export default function optchat(pi: ExtensionAPI) {
       const memory = new Memory(memoryDirectory(dir), createCompressor(ctx.modelRegistry, () => config.compactor, message => {
         usage.compression(message, 'compactor', sessionId);
         status(ctx);
-      }), warning => ctx.ui.notify(warning, 'error'));
+      }, () => config.summaryAcceptBytes), warning => ctx.ui.notify(warning, 'error'));
       openingMemory = memory;
       const inbox = new Inbox(dir);
       const recovered = pendingImport(dir) ? 0 : inbox.recover(memory);
       if (recovered) ctx.ui.notify(`Recovered ${recovered} unanswered inputs into ${name}'s memory. Ask to continue them when ready.`, 'info');
       const children = new Children(memory, ctx.modelRegistry, () => config.subagent, () => `${instructions(dir)}\n\n${IMPORT_GUIDANCE}`,
-        deliverReport, text => ctx.ui.notify(text, 'error'), dir, { parentSession: sessionId, usage, builtins: () => loadedBuiltins(pi),
+        deliverReport, text => ctx.ui.notify(text, 'error'), dir, { parentSession: sessionId, usage, builtins: () => loadedBuiltins(pi), settings: () => config,
           summarizeHandoff: createHandoffSummarizer(ctx.modelRegistry, () => config.compactor, message => usage.compression(message, 'compactor', sessionId)) });
       const loggedReports = new Set(memory.root.map(e => e.receipt));
       reports = saved.filter((s): s is string => typeof s === 'string' && !loggedReports.has(reportReceipt(s)));
@@ -227,7 +231,8 @@ export default function optchat(pi: ExtensionAPI) {
   });
   const startRun = (ctx: ExtensionContext) => {
     flush(); run = []; logged = 0; view = undefined; runStarted = true;
-    previous = previousExchange(ctx.sessionManager.getBranch());
+    const config = active?.config;
+    previous = config?.previousExchange ? previousExchange(ctx.sessionManager.getBranch(), config.previousExchangeKB * 1000) : [];
     pi.appendEntry(RUN_BOUNDARY, { state: 'start' });
   };
   // A report sent while Pi is idle starts its run without before_agent_start; it reuses the last built prompt.
@@ -239,7 +244,7 @@ export default function optchat(pi: ExtensionAPI) {
     startRun(ctx);
     const a = required();
     // Pi's own prompt sections (AGENTS.md files, skills, cwd) stay; the profile's instructions go last.
-    event.systemPromptOptions.customPrompt = `${MASTER}\n\n${VIEW_DOC}\n\nFor conversational continuity, the memory view may be followed by the immediately preceding completed exchange (its user requests and final answer, in full text), then the new input. Use that exact wording to understand follow-ups; older exchanges and previous tool output remain accessible through memory and zoom.`;
+    event.systemPromptOptions.customPrompt = `${MASTER}\n\n${VIEW_DOC}${a.config.previousExchange ? CONTINUITY : ''}`;
     event.systemPromptOptions.sections.instructions = `${instructions(a.dir)}\n\n${IMPORT_GUIDANCE}`;
     prompt = event.systemPrompt;
   });
@@ -274,11 +279,11 @@ export default function optchat(pi: ExtensionAPI) {
       if (fault) throw new Error(fault);
       if (view === undefined) {
         ctx.ui.setWorkingMessage('Waiting for OptChat summaries…');
-        await a.memory.settle(ctx.signal);
+        try { await a.memory.settle(ctx.signal); } finally { ctx.ui.setWorkingMessage(); }
         view = a.memory.render(); // Capture old history before logging the new input.
-        flush(); ctx.ui.setWorkingMessage();
+        flush();
       }
-      return { messages: buildContext(event.messages, run, view, prompt, previous) };
+      return { messages: buildContext(event.messages, run, view, continuity(prompt, a.config.previousExchange), previous) };
     } catch (error) {
       // Pi catches extension errors. Explicitly abort so it cannot fall back to old context.
       ctx.abort();
@@ -314,8 +319,8 @@ export default function optchat(pi: ExtensionAPI) {
   registerReportRenderer(pi);
   for (const tool of memoryTools(() => required().memory)) pi.registerTool(tool);
   pi.registerTool({ name: 'spawn', label: 'Spawn background agents',
-    description: 'Start background subagents, returning IDs immediately. Use only when the user asks. Give each task the cwd of the project it works on, so the subagent starts there with that project\'s AGENTS.md. Each receives the current memory view and read-only zoom/date. Children may delegate two more levels; the whole profile allows 8 active agents. Completion reports arrive automatically; never poll or sleep waiting for them.',
-    parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String({ description: CWD_DOC })) }), { minItems: 1, maxItems: 8 }) }),
+    description: 'Start background subagents, returning IDs immediately. Use only when the user asks. Give each task the cwd of the project it works on, so the subagent starts there with that project\'s AGENTS.md. Each receives the current memory view and read-only zoom/date. Whether children may delegate further, and how many agents may run at once, is set per profile. Completion reports arrive automatically; never poll or sleep waiting for them.',
+    parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String({ description: CWD_DOC })) }), { minItems: 1 }) }),
     async execute(_id, args, signal, _update, ctx) {
       const ids = await required().children.spawn(args.tasks, ctx.cwd, signal); status(ctx);
       return result(`Started: ${ids.join(', ')}. Reports will arrive automatically.`);
@@ -332,10 +337,11 @@ export default function optchat(pi: ExtensionAPI) {
     choices.sort((a, b) => Number(b === `${current.provider}/${current.model}`) - Number(a === `${current.provider}/${current.model}`) || a.localeCompare(b));
     const selected = await ctx.ui.select(`${a.name}: ${role} model`, choices);
     if (!selected) return;
-    const thinking = await ctx.ui.select('Thinking level', ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+    const picked = await ctx.ui.select('Thinking level', [...THINKING]);
+    const thinking = THINKING.find(level => level === picked);
     if (!thinking) return;
     const separator = selected.indexOf('/');
-    a.config[role] = { provider: selected.slice(0, separator), model: selected.slice(separator + 1), thinking: thinking as ThinkingLevel };
+    a.config[role] = { provider: selected.slice(0, separator), model: selected.slice(separator + 1), thinking };
     saveConfig(a.dir, a.config); ctx.ui.notify(`${role}: ${selected} (${thinking}); applies to new calls.`, 'info');
   };
   const inspect = async (ctx: ExtensionContext, page: InspectorPage) => {
@@ -364,7 +370,7 @@ export default function optchat(pi: ExtensionAPI) {
     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', 'model', 'agents', 'usage', 'instructions', 'browse', 'import']) ?? '';
+      action = await ctx.ui.select(`OptChat\n${info}`, ['profile', 'settings', 'model', 'agents', 'usage', 'instructions', 'browse', 'import']) ?? '';
     }
     if (action === 'import') {
       const a = required();
@@ -394,7 +400,7 @@ export default function optchat(pi: ExtensionAPI) {
         if (!closed) { await a.memory.close(); closed = true; }
         const compress = createCompressor(ctx.modelRegistry, () => a.config.compactor, message => {
           a.usage.compression(message, 'import', ctx.sessionManager.getSessionId());
-        });
+        }, () => a.config.summaryAcceptBytes);
         const completed = await showProgress(ctx, job, (signal, progress) => runImport(a.dir, compress, signal, progress), signal);
         ctx.ui.notify(completed ? `Imported ${job.added} messages into ${a.name}. Previous memory retained at ${job.previous === '.' ? a.dir : join(a.dir, job.previous)}.`
           : 'Import paused. Use /optchat import to resume. Other profiles remain available.', 'info');
@@ -414,6 +420,12 @@ export default function optchat(pi: ExtensionAPI) {
       await ctx.newSession({ setup: async manager => { manager.appendCustomEntry(binding, { name: selected }); } });
       return;
     }
+    if (action === 'settings') {
+      const a = required();
+      if (ctx.mode !== 'tui') throw new Error('/optchat settings requires interactive Pi. Edit config.json in the profile directory instead.');
+      return showSettings(ctx, { profile: a.name, config: a.config, models: ctx.modelRegistry.getAvailable().map(m => `${m.provider}/${m.id}`).sort(),
+        save: config => saveConfig(a.dir, config) });
+    }
     if (action === 'model') return pickModel(ctx, 'compactor');
     if (action === 'agents model') return pickModel(ctx, 'subagent');
     if (action === 'agents' || action === 'usage') return inspect(ctx, action);
@@ -428,7 +440,7 @@ export default function optchat(pi: ExtensionAPI) {
       if (ctx.hasUI) execFile(process.platform === 'darwin' ? 'open' : 'xdg-open', [file], error => { if (error) ctx.ui.notify(`Open ${file}`, 'info'); });
       ctx.ui.notify(file, 'info'); return;
     }
-    if (action) throw new Error('Use /optchat [profile|model|agents|usage|instructions|browse|import].');
+    if (action) throw new Error('Use /optchat [profile|settings|model|agents|usage|instructions|browse|import].');
   };
   pi.registerCommand('complete', { description: 'End this connected conversation and hand off to the main agent', handler: async (_args, ctx) => {
     if (!remote) { ctx.ui.notify('/complete is for connected subagent windows.', 'info'); return; }
@@ -438,8 +450,8 @@ export default function optchat(pi: ExtensionAPI) {
     if (!remote) { ctx.ui.notify('/tell-main is for connected subagent windows.', 'info'); return; }
     try { await remote.tell(args); } catch (error) { ctx.ui.notify(errorText(error), 'error'); }
   } });
-  pi.registerCommand('optchat', { description: 'OptChat profiles, models, agents, instructions, memory browser, and imports',
-    getArgumentCompletions: prefix => ['profile', 'model', 'agents', 'agents model', 'usage', 'instructions', 'browse', 'import'].filter(s => s.startsWith(prefix)).map(value => ({ value, label: value })),
+  pi.registerCommand('optchat', { description: 'OptChat profiles, settings, models, agents, instructions, memory browser, and imports',
+    getArgumentCompletions: prefix => ['profile', 'settings', 'model', 'agents', 'agents model', 'usage', 'instructions', 'browse', 'import'].filter(s => s.startsWith(prefix)).map(value => ({ value, label: value })),
     handler: async (args, ctx) => { try { await command(args, ctx); } catch (error) { ctx.ui.notify(errorText(error), 'error'); } },
   });
 }

package/src/memory.ts

@@ -1,5 +1,5 @@
-import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, writeSync } from 'node:fs';
-import { join } from 'node:path';
+import { closeSync, existsSync, fstatSync, fsyncSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync, writeSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { EventEmitter } from 'node:events';
 
 export const NODE = 512;
@@ -19,21 +19,32 @@ export const end = (part: Part) => start(part) + 2 ** part.l;
 export const bytes = (s: string) => Buffer.byteLength(s, 'utf8');
 const UNBUILT_BYTES = bytes(UNBUILT);
 export const flat = (s: string) => s.replace(/[\r\n]+/g, ' ');
+const lineBytes = (s: string) => bytes(flat(s));
+const notice = (omitted: number) => `\n[${omitted} characters omitted; head and tail retained]\n`;
+const VIEW_OPEN = '<chat>\n';
+export const isView = (text: string) => text.startsWith(VIEW_OPEN);
 export function cap(text: string, limit = CAP) {
   if (text.length <= limit) return text;
-  const notice = `\n[${text.length - limit} characters omitted; head and tail retained]\n`;
-  const half = Math.floor((limit - notice.length) / 2);
-  return text.slice(0, half) + notice + text.slice(-half);
+  const half = Math.floor((limit - notice(text.length).length) / 2);
+  const head = text.slice(0, /[\ud800-\udbff]/.test(text[half - 1]) ? half - 1 : half);
+  const tail = text.slice(/[\udc00-\udfff]/.test(text[text.length - half]) ? text.length - half + 1 : text.length - half);
+  return head + notice(text.length - head.length - tail.length) + tail;
 }
 export function localDay(date = new Date()) {
   return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
 }
-export function appendJson(file: string, value: unknown) {
-  const fd = openSync(file, 'a', 0o600);
+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. */
+export function appendJson(file: string, value: unknown, size?: number) {
+  const fd = openSync(file, 'a+', 0o600);
   try {
-    const data = Buffer.from(JSON.stringify(value) + '\n');
+    const length = fstatSync(fd).size, last = Buffer.alloc(1);
+    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}`);
     fsyncSync(fd);
+    return fstatSync(fd).size;
   } finally { closeSync(fd); }
 }
 function records(dir: string, warn: (s: string) => void): unknown[] {
@@ -41,16 +52,11 @@ function records(dir: string, warn: (s: string) => void): unknown[] {
   const result: unknown[] = [];
   for (const name of readdirSync(dir).filter(n => n.endsWith('.jsonl')).sort()) {
     const file = join(dir, name);
-    const text = readFileSync(file, 'utf8');
-    for (const [index, line] of text.split('\n').entries()) {
+    for (const [index, line] of readFileSync(file, 'utf8').split('\n').entries()) {
       if (!line.trim()) continue;
       try { result.push(JSON.parse(line)); }
       catch { warn(`Skipped damaged JSON at ${file}:${index + 1}`); }
     }
-    if (text && !text.endsWith('\n')) {
-      const fd = openSync(file, 'a');
-      try { writeSync(fd, '\n'); fsyncSync(fd); } finally { closeSync(fd); }
-    }
   }
   return result;
 }
@@ -77,6 +83,7 @@ export class Memory {
   private readonly busy = new Map<number, Promise<void>>();
   private readonly retryAt = new Map<number, number>();
   private readonly reported = new Set<number>();
+  private readonly lastSeenBytes = new Map<string, number>();
   private viewBytes = 0;
   private leaves = 0;
   /** Per level, every node below this index is built. */
@@ -90,24 +97,31 @@ export class Memory {
     private readonly warn: (s: string) => void = console.error,
     readonly budget = VIEW, private readonly jobs = 8, private readonly retryMs = 10_000) {
     for (const sub of ['main', 'tree']) mkdirSync(join(directory, sub), { recursive: true, mode: 0o700 });
-    for (const value of records(join(directory, 'main'), warn)) {
-      if (!isEntry(value) || value.i !== this.root.length) throw new Error('Invalid/noncontiguous OptChat log; refusing to change it.');
-      this.root.push({ ...value, size: bytes(`${value.kind}: ${value.text}`) });
-    }
+    const main = join(directory, 'main'), log = records(main, warn);
+    for (const name of readdirSync(main).filter(n => n.endsWith('.jsonl'))) this.lastSeenBytes.set(join(main, name), statSync(join(main, name)).size);
+    const entries = log.every(isEntry) ? log.sort((a, b) => a.i - b.i) : undefined;
+    if (!entries || entries.some((entry, i) => entry.i !== i)) throw new Error('Invalid/noncontiguous OptChat log; refusing to change it.');
+    for (const value of entries) this.root.push({ ...value, size: bytes(`${value.kind}: ${value.text}`) });
     for (const value of records(join(directory, 'tree'), warn)) {
       if (!isSummary(value) || value.l < 0 || value.i < 0 || end(value) > this.root.length)
         throw new Error('Invalid OptChat summary record.');
       if (value.l === 0 && !this.tree.has(key(value))) this.leaves++;
-      this.tree.set(key(value), { ...value, size: bytes(value.text) });
+      this.tree.set(key(value), { ...value, size: lineBytes(value.text) });
     }
     // Fold history in order; do not retile the entire log on each turn.
     for (let i = 0; i < this.root.length; i++) { this.push(i); this.fit(i + 1); }
     this.schedule();
   }
+  private checkLog(next: string) {
+    const main = dirname(next), names = readdirSync(main).filter(n => n.endsWith('.jsonl'));
+    if (names.length !== this.lastSeenBytes.size || names.some(n => statSync(join(main, n)).size !== this.lastSeenBytes.get(join(main, n)))) throw otherWriter(next);
+  }
   append(kind: Kind, text: string, date = new Date().toISOString(), receipt?: string) {
     if (this.stopped) throw new Error('Memory is closed.');
     const entry: Entry = { i: this.root.length, kind, text, date, size: bytes(`${kind}: ${text}`), ...(receipt ? { receipt } : {}) };
-    appendJson(join(this.directory, 'main', `${localDay()}.jsonl`), entry);
+    const file = join(this.directory, 'main', `${localDay()}.jsonl`);
+    if (!this.lastSeenBytes.has(file)) this.checkLog(file);
+    this.lastSeenBytes.set(file, appendJson(file, entry, this.lastSeenBytes.get(file) ?? 0));
     this.root.push(entry); this.push(entry.i); this.fit(); this.schedule();
     return entry;
   }
@@ -115,7 +129,7 @@ export class Memory {
   private text(part: Part) { return this.node(part)?.text ?? UNBUILT; }
   private partBytes(part: Part) { return this.node(part)?.size ?? UNBUILT_BYTES; }
   private push(i: number) { const part = { l: 0, i }; this.view.push(part); this.viewBytes += this.partBytes(part); }
-  render() { return `<chat>\n${this.view.map(p => `${start(p)}+${2 ** p.l}|${flat(this.text(p))}`).join('\n')}\n</chat>`; }
+  render() { return `${VIEW_OPEN}${this.view.map(p => `${start(p)}+${2 ** p.l}|${flat(this.text(p))}`).join('\n')}\n</chat>`; }
   get ready() { return this.view.every(p => this.node(p)); }
   get pending() { return this.root.length - this.leaves; }
   get active() { return this.busy.size; }
@@ -192,7 +206,7 @@ export class Memory {
       historical: this.root.slice(start(part), end(part)).some(entry => !!entry.origin) }, this.controller.signal)).trim();
     if (this.stopped) return;
     if (!text) throw new Error('Compactor returned an empty summary.');
-    const node = { ...part, text, size: bytes(text) };
+    const node = { ...part, text, size: lineBytes(text) };
     appendJson(join(this.directory, 'tree', `${localDay()}.jsonl`), node);
     this.tree.set(key(part), node); this.retryAt.delete(key(part));
     // A leaf is usually still in the view when built, but after a damaged tree file a saved parent can already hide it.
@@ -200,8 +214,9 @@ export class Memory {
     if (!this.retryAt.size) this.lastError = undefined;
     this.fit();
   }
+  /** Waits until every part of the view is built. As in the recipe, the view may run over budget until pending merges land. */
   async settle(signal?: AbortSignal, all = false): Promise<void> {
-    const done = () => this.ready && this.size <= this.budget && (!all || (this.busy.size === 0 && this.tree.size === this.expectedNodes()));
+    const done = () => this.ready && (!all || (this.busy.size === 0 && this.tree.size === this.expectedNodes()));
     if (done()) return;
     if (this.stopped || signal?.aborted) throw new Error('Memory wait cancelled.');
     await new Promise<void>((resolve, reject) => {

package/src/profiles.ts

@@ -1,17 +1,19 @@
-import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { chmodSync, closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { createConnection, createServer } from 'node:net';
-import { homedir, tmpdir } from 'node:os';
+import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
-import { createHash } from 'node:crypto';
 import type { ModelChoice } from './compactor.ts';
 import { record } from './cache.ts';
+import { DEFAULT_SETTINGS, readSettings, type Settings } from './settings.ts';
 
 export const dataHome = () => resolve(process.env.OPTCHAT_HOME ?? join(homedir(), '.optchat'));
-export interface ProfileConfig { compactor: ModelChoice; subagent: ModelChoice }
+export interface ProfileConfig extends Settings { compactor: ModelChoice; subagent: 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' },
+  ...DEFAULT_SETTINGS,
 };
+export const THINKING = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
 export function profilePath(name: string) {
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(name)) throw new Error('Profile names: 1–64 lowercase letters, digits, hyphens, or underscores.');
   return join(dataHome(), 'profiles', name);
@@ -40,12 +42,13 @@ export function createProfile(name: string) {
 export function saveConfig(dir: string, config: ProfileConfig) { atomicWrite(join(dir, 'config.json'), JSON.stringify(config, null, 2) + '\n'); }
 function modelChoice(value: unknown): value is ModelChoice {
   return record(value) && typeof value.provider === 'string' && typeof value.model === 'string'
-    && typeof value.thinking === 'string' && ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].includes(value.thinking);
+    && THINKING.some(level => level === value.thinking);
 }
 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`);
-  return { compactor: value.compactor, subagent: value.subagent };
+  try { return { compactor: value.compactor, subagent: value.subagent, ...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'); }
 export function lastProfile() {
@@ -57,15 +60,29 @@ export function rememberProfile(name: string) { atomicWrite(join(dataHome(), 'la
 export class ProfileBusyError extends Error {
   constructor(readonly owner: string) { super(`Profile already running: ${owner}`); }
 }
-export function profileSocket(dir: string, purpose: 'lock' | 'windows' = 'lock') {
-  const hash = createHash('sha256').update(dir).digest('hex').slice(0, 24);
-  return join(tmpdir(), `pi-optchat-${process.getuid?.() ?? 'user'}-${hash}${purpose === 'lock' ? '' : '-windows'}.sock`);
+/** Lives in the profile itself, so every Pi on this profile finds the same socket whatever its TMPDIR. Git skips sockets, so checkpoints never see it. */
+export const profileSocket = (dir: string, purpose: 'lock' | 'windows' = 'lock') => join(dir, `${purpose}.sock`);
+
+// sun_path is 104 bytes on macOS and 108 elsewhere, both including the NUL. Node 22 binds a truncated path instead of failing, so the length is checked before listen.
+export const SOCKET_PATH_LIMIT = process.platform === 'darwin' ? 103 : 107;
+export function checkSocketPath(path: string) {
+  const length = Buffer.byteLength(path);
+  if (length > SOCKET_PATH_LIMIT) throw new Error(`Cannot listen on the profile socket: its path is ${length} bytes, over this system's limit of ${SOCKET_PATH_LIMIT}. Set OPTCHAT_HOME to a shorter directory: ${path}`);
+}
+
+/** A socket that may be replaced; a file that only shares its name is refused, never deleted. */
+function existingSocket(path: string) {
+  let stat; try { stat = lstatSync(path); } catch { return undefined; }
+  if (!stat.isSocket()) throw new Error(`${path} is not an OptChat socket. Move it out of the profile and try again.`);
+  return stat;
 }
+/** Removes a dead socket left by a previous owner. */
+export function removeStaleSocket(path: string) { if (existingSocket(path)) unlinkSync(path); }
 
 /** OS-owned socket lifetime, no timeout-based stealing of a busy profile. */
 export async function lockProfile(dir: string, description: string) {
-  const socketPath = profileSocket(dir);
-  const server = createServer(socket => { socket.end(description); });
+  const socketPath = profileSocket(dir); checkSocketPath(socketPath);
+  const server = createServer(socket => { socket.on('error', () => socket.destroy()); socket.end(description); });
   const listen = () => new Promise<void>((resolve, reject) => {
     const failed = (error: Error) => { server.off('listening', ready); reject(error); };
     const ready = () => { server.off('error', failed); resolve(); };
@@ -74,7 +91,8 @@ export async function lockProfile(dir: string, description: string) {
   try { await listen(); }
   catch (error) {
     if (!(error instanceof Error) || !('code' in error) || error.code !== 'EADDRINUSE') throw error;
-    const before = statSync(socketPath);
+    const before = existingSocket(socketPath);
+    if (!before) throw new Error('Profile lock changed; try again.');
     const owner = await new Promise<string | undefined>((resolve, reject) => {
       const socket = createConnection(socketPath); let message = '';
       socket.setTimeout(1500, () => { socket.destroy(); reject(new Error('Profile lock did not respond; refusing to steal it.')); });
@@ -86,6 +104,7 @@ export async function lockProfile(dir: string, description: string) {
     if (statSync(socketPath).ino !== before.ino) throw new Error('Profile lock changed; try again.');
     unlinkSync(socketPath); await listen();
   }
-  chmodSync(socketPath, 0o600);
-  return () => new Promise<void>(resolve => server.close(() => resolve()));
+  const unlock = () => new Promise<void>(resolve => server.close(() => resolve()));
+  try { chmodSync(socketPath, 0o600); } catch (error) { await unlock(); throw error; }
+  return unlock;
 }

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,160 @@
+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';
+
+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; models: string[];
+  /** 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: string[], 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(value => ({ value, label: value }));
+    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.indexOf(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 list = new SelectList(THINKING.map(value => ({ value, label: value })), THINKING.length, listTheme(theme));
+    list.setSelectedIndex(Math.max(0, THINKING.indexOf(current.thinking)));
+    list.onCancel = () => this.pickModel();
+    list.onSelect = item => {
+      const thinking = THINKING.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()));
+}