pi2web 0.2.6 → 0.2.12

package/dist/http/agent-routes.js

@@ -81,6 +81,8 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
             return send(200, {
                 data: await ctx.agents.timeline(id, Number(u.searchParams.get('limit') ?? 50), u.searchParams.get('before') ?? undefined)
             });
+        if (req.method === 'GET' && parts[4] === 'performance' && parts.length === 5)
+            return send(200, { data: await ctx.agents.performance(id) });
         // /agents/:id/sessions/:sessionId/items/:itemId — items never change, and the session is part of the
         // URL so a cached body is never served for another one: let the browser keep it for good.
         if (req.method === 'GET' && parts[4] === 'sessions' && parts[6] === 'items' && parts.length === 8) {
@@ -90,6 +92,14 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
         }
         if (req.method === 'GET' && parts[4] === 'system-prompt')
             return send(200, { data: await ctx.agents.systemPrompt(id) });
+        if (req.method === 'POST' && parts[4] === 'system-prompt') {
+            const b = await ctx.body();
+            if (b.templateId !== undefined && typeof b.templateId !== 'string')
+                throw Object.assign(new Error('templateId must be a string'), { code: 'INVALID_REQUEST' });
+            const template = b.templateId ? ctx.templates.snapshot(b.templateId) : undefined;
+            const record = await ctx.agents.setTemplate(id, template, candidate => ctx.metadata.commitAgentTemplate(candidate));
+            return send(200, { data: { template: record.template ?? null } });
+        }
         if (req.method === 'GET' && parts[4] === 'capabilities')
             return send(200, { data: await ctx.agents.capabilities(id) });
         if (req.method === 'GET' && parts[4] === 'session')
@@ -145,6 +155,14 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
             ctx.metadata.scheduleAgent(ctx.agents.get(id).record);
             return send(200, { data: result });
         }
+        // Safe pause: POST asks the running turn to stop before its next model request; DELETE withdraws that.
+        if (parts[4] === 'pause' && (req.method === 'POST' || req.method === 'DELETE')) {
+            if (req.method === 'POST')
+                await ctx.agents.requestPause(id);
+            else
+                await ctx.agents.cancelPause(id);
+            return send(200, { data: { success: true } });
+        }
         if (req.method === 'POST' && parts[4] === 'bash-abort') {
             await ctx.agents.abortBash(id);
             return send(200, { data: { aborted: true } });
@@ -154,6 +172,15 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
                 return send(200, { data: await ctx.agents.queue(id) });
             if (req.method === 'DELETE')
                 return send(200, { data: await ctx.agents.clearQueue(id) });
+            if (req.method === 'POST' && parts[5] === 'move') {
+                const { from, index, expected } = await ctx.body();
+                if ((from !== 'steering' && from !== 'followUp') ||
+                    !Number.isSafeInteger(index) ||
+                    index < 0 ||
+                    typeof expected !== 'string')
+                    throw Object.assign(new Error('from, index and expected are required'), { code: 'INVALID_REQUEST' });
+                return send(200, { data: await ctx.agents.moveQueue(id, from, index, expected) });
+            }
         }
         if (parts[4] === 'mcp') {
             const cwd = ctx.agents.get(id).record.cwd;
@@ -172,10 +199,17 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
             return send(200, { data: { success: true } });
         }
         if (req.method === 'POST' && parts[4] === 'transcribe') {
+            ctx.agents.get(id);
+            const mime = String(req.headers['content-type'] ?? 'audio/webm').split(';')[0];
+            if (ctx.sottoStt.getSettings().enabled) {
+                if (mime !== 'application/octet-stream')
+                    throw Object.assign(new Error('Sotto requires 16 kHz float32 PCM'), { code: 'INVALID_REQUEST' });
+                const audio = await ctx.binaryBody();
+                return send(200, { data: await ctx.sottoStt.transcribe(audio) });
+            }
             if (!ctx.voice)
                 throw Object.assign(new Error('Voice service is disabled'), { code: 'VOICE_DISABLED' });
-            ctx.agents.get(id);
-            const audio = await ctx.binaryBody(), mime = String(req.headers['content-type'] ?? 'audio/webm').split(';')[0], filename = String(req.headers['x-audio-filename'] ?? 'recording.webm');
+            const audio = await ctx.binaryBody(), filename = String(req.headers['x-audio-filename'] ?? 'recording.webm');
             return send(200, { data: await ctx.voice.transcribe(audio, mime, filename) });
         }
         if (req.method === 'POST' && ['prompt', 'steer', 'follow-up', 'abort'].includes(parts[4])) {
@@ -184,7 +218,7 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
                 ctx.voice?.recordUserPrompt(id, String(b.message ?? ''));
                 ctx.sessionNamer?.recordUserPrompt(id, String(b.message ?? ''));
             }
