pi-optchat 0.6.7 → 0.6.8

package/src/settings.ts

@@ -0,0 +1,42 @@
+import { NODE } from './memory.ts';
+
+/** Per-profile choices where OptChat departs from Victor's recipe. Each default is the recipe's behaviour unless noted. */
+export const SETTINGS = {
+  subagentLevels: { kind: 'number', label: 'Subagent levels', default: 1, min: 1, unit: '',
+    description: 'How many levels of subagents. 1: only the main agent starts subagents, as in Victor\'s recipe. 2: those subagents may start their own, and so on.',
+    applies: 'Applies to subagents started or resumed after this.' },
+  maxAgents: { kind: 'number', label: 'Max active agents', default: 8, min: 1, unit: '',
+    description: 'Subagents running at once in this profile, all levels together. It also caps how deep a chain can go.',
+    applies: 'Applies to the next spawn.' },
+  previousExchange: { kind: 'toggle', label: 'Previous exchange', default: true,
+    description: 'Send your last request and its answer in full with the next turn, so a follow-up reads the exact wording. Off: memory view only, as in Victor\'s recipe. On by default: a study found it costs little and saves zooms.',
+    applies: 'Applies from the next turn.' },
+  previousExchangeKB: { kind: 'number', label: 'Previous exchange limit', default: 16, min: 1, unit: 'KB',
+    description: 'A larger last exchange, usually a big paste, is left out and the model zooms into memory instead.',
+    applies: 'Applies from the next turn.' },
+  summaryAcceptBytes: { kind: 'number', label: 'Summary size tolerance', default: NODE * 1.25, min: NODE, unit: 'bytes',
+    description: `The compactor is always asked for ${NODE}-byte lines; a longer line up to this size is kept instead of retried. ${NODE}: strict, as in Victor's recipe. The default saves retries for a little more view space.`,
+    applies: 'Applies to the next summary.' },
+} as const;
+
+export type SettingKey = keyof typeof SETTINGS;
+export type Settings = { -readonly [K in SettingKey]: (typeof SETTINGS)[K]['default'] extends boolean ? boolean : number };
+export type NumberKey = { [K in SettingKey]: Settings[K] extends number ? K : never }[SettingKey];
+export const SETTING_KEYS = Object.keys(SETTINGS) as SettingKey[];
+export const isNumberKey = (key: SettingKey): key is NumberKey => SETTINGS[key].kind === 'number';
+
+/** Why a value can't be used, or undefined if it can. Numbers are whole and at least their minimum. */
+export function invalid(key: SettingKey, value: unknown) {
+  if (isNumberKey(key)) { const { label, min } = SETTINGS[key]; return Number.isSafeInteger(value) && Number(value) >= min ? undefined : `${label} must be a whole number of ${min} or more.`; }
+  return typeof value === 'boolean' ? undefined : `${SETTINGS[key].label} must be true or false.`;
+}
+
+/** Missing keys take their defaults, so config files written before a setting existed keep working. */
+export function readSettings(value: Record<string, unknown>): Settings {
+  return Object.fromEntries(SETTING_KEYS.map(key => {
+    const raw = Object.hasOwn(value, key) ? value[key] : SETTINGS[key].default, problem = invalid(key, raw);
+    if (problem) throw new Error(problem);
+    return [key, raw];
+  })) as Settings;
+}
+export const DEFAULT_SETTINGS = readSettings({});

package/src/transcript.ts

@@ -1,8 +1,9 @@
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
 import { getCurrentSystemMessage, type SystemMessage, type UserMessage } from '@earendil-works/pi-ai';
-import { cap, type Memory } from './memory.ts';
+import { CAP, cap, type Memory } from './memory.ts';
 import { record } from './cache.ts';
+import { DEFAULT_SETTINGS } from './settings.ts';
 
 export const RUN_BOUNDARY = 'optchat.run';
 /** Subagent traffic to the main agent: a custom message on screen, a plain user message to the model and memory. */
