pi-optchat 0.6.7 → 0.7.0

package/src/index.ts

@@ -3,17 +3,18 @@ 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 { 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 { 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';
-import { registerReportRenderer } from './report-message.ts';
-import { memoryTools, result } from './tools.ts';
+import { registerReportRenderer, type ReportDetails } from './report-message.ts';
+import { memoryTools, result, SEARCH_DOC, searchTool } from './tools.ts';
 import { Children, CWD_DOC, loadedBuiltins } from './agents.ts';
 import { exportBrowser } from './browser.ts';
 import { Inbox } from './inbox.ts';
@@ -29,8 +30,14 @@ 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.';
+const toggle = (prompt: string, line: string, on: boolean, after: string) => on === prompt.includes(line) ? prompt : on ? prompt.replace(after, after + line) : prompt.replace(line, '');
+/** A report run while idle reuses the last built prompt, so Previous exchange and Memory search changes since then are applied here. */
+const promptFor = (prompt: string, { previousExchange, memorySearch }: ProfileConfig) =>
+  toggle(toggle(prompt, CONTINUITY, previousExchange, VIEW_DOC), SEARCH_DOC, memorySearch, previousExchange ? VIEW_DOC + CONTINUITY : VIEW_DOC);
 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) {
@@ -45,7 +52,8 @@ export default function optchat(pi: ExtensionAPI) {
   let prompt = '';
   let runStarted = false;
   let fault: string | undefined;
-  let reports: string[] = [];
+  /** Reports not yet in memory. `count`: how many subagent reports the text joins. `batch`: held while the rest of that spawn runs, not sent yet. */
+  let reports: { text: string; count?: number; batch?: string }[] = [];
   const receipts = new Map<AgentMessage, string>();
   let checkpoints = Promise.resolve();
   let importing = false;
@@ -62,13 +70,21 @@ export default function optchat(pi: ExtensionAPI) {
     const a = active;
     if (a) title.show(text => ctx.ui.setTitle(text), mainTitle(a.name, working, a.children.ids.length));
   };
+  /** Journals written before batches held plain strings. */
+  const isPendingReport = (s: unknown): s is string | { text: string; count?: number } =>
+    typeof s === 'string' || record(s) && typeof s.text === 'string' && (s.count === undefined || typeof s.count === 'number');
   const reportReceipt = (text: string) => 'report:' + createHash('sha256').update(text).digest('hex');
   const errorText = (error: unknown) => error instanceof Error ? error.message : String(error);
   pi.registerFlag('optchat-profile', { description: 'OptChat profile (required for noninteractive sessions without a saved binding)', type: 'string' });
   const required = () => { if (!active) throw new Error('Choose an OptChat profile first: /optchat profile'); return active; };
   const status = (ctx: ExtensionContext) => {
     const a = active;
-    ctx.ui.setStatus('optchat', a ? `OptChat: ${a.name} · ${a.memory.root.length} messages · ${a.memory.pending} pending · ${a.children.ids.length} agents${importing ? ' · importing' : pendingImport(a.dir) ? ' · import paused: /optchat import' : ''}` : 'OptChat: choose profile');
+    if (!a) { ctx.ui.setStatus('optchat', 'OptChat: choose profile'); return; }
+    // A display only: a broken import journal is refused where it matters, never here.
+    let note = '';
+    try { note = importing ? ' · importing' : pendingImport(a.dir) ? ' · import paused: /optchat import' : ''; }
+    catch { note = ' · import journal invalid'; }
+    ctx.ui.setStatus('optchat', `OptChat: ${a.name} · ${a.memory.root.length} messages · ${a.memory.pending} pending · ${a.children.ids.length} agents${note}`);
   };
   const saveReports = () => { if (active) atomicWrite(join(active.dir, 'pending-reports.json'), JSON.stringify(reports)); };
   const flush = () => {
@@ -80,21 +96,25 @@ export default function optchat(pi: ExtensionAPI) {
       if (receipt && !receipt.startsWith('report:')) active.inbox.acknowledge(receipt);
       receipts.delete(message);
       if (message.role === 'user') {
-        const index = reports.indexOf(textContent(message.content));
+        const text = textContent(message.content), index = reports.findIndex(r => !r.batch && r.text === text);
         if (index >= 0) { reports.splice(index, 1); saveReports(); }
       }
     }
   };
   // Shown as a dark background box, not as the user's own message. Before this profile has run once there is no
   // built system prompt to reuse, so that rare case still goes through Pi's normal prompt path as a user message.
-  const sendReport = (text: string) => {
-    if (prompt) pi.sendMessage({ customType: REPORT_TYPE, content: text, display: true }, { triggerTurn: true, deliverAs: 'steer' });
+  const sendReport = (text: string, count?: number) => {
+    if (prompt) pi.sendMessage<ReportDetails>({ customType: REPORT_TYPE, content: text, display: true, details: { count } }, { triggerTurn: true, deliverAs: 'steer' });
     else pi.sendUserMessage(text, { deliverAs: 'steer', expandPromptTemplates: false });
   };
-  const deliverReport = async (text: string, once = false) => {
-    if (once && (active?.memory.root.some(e => e.receipt === reportReceipt(text)) || reports.includes(text))) return;
-    reports.push(text); saveReports();
-    if (!stopping) sendReport(text);
+  const deliverReport = async (text: string, { once = false, count }: { once?: boolean; count?: number } = {}) => {
+    if (once && (active?.memory.root.some(e => e.receipt === reportReceipt(text)) || reports.some(r => r.text === text))) return;
+    reports.push({ text, count }); saveReports();
+    if (!stopping) sendReport(text, count);
+  };
+  const holdReports = (batch: string, texts: string[]) => {
+    reports = [...reports.filter(r => r.batch !== batch), ...texts.length ? [{ text: texts.join('\n\n'), count: texts.length, batch }] : []];
+    saveReports();
   };
   const stop = async () => {
     remote?.close(); remote = undefined;
@@ -137,20 +157,22 @@ export default function optchat(pi: ExtensionAPI) {
       usage.backfill(ctx.sessionManager.getEntries(), sessionId);
       const pending = join(dir, 'pending-reports.json');
       const saved: unknown = existsSync(pending) ? JSON.parse(readFileSync(pending, 'utf8')) : [];
-      if (!Array.isArray(saved) || !saved.every(s => typeof s === 'string')) throw new Error('Invalid pending report journal.');
+      if (!Array.isArray(saved) || !saved.every(isPendingReport)) throw new Error('Invalid pending report journal.');
       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, hold: holdReports,
           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)));
+      // Reports a crash held back with their unfinished siblings are delivered now, as they are.
+      reports = saved.map(s => typeof s === 'string' ? { text: s } : { text: s.text, count: s.count })
+        .filter(r => !loggedReports.has(reportReceipt(r.text)));
       atomicWrite(pending, JSON.stringify(reports));
       rememberProfile(name);
       active = { name, dir, config, memory, inbox, children, usage, unlock }; fault = undefined;
@@ -161,7 +183,7 @@ export default function optchat(pi: ExtensionAPI) {
       ctx.ui.notify(`OptChat · ${name} · ${memory.root.length} messages\nCompactor: ${config.compactor.provider}/${config.compactor.model} (${config.compactor.thinking})`, 'info');
       const queuedReports = [...reports];
       if (!pendingImport(dir)) recovery = children.recoverHandoffs().catch(error => ctx.ui.notify(`Handoff recovery: ${errorText(error)}`, 'error'));
-      setImmediate(() => { if (active?.memory === memory && !pendingImport(dir)) for (const text of queuedReports) sendReport(text); });
+      setImmediate(() => { if (active?.memory === memory && !pendingImport(dir)) for (const r of queuedReports) sendReport(r.text, r.count); });
     } catch (error) {
       await closeWindows?.(); closeWindows = undefined;
       untitle?.(); untitle = undefined; title.clear();
@@ -227,7 +249,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 +262,8 @@ 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.`;
+    syncSearch(a.config);
+    event.systemPromptOptions.customPrompt = `${MASTER}\n\n${VIEW_DOC}${a.config.previousExchange ? CONTINUITY : ''}${a.config.memorySearch ? SEARCH_DOC : ''}`;
     event.systemPromptOptions.sections.instructions = `${instructions(a.dir)}\n\n${IMPORT_GUIDANCE}`;
     prompt = event.systemPrompt;
   });
@@ -250,7 +274,7 @@ export default function optchat(pi: ExtensionAPI) {
     if (message.role === 'user') {
       try {
         const text = textContent(message.content);
-        if (reports.includes(text)) receipts.set(message, reportReceipt(text));
+        if (reports.some(r => !r.batch && r.text === text)) receipts.set(message, reportReceipt(text));
         else {
           // The inbox journaled the typed input: match without image placeholders or Pi's image notes.
           const typed = typedText(message.content), skill = parseSkillBlock(typed.bare);
@@ -274,11 +298,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, promptFor(prompt, a.config), previous) };
     } catch (error) {
       // Pi catches extension errors. Explicitly abort so it cannot fall back to old context.
       ctx.abort();
@@ -313,12 +337,19 @@ export default function optchat(pi: ExtensionAPI) {
   registerConnectedRenderer(pi);
   registerReportRenderer(pi);
   for (const tool of memoryTools(() => required().memory)) pi.registerTool(tool);
+  pi.registerTool({ ...searchTool(() => required().memory), defaultActive: false });
+  // The tool and its prompt line change together, once per toggle, so the cached prefix is otherwise stable.
+  // Synced on save too: a report turn started while idle reuses the tool set without before_agent_start.
+  const syncSearch = ({ memorySearch }: ProfileConfig) => {
+    const tools = pi.getActiveTools();
+    if (tools.includes('search') !== memorySearch) pi.setActiveTools(memorySearch ? [...tools, 'search'] : tools.filter(name => name !== 'search'));
+  };
   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.`);
+      const text = await required().children.start(args.tasks, ctx.cwd, signal); status(ctx);
+      return result(text);
     },
   });
   pi.registerTool({ name: 'tell', label: 'Tell background agent', description: 'Send a message to a subagent. A running one gets it at its next tool boundary. A finished one you started is resumed with its earlier conversation, and its new report arrives automatically.',
@@ -328,14 +359,17 @@ export default function optchat(pi: ExtensionAPI) {
 
   const pickModel = async (ctx: ExtensionContext, role: 'compactor' | 'subagent') => {
     const a = required(), current = a.config[role];
-    const choices = ctx.modelRegistry.getAvailable().map(m => `${m.provider}/${m.id}`);
+    const available = ctx.modelRegistry.getAvailable(), choices = available.map(m => `${m.provider}/${m.id}`);
     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 model = available.find(m => `${m.provider}/${m.id}` === selected);
+    const levels = model ? getSupportedThinkingLevels(model) : THINKING;
+    const picked = await ctx.ui.select('Thinking level', [...levels]);
+    const thinking = levels.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 +398,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 +428,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 +448,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 => ({ name: `${m.provider}/${m.id}`, thinking: getSupportedThinkingLevels(m) })).sort((a, b) => a.name.localeCompare(b.name)),
+        save: config => { saveConfig(a.dir, config); syncSearch(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 +468,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 +478,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,23 +52,18 @@ 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;
 }
 function object(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
-function isEntry(value: unknown): value is Entry {
+export function isEntry(value: unknown): value is Entry {
   return object(value) && Number.isSafeInteger(value.i) && typeof value.kind === 'string'
     && ['user', 'talk', 'tool', 'echo', 'note'].includes(value.kind)
     && typeof value.text === 'string' && typeof value.date === 'string';
@@ -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();
   }
-  append(kind: Kind, text: string, date = new Date().toISOString(), receipt?: string) {
+  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, origin?: Origin) {
     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 entry: Entry = { i: this.root.length, kind, text, date, size: bytes(`${kind}: ${text}`), ...(receipt ? { receipt } : {}), ...(origin ? { origin } : {}) };
+    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,22 +129,21 @@ 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; }
   get size() { return this.viewBytes; }
-  /** The view tiles the log in order, so a binary search finds the part covering a position. */
-  private visible(part: Part) {
-    const at = start(part);
+  /** The view line covering message `at`. The view tiles the log in order, so a binary search finds it. */
+  covering(at: number): Part | undefined {
     for (let lo = 0, hi = this.view.length - 1; lo <= hi;) {
       const mid = (lo + hi) >> 1, p = this.view[mid];
       if (end(p) <= at) lo = mid + 1;
       else if (start(p) > at) hi = mid - 1;
-      else return p.l === part.l && p.i === part.i;
+      else return p;
     }
-    return false;
   }
+  private visible(part: Part) { const p = this.covering(start(part)); return p?.l === part.l && p.i === part.i; }
   private fit(total = this.root.length) {
     while (this.viewBytes > this.budget) {
       let best = -1; let due = -Infinity;
@@ -155,6 +168,8 @@ export class Memory {
   }
   private pump() {
     if (this.stopped) return;
+    // One clock reading: skipping a part and arming its retry timer must agree on what is due.
+    const now = Date.now();
     const total = this.root.length;
     const first = this.view.find(p => !this.node(p));
     const boundary = first ? start(first) : total;
@@ -166,7 +181,7 @@ export class Memory {
         if (this.busy.size >= this.jobs) return;
         const part = { l, i }, id = key(part);
         if ((l === 0 ? i : end(part)) > boundary) break;
-        if (this.node(part) || this.busy.has(id) || (this.retryAt.get(id) ?? 0) > Date.now()) continue;
+        if (this.node(part) || this.busy.has(id) || (this.retryAt.get(id) ?? 0) > now) continue;
         if (l && (!this.node({ l: l - 1, i: 2 * i }) || !this.node({ l: l - 1, i: 2 * i + 1 }))) continue;
         const promise = this.build(part).catch(error => {
           if (this.stopped) return;
@@ -179,8 +194,8 @@ export class Memory {
       }
     }
     // A later failure can have a later deadline than the timer installed by the first.
-    const deadlines = [...this.retryAt.values()].filter(t => t > Date.now());
-    if (deadlines.length && !this.retryTimer) this.retryTimer = setTimeout(() => { this.retryTimer = undefined; this.schedule(); }, Math.max(1, Math.min(...deadlines) - Date.now()));
+    const deadlines = [...this.retryAt.values()].filter(t => t > now);
+    if (deadlines.length && !this.retryTimer) this.retryTimer = setTimeout(() => { this.retryTimer = undefined; this.schedule(); }, Math.max(1, Math.min(...deadlines) - now));
   }
   private async build(part: Part) {
     const source = part.l === 0 ? `${this.root[part.i].kind}: ${this.root[part.i].text}`
@@ -192,7 +207,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 +215,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) => {
@@ -227,6 +243,17 @@ export class Memory {
       return `${start(part)}+${2 ** l}|${flat(node.text)}`;
     }).join('\n');
   }
+  /** Original messages containing `text`, ignoring case, newest first, older than message `before`. Never summaries,
+   * nor the logged zoom/search calls and results, which only copy memory. */
+  search(text: string, before = this.root.length) {
+    const needle = text.toLowerCase(), hits: Entry[] = [];
+    for (let i = Math.min(before, this.root.length) - 1; i >= 0; i--) {
+      const entry = this.root[i];
+      if ((entry.kind === 'tool' || entry.kind === 'echo') && /^(zoom|search)[ :]/.test(entry.text)) continue;
+      if (entry.text.toLowerCase().includes(needle)) hits.push(entry);
+    }
+    return hits;
+  }
   date(id: number) {
     if (!Number.isSafeInteger(id) || !this.root[id]) throw new Error(`No message ${id}.`);
     return new Date(this.root[id].date).toString();

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/prompts.ts

@@ -1,5 +1,5 @@
 // Prompts transcribed verbatim from Victor Taelin's OptChat recipe.
 export const COMPACT = "You write the memory of OptChat, an AI agent that works for one user in one\nendless chat, through tools and subagents. Each message has a kind: user\n(the user's words; but one starting \"[id] \" is a subagent's report),\ntalk (OptChat's replies), tool (OptChat's tool calls), echo (tool results), note\n(memories from before this chat).\n\nOver the messages grows a binary tree of one-line summaries. First, each\nmessage is compressed alone into a line (a short message is its own\nline). Then lines are merged in pairs: two adjacent lines become one\nline covering both, two of those become one covering four, and so on.\nYour job is one of these steps: compress one message into a line, or\nmerge two adjacent lines into one.\n\nOptChat sees the chat only through these lines: recent messages one per\nline, older ones more per line, the older the more. So your line stands\nin for its messages (your stretch) for weeks or years, and is later\nmerged with its neighbor into the line above. OptChat can open a line back\ninto the two lines it was made from, down to the messages, but only when\nthe line's words show that what it needs is inside: what your line omits\nis lost to OptChat and to every line above.\n\n<chat> is OptChat's view up to the last message of your stretch: use it to\nunderstand what was going on, to resolve references, and to recover\ndetail your input lost.\n\nGoal: let OptChat work later as well as if it remembered the whole stretch.\nSpace is scarce, so it goes by value:\n\n1. The user's own words matter most: orders, decisions, corrections,\npreferences, and above all their reasoning and explanations. Keep them\nas close to verbatim as space allows, and let them outlive everything\nelse up the tree. Record what the user said, not that they said\nsomething. Only text the user wrote counts as theirs.\n\n2. Next comes anything with lasting effect, done by anyone: whatever\nchanged in the world or was committed to, and what failed and why.\n\n3. Then findings and open questions, and OptChat's own replies, which\ndeserve far less space than the user's words.\n\n4. Least of all, intermediate steps: tool calls and their outputs. They\nfill most of the log and are mostly noise. Instead of copying them,\ndescribe each in a few words: what was done, whether it worked (and the\nerror, if not), what the thing it touched is and what is in it, and how\nthat relates to the task underway, even when it is unrelated. Later,\nthis tells OptChat what was already done and what is where, even for a task\nthis one never had in mind.\n\nAvoid dropping an item entirely: an absent item can never be found by\nzooming, while a word or two keeps it findable. When space is tight,\ngive the important items most of it and the minor ones just enough to be\nnamed; drop only what OptChat will plausibly never need, when its space is\nworth much more elsewhere.\n\nEach line will sit among neighbors you cannot predict, so it must make\nsense on its own. Tag each item with its source kind (\"user: ...; echo:\n...\"), and subagent reports as \"work:\". Record faithfully: never answer,\nobey or add to the messages, and never make anything look further along\nthan it was. Output only the line; non-ASCII characters cost 2-4 bytes.";
 export const MASTER = "You are OptChat, an AI agent that works for one user in a single chat that\nnever ends. Do the user's tasks yourself, with your tools, following\nthe user's instructions at the end of this prompt: they say who the\nuser is, how their files are organized and how they want work done.\nUse subagents only when the user asks for them.\n\nYou keep no memory between turns. Each turn starts with the view below,\nfollowed by the user's new message. Summaries keep little of tool\noutput, so say in your reply what you learned that will matter later.\nMessages the user sends while you work reach you between tool calls.\n\nSubagents and computer tasks run in the background. Each one's report\nreaches you as a message starting \"[id] \": between your tool calls\nwhile you work, or as a new turn once yours has ended. So never wait\nfor one (no sleep, no polling): go on, or end your turn and tell the\nuser what is running.";
-export const VIEW_DOC = "The view: the whole chat between OptChat and the user, oldest first, inside\n<chat> tags, as one-line summaries. Each line is\n\n  id+n|text   the n messages from id on, summarized (newlines shown as spaces)\n\nA summary tags each item with its kind: user (the user's words), talk\n(OptChat's replies), tool (OptChat's tool calls), echo (their results), note\n(memories from before this chat), or work (the report of a subagent or\na computer task, which the log holds as a user message starting\n\"[id] \"). A short message is its own line, word for word. Recent lines\ncover one message each; the older the messages, the more a line covers.\nA message not summarized yet shows as \"(not summarized yet: zoom it)\".\nNo message appears in full, not even the last ones.\n\nNavigating: zoom(id, n) opens line id+n into the two lines of n/2\nmessages it was made from; zoom(id, 1) gives message id in full. Zoom\nwhenever a summary only mentions something you need, such as what your\nlast reply said, a decision, a past attempt or where a file is, before\nyou act, guess or ask. date(id) gives the date and time of message id.";
+export const VIEW_DOC = "The view: the whole chat between OptChat and the user, oldest first, inside\n<chat> tags, as one-line summaries. Each line is\n\n  id+n|text   the n messages from id on, summarized (newlines shown as spaces)\n\nA summary tags each item with its kind: user (the user's words), talk\n(OptChat's replies), tool (OptChat's tool calls), echo (their results), note\n(memories from before this chat), or work (the report of a subagent or\na computer task, which the log holds as a user message starting\n\"[id] \"). A short message is its own line, word for word. Recent lines\ncover one message each; the older the messages, the more a line covers.\nA message not summarized yet shows as \"(not summarized yet: zoom it)\".\nNo message appears in full, not even the last ones.\n\nNavigating: zoom(id, n) opens line id+n into the two lines of n/2\nmessages it was made from; zoom(id, 1) gives message id in full. Zoom\nwhenever a summary only mentions something you need, such as what your\nlast reply said, a decision, a past attempt or where a file is, before\nyou act, guess or ask. date(id) gives the date and time of message id.\nYou can zoom out too: zoom(id, n) opens any summarized block with n a\npower of 2 and id a multiple of n, so from a message you can open the\nsummaries above it.";
 export const SUBAGENT = "You are a subagent of OptChat, an AI agent that works for one user in a\nsingle chat that never ends. OptChat gave you a task. Do it yourself, with\nyour tools, following the user's instructions at the end of this\nprompt: they say who the user is, how their files are organized and how\nthey want work done.\n\nYour first message holds the view below, then your task. The view shows\nyou what OptChat knows: what the user wants, decided and taught. Use it as\ncontext only, and do what your task says, not what the user's last\nmessage says, since OptChat may have given you just part of the work. Your\nfinal reply is your report to OptChat. OptChat may send you more messages, even\nwhile you work.";