-            const disposition = await ctx.agents.command(id, parts[4], b.message ?? '');
+            const disposition = await ctx.agents.submitCommand(id, parts[4], b.message ?? '');
             const record = ctx.agents.get(id).record;
             ctx.metadata.scheduleAgent(record);
             if (parts[4] === 'prompt')

package/dist/http/utils.js

@@ -35,7 +35,11 @@ export function errorStatus(code) {
         return 403;
     if (code === 'FILE_TOO_LARGE' || code === 'REQUEST_TOO_LARGE')
         return 413;
-    if (code === 'VOICE_DISABLED' || code === 'VOICE_STT_DISABLED' || code === 'MAIL_NOTIFICATIONS_DISABLED')
+    if (code === 'VOICE_DISABLED' ||
+        code === 'VOICE_STT_DISABLED' ||
+        code === 'SOTTO_DISABLED' ||
+        code === 'SOTTO_UNAVAILABLE' ||
+        code === 'MAIL_NOTIFICATIONS_DISABLED')
         return 503;
     if (code?.endsWith('NOT_FOUND'))
         return 404;

package/dist/http/web-assets.js

@@ -10,6 +10,7 @@ const webFiles = {
     '/': { file: 'index.html', type: 'text/html; charset=utf-8' },
     '/index.html': { file: 'index.html', type: 'text/html; charset=utf-8' },
     '/app.js': { file: 'app.js', type: 'text/javascript; charset=utf-8' },
+    '/voice-pcm.js': { file: 'voice-pcm.js', type: 'text/javascript; charset=utf-8' },
     '/backend-state.js': { file: 'backend-state.js', type: 'text/javascript; charset=utf-8' },
     '/hid-keyboard.js': { file: 'hid-keyboard.js', type: 'text/javascript; charset=utf-8' },
     '/activity-view.js': { file: 'activity-view.js', type: 'text/javascript; charset=utf-8' },

package/dist/mail-notifier.js

@@ -76,8 +76,13 @@ export class MailNotifier {
         this.lastAssistant.delete(agentId);
         if (!this.settings.enabled)
             return;
-        // Pi 0.99+ reports whether the run was cancelled; a cancelled run is not a completed task.
-        this.queue.push({ agentId, finalOutput, context, aborted: event.aborted === true });
+        // Pi 0.99+ reports whether the run was cancelled; a cancelled or safely paused run is not a completed task.
+        this.queue.push({
+            agentId,
+            finalOutput,
+            context,
+            aborted: event.aborted === true || event.paused === true
+        });
         if (!this.timer)
             this.scheduleFlush();
     }

package/dist/metadata-store.js

@@ -176,7 +176,8 @@ export class MetadataStore {
     writeAgent(record, archivedAt) {
         this.database
             .prepare(
-        // `template` is written on insert only: an Agent's system prompt template never changes.
+        // Ordinary state/index writes must not overwrite the conversation's template snapshot.
+        // Only commitAgentTemplate may change it after creation.
         `INSERT INTO agents(id,workspace_id,session_id,session_file,session_name,cwd,status,profile,template,created_at,last_active_at,archived_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,session_id=excluded.session_id,session_file=excluded.session_file,session_name=excluded.session_name,cwd=excluded.cwd,status=excluded.status,profile=excluded.profile,last_active_at=excluded.last_active_at,archived_at=excluded.archived_at`)
             .run(record.agentId, record.workspaceId, record.sessionId, record.sessionFile ?? null, record.sessionName ?? null, record.cwd, record.status, record.profile ?? 'default', record.template ? JSON.stringify(record.template) : null, asTime(record.createdAt), asTime(record.lastActiveAt), archivedAt);
     }
@@ -186,6 +187,18 @@ export class MetadataStore {
         this.pendingAgents.delete(record.agentId);
         this.writeAgent(record, null);
     }
+    /** Commit the validated pre-conversation choice and its session identity together. */
+    commitAgentTemplate(record) {
+        this.database.transaction(() => {
+            const updated = this.database
+                .prepare('UPDATE agents SET template=? WHERE id=? AND archived_at IS NULL')
+                .run(record.template ? JSON.stringify(record.template) : null, record.agentId);
+            if (!updated.changes)
+                throw Object.assign(new Error('Agent not found'), { code: 'AGENT_NOT_FOUND' });
+            this.writeAgent(record, null);
+        })();
+        this.pendingAgents.delete(record.agentId);
+    }
     scheduleAgent(record) {
         if (this.archivedAgents.has(record.agentId))
             return;

package/dist/safe-pause.js

@@ -0,0 +1,100 @@
+const error = (message, code) => Object.assign(new Error(message), { code });
+/**
+ * Stops a Pi session before the conversation advances: no further model response or tool call
+ * once the pause is reached. Tools that are running finish and their results are recorded first,
+ * so the transcript ends with tool results (or the user's message) and nothing is lost.
+ *
+ * A Pi run asks the model again through exactly two entries, and each one is gated:
+ * - Gate A, the agent loop's `finishTurn`: the next turn inside the loop.
+ * - Gate B, `agent.continue()`: every continuation the session's run controller starts after the
+ *   loop ends, i.e. auto-retry, overflow-compaction retry, queued messages and extension
+ *   `agent_before_settle` continuations.
+ * Neither gate depends on event timing. Housekeeping model calls that do not advance the
+ * conversation (compaction summaries, prompt-cache warming) are not gated.
+ */
+export class SafePause {
+    session;
+    emit;
+    state = 'none';
+    /** Set for the agent_settled of a run that ended at the safe point. */
+    settledPaused = false;
+    constructor(session, emit) {
+        this.session = session;
+        this.emit = emit;
+        const agent = session.agent;
+        // Gate A. AgentSession installed its own finishTurn (extension turn_end boundaries); run it first.
+        const finishTurn = agent.finishTurn;
+        agent.finishTurn = async (turn, signal) => {
+            const decision = (await finishTurn?.(turn, signal)) ?? undefined;
+            if (this.state === 'none' || decision?.action === 'end')
+                return decision;
+            // An error or aborted turn ends the loop anyway; a retry has to pass gate B.
+            if (turn.message.stopReason === 'error' || turn.message.stopReason === 'aborted')
+                return decision;
+            // A final answer with nothing queued and no continuation request ends the loop by itself.
+            const wouldContinue = turn.toolResults.length > 0 || decision?.action === 'continue' || agent.hasQueuedMessages();
+            if (!wouldContinue)
+                return decision;
+            this.reach();
+            return { action: 'end' };
+        };
+        // Gate B. The run controller calls agent.continue() only after the previous loop has fully
+        // ended, so no request is in flight and no tool is running here. Instead of continuing, ask
+        // the session to stop its run: abort() first sets the controller's stop flag synchronously,
+        // which ends the run before another request. Queued messages stay queued for the next prompt.
+        const resume = agent.continue.bind(agent);
+        agent.continue = async () => {
+            if (this.state === 'none')
+                return resume();
+            this.reach();
+            // abort() waits for the run to settle, which happens only after this call returns.
+            void session.abort().catch(() => { });
+        };
+        session.subscribe(event => {
+            if (event.type !== 'agent_settled') {
+                this.settledPaused = false;
+                return;
+            }
+            const state = this.state;
+            this.state = 'none';
+            this.settledPaused = state === 'reached';
+            if (state === 'reached')
+                this.emit('paused');
+            else if (state === 'requested')
+                this.emit('finished');
+        });
+    }
+    /** Whether the agent_settled being delivered ends a run that stopped at the safe point. */
+    get pausedRunSettled() {
+        return this.settledPaused;
+    }
+    async request() {
+        if (!this.session.isStreaming)
+            throw error('Agent is not running', 'AGENT_NOT_RUNNING');
+        if (this.state !== 'none')
+            return;
+        this.state = 'requested';
+        this.emit('requested');
+        // During a retry backoff the next step is the retried model request. isRetrying means Pi has
+        // created the retry's abort controller, so cancelling it now takes effect; the run then winds
+        // down through the controller, and any continuation it still attempts meets gate B.
+        if (this.session.isRetrying) {
+            this.reach();
+            this.session.abortRetry();
+        }
+    }
+    async cancel() {
+        if (this.state === 'reached')
+            throw error('The run has already stopped at the safe point', 'PAUSE_ALREADY_REACHED');
+        if (this.state !== 'requested')
+            return;
+        this.state = 'none';
+        this.emit('cancelled');
+    }
+    reach() {
+        if (this.state === 'reached')
+            return;
+        this.state = 'reached';
+        this.emit('reached');
+    }
+}

package/dist/sdk-backend.js

@@ -1,6 +1,8 @@
 import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } from '@earendil-works/pi-coding-agent';
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
+import { PERFORMANCE_ENTRY, SessionPerformanceTracker } from './session-performance.js';
+import { SafePause } from './safe-pause.js';
 import { createCollabExtension } from './collab/pi-extension.js';
 /** Older Pi builds resolved steer()/followUp() with undefined; treat anything but an explicit `handled` as queued. */
 const normalizeDisposition = (value) => value === 'handled' ? 'handled' : 'queued';
@@ -11,11 +13,22 @@ export class SdkBackend {
     cwd;
     disposed = false;
     events = new EventEmitter();
+    safePause;
     pendingUi = new Map();
     constructor(session, agentId, cwd) {
         this.session = session;
         this.agentId = agentId;
         this.cwd = cwd;
+        const performance = new SessionPerformanceTracker(run => this.session.sessionManager.appendCustomEntry(PERFORMANCE_ENTRY, run));
+        this.session.subscribe(event => performance.apply(event));
+        this.safePause = new SafePause(session, state => this.events.emit('event', { type: 'safe_pause', state }));
+    }
+    /** Ask the running turn to stop before its next model request (see SafePause). */
+    requestPause() {
+        return this.safePause.request();
+    }
+    cancelPause() {
+        return this.safePause.cancel();
     }
     static async create(agentId, cwd, sessionFile, profile = 'default', collabBridge, options = {}) {
         const sessionManager = sessionFile ? SessionManager.open(sessionFile) : SessionManager.create(cwd);
@@ -53,14 +66,18 @@ export class SdkBackend {
             session.dispose();
             throw Object.assign(new Error(modelFallbackMessage), { code: 'PI_MODEL_UNAVAILABLE' });
         }
+        return SdkBackend.fromSession(session, agentId, cwd);
+    }
+    /** Wrap an existing Pi session; tests use it to drive a real session with a scripted model. */
+    static async fromSession(session, agentId, cwd) {
         const backend = new SdkBackend(session, agentId, cwd);
         await session.bindExtensions({ uiContext: backend.extensionUi() });
         return backend;
     }
     // Slash commands, skills and prompt templates are expanded by prompt() itself (expandPromptTemplates defaults to true),
     // so `/name args` typed in the web composer behaves exactly like the Pi TUI.
-    prompt(message) {
-        return this.session.prompt(message);
+    prompt(message, onAccepted) {
+        return this.session.prompt(message, { preflightResult: onAccepted });
     }
     // Since pi 0.99 steer()/followUp() report whether the message reached the running turn (`handled`)
     // or waits for it (`queued`); the web composer shows that difference instead of guessing.
@@ -81,6 +98,31 @@ export class SdkBackend {
         const cleared = this.session.clearQueue();
         return { steering: [...cleared.steering], followUp: [...cleared.followUp] };
     }
+    async moveQueue(from, index, expected) {
+        const before = {
+            steering: [...this.session.getSteeringMessages()],
+            followUp: [...this.session.getFollowUpMessages()]
+        };
+        if (!this.session.isStreaming || before[from][index] !== expected)
+            throw Object.assign(new Error('Queued message has changed or already been consumed'), {
+                code: 'QUEUE_CHANGED'
+            });
+        const to = from === 'steering' ? 'followUp' : 'steering';
+        before[from].splice(index, 1);
+        before[to].push(expected);
+        if ([...before.steering, ...before.followUp].some(text => text.startsWith('/')))
+            throw Object.assign(new Error('Slash commands cannot be moved safely'), { code: 'QUEUE_CHANGED' });
+        // Pi exposes clearQueue(), but no per-message move. Clear and requeue in the same JS turn:
+        // steer()/followUp() enqueue synchronously before their promises settle. No model callback can
+        // drain the half-updated queue between these calls. Never replace a stale queue by index alone.
+        this.session.clearQueue();
+        const pending = [
+            ...before.steering.map(text => this.session.steer(text)),
+            ...before.followUp.map(text => this.session.followUp(text))
+        ];
+        await Promise.all(pending);
+        return this.getQueue();
+    }
     abort() {
         return this.session.abort();
     }
@@ -239,7 +281,10 @@ export class SdkBackend {
             throw Object.assign(new Error('Extension UI request not found'), { code: 'EXTENSION_REQUEST_NOT_FOUND' });
     }
     subscribe(listener) {
-        const fromSession = (event) => listener(event);
+        // A paused run settles like a finished one; notifications must not report it as completed.
+        const fromSession = (event) => listener(event.type === 'agent_settled' && this.safePause.pausedRunSettled
+            ? { ...event, paused: true }
+            : event);
         const unsubscribe = this.session.subscribe(fromSession);
         this.events.on('event', listener);
         return () => {

package/dist/server.js

@@ -8,6 +8,7 @@ import { AgentManager } from './agents.js';
 import { createSdkBackend } from './sdk-backend.js';
 import { TerminalManager } from './terminals.js';
 import { MetadataStore } from './metadata-store.js';
+import { SottoSttService } from './sotto-stt.js';
 import { CollabHub } from './collab/hub.js';
 import { CollabStore } from './collab/store.js';
 import { CollabRouter } from './collab/routes.js';
@@ -54,6 +55,7 @@ export class RemotePiServer {
     sessionIndexJobs = new Map();
     agentIndexJobs = new Map();
     voice;
+    sottoStt;
     sessionNamer;
     mailNotifier;
     loginLimiter = new LoginLimiter();
@@ -64,6 +66,7 @@ export class RemotePiServer {
         this.dataDir = options.dataDir ?? defaultDataDir();
         this.auth = new AuthStore(this.dataDir);
         this.metadata = new MetadataStore(this.dataDir);
+        this.sottoStt = new SottoSttService(this.metadata);
         this.templates = new AgentTemplateStore(path.join(this.dataDir, AGENT_TEMPLATES_DIR));
         this.workspaces = options.workspaces ?? new WorkspaceStore();
         this.voice = options.voice;
@@ -115,6 +118,7 @@ export class RemotePiServer {
             console.warn('WARNING: --allow-insecure-no-auth disables loopback bind and Host/Origin restrictions. Anyone who can reach this server, including through a web page, can access workspaces and control agents and terminals without a pairing code. Use only on a trusted, access-controlled network.');
         const first = this.noAuth ? {} : await this.auth.init();
         this.metadata.init();
+        this.sottoStt.load();
         this.collab.init();
         this.unsubscribeCollab = this.collab.subscribe(event => this.collabNotification(event));
         this.collabStallTimer = setInterval(() => {
@@ -343,7 +347,10 @@ export class RemotePiServer {
                 .map(x => x.trim())
                 .find(x => x.startsWith('access-token.'))
                 ?.slice(13);
-        const pathname = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`).pathname, isSocket = pathname === '/api/v1/ws' || /^\/api\/v1\/terminals\/[^/]+\/ws$/.test(pathname);
+        const pathname = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`).pathname, voiceMatch = pathname.match(/^\/api\/v1\/agents\/([^/]+)\/transcribe\/ws$/), isTranscription = pathname === '/api/v1/transcribe/ws', isSocket = pathname === '/api/v1/ws' ||
+            /^\/api\/v1\/terminals\/[^/]+\/ws$/.test(pathname) ||
+            !!voiceMatch ||
+            isTranscription;
         if (!isSocket) {
             socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
             socket.destroy();
@@ -374,6 +381,24 @@ export class RemotePiServer {
             return;
         }
         this.loginLimiter.clear(key);
+        if (voiceMatch || isTranscription) {
+            try {
+                if (voiceMatch)
+                    this.agents.get(decodeURIComponent(voiceMatch[1]));
+                this.sottoStt.streamUrl();
+            }
+            catch {
+                socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            this.wss.handleUpgrade(req, socket, head, ws => {
+                this.clients.add(ws);
+                ws.on('close', () => this.clients.delete(ws));
+                this.sottoStt.stream(ws);
+            });
+            return;
+        }
         this.wss.handleUpgrade(req, socket, head, ws => this.wss.emit('connection', ws, req));
     }
     clientKey(req) {
@@ -575,12 +600,36 @@ export class RemotePiServer {
                         terminalCount: this.terminals.list().length,
                         webSocketConnections: this.clients.size,
                         voiceEnabled: !!this.voice,
-                        voiceCapabilities: this.voice?.capabilities() ?? { tts: false, stt: false },
+                        voiceCapabilities: {
+                            tts: this.voice?.capabilities().tts ?? false,
+                            stt: (this.voice?.capabilities().stt ?? false) || this.sottoStt.getSettings().enabled
+                        },
+                        sottoStt: this.sottoStt.getSettings(),
                         sessionNamingEnabled: !!this.sessionNamer,
                         mailNotificationsConfigured: !!this.mailNotifier,
                         mailNotificationsEnabled: this.mailNotifier?.getSettings().enabled ?? false
                     }
                 });
+            if (u.pathname === '/api/v1/sotto-stt') {
+                if (req.method === 'GET')
+                    return json(res, 200, { data: this.sottoStt.getSettings() });
+                if (req.method === 'PUT')
+                    return json(res, 200, { data: await this.sottoStt.update(await readJsonBody(req)) });
+            }
+            if (req.method === 'POST' && u.pathname === '/api/v1/transcribe') {
+                const mime = String(req.headers['content-type'] ?? 'audio/webm').split(';')[0];
+                if (this.sottoStt.getSettings().enabled) {
+                    if (mime !== 'application/octet-stream')
+                        throw Object.assign(new Error('Sotto requires 16 kHz float32 PCM'), { code: 'INVALID_REQUEST' });
+                    return json(res, 200, { data: await this.sottoStt.transcribe(await readBinaryBody(req)) });
+                }
+                if (!this.voice)
+                    throw Object.assign(new Error('Voice service is disabled'), { code: 'VOICE_DISABLED' });
+                const filename = String(req.headers['x-audio-filename'] ?? 'recording.webm');
+                return json(res, 200, {
+                    data: await this.voice.transcribe(await readBinaryBody(req), mime, filename)
+                });
+            }
             if (await handleMailSettingsRoutes({ mailNotifier: this.mailNotifier, metadata: this.metadata }, req, res, u))
                 return;
             const workspaceContext = {
@@ -599,6 +648,7 @@ export class RemotePiServer {
                 metadata: this.metadata,
                 workspaces: this.workspaces,
                 voice: this.voice,
+                sottoStt: this.sottoStt,
                 sessionNamer: this.sessionNamer,
                 ensureSessionIndex: (workspace, cwd, force) => this.ensureSessionIndex(workspace, cwd, force),
                 indexAgentSession: (agentId) => this.indexAgentSession(agentId),

package/dist/session-performance.js

@@ -0,0 +1,139 @@
+export const PERFORMANCE_ENTRY = 'pi2web.performance.v1';
+/** Wall-clock spans, collected on the host running Pi. Parallel tool spans deliberately overlap. */
+export class SessionPerformanceTracker {
+    save;
+    now;
+    run = null;
+    model = null;
+    tools = new Map();
+    other = null;
+    constructor(save, now = Date.now) {
+        this.save = save;
+        this.now = now;
+    }
+    finish(span, at) {
+        if (span)
+            span.end = at;
+    }
+    span(kind, at, name) {
+        const span = { kind, start: at, end: at };
+        if (name)
+            span.name = name;
+        this.run.spans.push(span);
+        return span;
+    }
+    apply(event) {
+        const at = this.now(), e = event;
+        if (event.type === 'agent_start' && !this.run)
+            this.run = { start: at, spans: [] };
+        if (!this.run)
+            return;
+        switch (event.type) {
+            case 'turn_start':
+                if (this.other?.kind === 'retry') {
+                    this.finish(this.other, at);
+                    this.other = null;
+                }
+                this.finish(this.model, at);
+                this.model = this.span('model', at);
+                break;
+            case 'message_update':
+                if (this.model && this.model.firstResponse === undefined)
+                    this.model.firstResponse = at;
+                break;
+            case 'message_end':
+                if (e.message?.role === 'assistant') {
+                    if (this.model && Number.isFinite(e.message.usage?.output) && e.message.usage.output >= 0)
+                        this.model.outputTokens = e.message.usage.output;
+                    this.finish(this.model, at);
+                    this.model = null;
+                }
+                break;
+            case 'tool_execution_start':
+                if (e.parentToolCallId)
+                    break; // nested tools are included in their parent's wall-clock span
+                if (this.model) {
+                    this.finish(this.model, at);
+                    this.model = null;
+                }
+                if (e.toolCallId) {
+                    const span = this.span('tool', at, String(e.toolName ?? 'tool'));
+                    span.toolCallId = String(e.toolCallId);
+                    this.tools.set(span.toolCallId, span);
+                }
+                break;
+            case 'tool_execution_end': {
+                const span = this.tools.get(String(e.toolCallId));
+                if (span) {
+                    this.finish(span, at);
+                    this.tools.delete(String(e.toolCallId));
+                }
+                break;
+            }
+            case 'compaction_start':
+            case 'auto_retry_start':
+                this.finish(this.other, at);
+                this.other = this.span(event.type === 'compaction_start' ? 'compaction' : 'retry', at);
+                break;
+            case 'compaction_end':
+            case 'auto_retry_end':
+                this.finish(this.other, at);
+                this.other = null;
+                if (event.type === 'auto_retry_end' && e.finalError === 'Retry cancelled')
+                    this.run.incomplete = true;
+                break;
+            case 'agent_end':
+                this.finish(this.model, at);
+                this.model = null;
+                if (e.aborted)
+                    this.run.incomplete = true;
+                break;
+            case 'agent_settled':
+                // Unlike agent_end, this also follows post-run compaction or a cancelled retry delay.
+                this.finish(this.model, at);
+                this.finish(this.other, at);
+                for (const span of this.tools.values()) {
+                    this.finish(span, at);
+                    span.incomplete = true;
+                }
+                this.save({
+                    start: this.run.start,
+                    end: at,
+                    spans: this.run.spans,
+                    ...(this.run.incomplete ? { incomplete: true } : {})
+                });
+                this.run = null;
+                this.model = this.other = null;
+                this.tools.clear();
+        }
+    }
+}
+/** Current branch only. Earlier sessions have tool timestamps but no model-call spans. */
+export function sessionPerformance(entries) {
+    const runs = [];
+    const legacyTools = [];
+    for (const entry of entries) {
+        const e = entry;
+        if (e.type === 'custom' &&
+            e.customType === PERFORMANCE_ENTRY &&
+            e.data?.spans &&
+            Number.isFinite(e.data.start) &&
+            Number.isFinite(e.data.end)) {
+            runs.push(e.data);
+        }
+    }
+    for (const entry of entries) {
+        const e = entry;
+        if (e.type !== 'message' || e.message?.role !== 'toolResult')
+            continue;
+        const duration = Number(e.message.durationMs);
+        const end = Number(e.message.timestamp) || Date.parse(e.timestamp ?? '');
+        if (!Number.isFinite(duration) ||
+            duration < 0 ||
+            !Number.isFinite(end) ||
+            runs.some(run => end >= run.start && end <= run.end))
+            continue;
+        legacyTools.push({ kind: 'tool', start: end - duration, end, name: String(e.message.toolName ?? 'tool') });
+    }
+    return { runs, legacyTools };
+}