@@ -44,7 +45,7 @@ export function logMessage(memory: Memory, message: AgentMessage, receipt?: stri
 export function boundedMessage(message: AgentMessage): AgentMessage {
   if (message.role !== 'toolResult') return message;
   const text = message.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
-  if (text.length <= 30_000) return message;
+  if (text.length <= CAP) return message;
   return { ...message, content: [{ type: 'text', text: cap(text) }, ...message.content.filter(c => c.type === 'image')] };
 }
 /** The caller supplies a single settled run, including any steering after text-only replies. */
@@ -63,8 +64,18 @@ function completedExchange(history: readonly AgentMessage[]) {
   return [...requests, { ...answer, content }];
 }
 
-/** Recover the latest successful run on this branch, skipping failed and unfinished runs. */
-export function previousExchange(branch: readonly SessionEntry[]) {
+/** Default limit in bytes of text (16 KB, ~4,000 tokens). Most exchanges are 1-7 KB; a larger one, usually a big paste, is
+ * left out entirely and the model falls back to its summaries in the memory view, zooming for the full text if it needs it. */
+export const PREVIOUS_EXCHANGE = DEFAULT_SETTINGS.previousExchangeKB * 1000;
+
+/** The latest successful run on this branch, skipping failed and unfinished runs; none if it is over `limit` bytes. */
+export function previousExchange(branch: readonly SessionEntry[], limit = PREVIOUS_EXCHANGE) {
+  const exchange = latestExchange(branch);
+  const bytes = exchange.reduce((sum, message) => sum + Buffer.byteLength(textContent(message.content)), 0);
+  return bytes <= limit ? exchange : [];
+}
+
+function latestExchange(branch: readonly SessionEntry[]) {
   let end = -1;
   let legacyEnd = branch.length;
   const messages = (entries: readonly SessionEntry[]) => entries.flatMap(entry => entry.type === 'message' ? [asUser(entry.message)] : entry.type === 'custom_message' && entry.customType === REPORT_TYPE ? [asUser({ role: 'custom', customType: entry.customType, content: entry.content, display: entry.display, timestamp: Date.parse(entry.timestamp) })] : []);

package/src/usage.ts

@@ -36,27 +36,27 @@ export function addUsage(total: Usage, usage: Usage) {
 /** One profile's ledger. Stable message IDs make resume/backfill idempotent. */
 export class UsageLedger {
   readonly entries: UsageEntry[] = [];
-  readonly warnings: string[] = [];
+  private invalid = 0;
   private readonly ids = new Set<string>();
   private readonly cursors = new Map<string, number>();
   private readonly file: string;
   constructor(directory: string) {
     this.file = join(directory, 'usage.jsonl');
-    let invalid = 0;
     const contents = existsSync(this.file) ? readFileSync(this.file, 'utf8') : '';
     for (const line of contents.split('\n')) {
       if (!line.trim()) continue;
       try {
         const entry: unknown = JSON.parse(line);
-        if (!validEntry(entry)) { invalid++; continue; }
+        if (!validEntry(entry)) { this.invalid++; continue; }
         if (entry.id && this.ids.has(entry.id)) continue;
         this.entries.push(entry); if (entry.id) this.ids.add(entry.id);
-      } catch { invalid++; }
+      } catch { this.invalid++; }
     }
-    if (invalid) this.warnings.push(`${invalid} unreadable usage records excluded; totals may be incomplete.`);
     if (contents && !contents.endsWith('\n')) appendFileSync(this.file, '\n');
   }
+  get warnings() { return this.invalid ? [`${this.invalid} unreadable usage records excluded; totals may be incomplete.`] : []; }
   add(entry: UsageEntry) {
+    if (!validEntry(entry)) { this.invalid++; return; }
     if (entry.id && this.ids.has(entry.id)) return;
     appendJson(this.file, entry);
     this.entries.push(entry); if (entry.id) this.ids.add(entry.id);
@@ -86,7 +86,7 @@ export class UsageLedger {
   select(range: UsageRange, session: string, now = Date.now()) {
     const today = new Date(now); today.setHours(0, 0, 0, 0);
     const since = range === 'Last hour' ? now - 3600_000 : range === 'Today' ? today.getTime() : range === 'Last 7 days' ? now - 7 * 86400_000 : 0;
-    return this.entries.filter(e => range === 'This session' ? e.session === session : Date.parse(e.date) >= since && Date.parse(e.date) <= now);
+    return this.entries.filter(e => range === 'This session' ? e.session === session : range === 'All time' || (Date.parse(e.date) >= since && Date.parse(e.date) <= now));
   }
 }
 

package/src/window-bridge.ts

@@ -1,9 +1,9 @@
-import { chmodSync, existsSync, unlinkSync } from 'node:fs';
+import { chmodSync } from 'node:fs';
 import { createConnection, createServer, type Socket } from 'node:net';
 import type { Children } from './agents.ts';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { record } from './cache.ts';
-import { profileSocket } from './profiles.ts';
+import { checkSocketPath, profileSocket, removeStaleSocket } from './profiles.ts';
 import { textContent } from './transcript.ts';
 import { isActiveRun } from './runs.ts';
 
@@ -83,8 +83,8 @@ function wire(socket: Socket, receive: (frame: Frame) => void) {
 /** Call only while holding the profile lock. The owner hosts every child session. */
 export async function serveWindows(directory: string, children: Children, available: () => boolean,
   report: (text: string) => Promise<void>) {
-  const path = profileSocket(directory, 'windows');
-  if (existsSync(path)) unlinkSync(path); // A previous owner can no longer hold the profile lock.
+  const path = profileSocket(directory, 'windows'); checkSocketPath(path);
+  removeStaleSocket(path); // A previous owner can no longer hold the profile lock.
   const connections = new Set<Socket>();
   const work = new Set<Promise<void>>();
   let closing = false;