@itookit/dsht 0.2.1 → 0.3.0

package/dist/controller.js

@@ -1,14 +1,34 @@
 /** UI state and connection generations for the standalone terminal client. */
 import { randomUUID } from 'node:crypto';
+import { saveSessionLog } from "./export.js";
 import { setTimeout as delay } from 'node:timers/promises';
 import { Client, HttpError, RemoteError } from "./client.js";
 import { AuthenticationRequired } from "./auth.js";
 import { resolveTarget, sessionLabel } from "./navigation.js";
 import { costRecords } from "./cost.js";
 import { Telemetry } from "./telemetry.js";
-import { Transcript } from "./transcript.js";
+import { Transcript, toolLine } from "./transcript.js";
+import { releaseHistoryLayout } from "./history.js";
+import { DEFAULT_HISTORY_LIMITS } from "./memory.js";
 import { fileReferences } from "./references.js";
 import { array, errorText, object, string } from "./wire.js";
+/** Wire addresses for one `session/list` row, in the order the cost scan should try them.
+ *
+ * A subagent child is reachable only under its durable parent, and the list row omits the delivery
+ * mode, so both modes are offered with the continuable form first.
+ * @param session - One row from the host session list.
+ * @returns One plain-session address, or both subagent forms when the row is a child.
+ */
+export function costAddresses(session) {
+    const sessionId = string(session.sessionId);
+    const parentSessionId = typeof session.parentSessionId === 'string' ? session.parentSessionId : '';
+    if (session.origin !== 'subagent' || parentSessionId === '')
+        return [{ kind: 'session', sessionId }];
+    return [
+        { kind: 'subagent', parentSessionId, childSessionId: sessionId, mode: 'continuable' },
+        { kind: 'subagent', parentSessionId, childSessionId: sessionId, mode: 'one-shot' },
+    ];
+}
 /** Owns reconnects and subscriptions. User commands remain single-attempt operations. */
 export class Controller {
     base;
@@ -16,9 +36,11 @@ export class Controller {
     makeClient;
     authenticate;
     costs;
+    historyLimits;
     state = { version: 0, online: false, busy: false, screen: 'workspaces', status: 'Connecting…',
         error: '', workspaces: [], sessions: [], showAllSessions: false, pending: [], transcript: new Transcript() };
     observers = new Set();
+    interactions = new Map();
     abort = new AbortController();
     client;
     clientId = '';
@@ -26,8 +48,10 @@ export class Controller {
     runTask;
     generationFailed;
     selection = 0;
-    telemetry = new Telemetry();
+    historyPinned = false;
+    telemetry = new Telemetry(new Set(['title', 'modelSelection', 'contextPressure', 'tokenUsage', 'sessionStats', 'agentPreset']));
     observedRunningAt = new Map();
+    presetClient;
     catalogRevision = 0;
     catalogTasks = new Set();
     runningUpdates = new Map();
@@ -54,6 +78,61 @@ export class Controller {
         return title !== undefined ? sessionLabel({ sessionId: id, projections: { values: { title } } })
             : row ? sessionLabel(row) : id;
     }
+    /** Current agent-preset name, matching the web header's built-in labels and custom metadata. */
+    get sessionMode() {
+        if (!this.state.sessionId)
+            return undefined;
+        const id = this.telemetry.view(this.state.sessionId).values.agentPreset;
+        if (typeof id !== 'string')
+            return undefined;
+        const preset = this.state.presets?.find(item => item.id === id);
+        const builtIn = new Map([['standard', 'Standard mode'], ['ptc', 'PTC mode'], ['minimal', 'Minimal mode'], ['cordis', 'Creator mode']]);
+        return preset?.trust === 'system' && builtIn.has(id) ? builtIn.get(id)
+            : typeof preset?.name === 'string' ? preset.name : id;
+    }
+    /** Load the optional preset roster once per connection, only when a session names a preset. */
+    loadPresetNames() {
+        const client = this.client;
+        if (!client || !this.state.online || this.presetClient === client)
+            return;
+        this.presetClient = client;
+        const task = client.call('agentPresets/list', {}).then(value => {
+            if (client === this.client)
+                this.update({ presets: array(object(value).presets).map(object), presetError: undefined });
+        }).catch(error => {
+            if (client === this.client)
+                this.update({ presets: [], presetError: errorText(error) });
+        });
+        this.catalogTasks.add(task);
+        void task.finally(() => this.catalogTasks.delete(task));
+    }
+    /** Fetch current model routes and adapter-owned reasoning choices for the selected session.
+     * @returns Host catalog; provider failures remain available to the selector.
+     */
+    async modelCatalog() {
+        const sessionId = this.sessionId;
+        const selection = this.selection;
+        const value = object(await this.host.call('session/modelCatalog', {}));
+        if (selection !== this.selection || sessionId !== this.state.sessionId)
+            throw new Error('Session changed while loading models');
+        return value;
+    }
+    /** Select the next request's model; the host also attempts to save its deployment default.
+     * @param provider - Host provider route ID.
+     * @param model - Exact model ID.
+     * @param reasoningEffort - Optional adapter-owned effort ID; omission uses its default.
+     */
+    async selectModel(provider, model, reasoningEffort) {
+        const sessionId = this.sessionId;
+        const selection = this.selection;
+        const selected = object(object(await this.host.call('session/selectModel', { request: {
+                sessionId, provider, model, ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+            } })).selected);
+        if (selection !== this.selection || sessionId !== this.state.sessionId)
+            return;
+        this.update({ status: `Next request: ${string(selected.provider)} / ${string(selected.model)}${selected.reasoningEffort ? ` · ${string(selected.reasoningEffort)}` : ''}` });
+        this.refreshCatalog(this.host);
+    }
     /** Epoch start from the retained turn log, or when this client first observed the run. */
     get workingSince() {
         if (!this.running || !this.state.sessionId)
@@ -92,12 +171,13 @@ export class Controller {
         void task.finally(() => { this.interruptTask = undefined; });
         return task;
     }
-    constructor(base, token, initialSession, makeClient = () => new Client(base), authenticate = client => client.authenticate(token ?? ''), costs) {
+    constructor(base, token, initialSession, makeClient = () => new Client(base), authenticate = client => client.authenticate(token ?? ''), costs, historyLimits = DEFAULT_HISTORY_LIMITS) {
         this.base = base;
         this.initialSession = initialSession;
         this.makeClient = makeClient;
         this.authenticate = authenticate;
         this.costs = costs;
+        this.historyLimits = historyLimits;
     }
     /** React-compatible state subscription. */
     subscribe = (listener) => {
@@ -118,6 +198,28 @@ export class Controller {
         await this.interruptTask;
         await Promise.all(this.catalogTasks);
         await this.costTask;
+        this.releaseTranscript();
+    }
+    /** Keep history stable while the user reads, searches, or expands it; trim again at the live tail.
+     * @param pinned - Whether the main transcript is actively being read away from its tail.
+     */
+    pinHistory(pinned) {
+        this.historyPinned = pinned;
+        if (!pinned && this.reclaimHistory())
+            this.update({});
+    }
+    reclaimHistory() {
+        if (this.historyPinned || !this.state.online)
+            return 0;
+        const removed = this.state.transcript.trimHistory(this.historyLimits);
+        if (removed)
+            releaseHistoryLayout(this.state.transcript);
+        return removed;
+    }
+    releaseTranscript() {
+        releaseHistoryLayout(this.state.transcript);
+        this.state.transcript.dispose();
+        this.historyPinned = false;
     }
     /** Stop the selected turn and then close, so quitting does not leave host work running.
      * An idle session stays untouched, and an in-flight cancellation is awaited rather than repeated.
@@ -172,62 +274,26 @@ export class Controller {
             try {
                 const sessions = array(object(await client.call('session/list', { _request: {} }, signal)).items).map(object);
                 signal.throwIfAborted();
+                const failures = [];
                 for (const session of sessions) {
                     signal.throwIfAborted();
                     const sessionId = string(session.sessionId);
                     if (!session.running && typeof session.updatedAt === 'number' && this.costUpdates.get(sessionId) === session.updatedAt)
                         continue;
-                    const snapshot = await new Promise((resolve, reject) => {
-                        let sub;
-                        const timeout = setTimeout(() => finish(new Error('Cost history snapshot timed out')), client.timeoutMs);
-                        const onAbort = () => finish(new Error('Cost refresh cancelled'));
-                        const finish = (error, frame) => {
-                            clearTimeout(timeout);
-                            signal.removeEventListener('abort', onAbort);
-                            sub?.cancel();
-                            if (error)
-                                reject(error);
-                            else
-                                resolve(frame);
-                        };
-                        signal.addEventListener('abort', onAbort, { once: true });
-                        try {
-                            sub = client.subscribe('session/follow', { request: { address: { kind: 'session', sessionId }, maxMessages: 80, assistantStream: true } }, {
-                                item: value => { const frame = object(value); if (frame.type === 'snapshot')
-                                    finish(undefined, frame); },
-                                end: error => finish(error ?? new Error('Cost history stream ended')),
-                            });
-                        }
-                        catch (error) {
-                            finish(error instanceof Error ? error : new Error(errorText(error)));
-                        }
-                    });
-                    const cut = snapshot.cursor;
-                    if (typeof cut !== 'number' || !Number.isSafeInteger(cut))
-                        throw new Error('Invalid cost history cursor');
-                    let page = snapshot;
-                    const events = [];
-                    while (true) {
+                    try {
+                        const history = await this.sessionCostHistory(session, signal);
+                        await ledger.replace(sessionId, history.cursor, history.events);
+                        if (!session.running && typeof session.updatedAt === 'number')
+                            this.costUpdates.set(sessionId, session.updatedAt);
+                        this.update({});
+                    }
+                    catch (error) {
+                        // One unreachable or rejected session must not freeze every other session's rates.
                         signal.throwIfAborted();
-                        const records = array(page.records);
-                        events.push(...costRecords(records));
-                        if (!page.hasMore)
-                            break;
-                        const seqs = records.map(r => object(object(r).event).seq);
-                        if (!seqs.length || seqs.some(n => typeof n !== 'number' || !Number.isSafeInteger(n)))
-                            throw new Error('Invalid cost history page');
-                        const beforeSeq = Math.min(...seqs);
-                        page = object(await client.call('session/page', { request: { address: { kind: 'session', sessionId }, throughSeq: cut, beforeSeq, maxMessages: 80 } }, signal));
-                        if (page.hasMore && array(page.records).every(r => Number(object(object(r).event).seq) >= beforeSeq))
-                            throw new Error('Cost history page did not advance');
+                        failures.push(`${sessionId}: ${errorText(error)}`);
                     }
-                    if (object(snapshot.header).isSeeded === true && !events.some(e => e.type === 'session/end-seed' && object(e.data).inherited === true))
-                        throw new Error('Cannot attribute inherited session usage');
-                    await ledger.replace(sessionId, cut, events);
-                    if (!session.running && typeof session.updatedAt === 'number')
-                        this.costUpdates.set(sessionId, session.updatedAt);
-                    this.update({});
                 }
+                ledger.error = failures.length === 0 ? '' : `${failures.length} of ${sessions.length} sessions failed: ${failures[0]}`;
                 ledger.scannedAt = Date.now();
             }
             catch (error) {
@@ -246,16 +312,132 @@ export class Controller {
             this.costTask = undefined;
         }
     }
+    /** Read one session's complete cost history, retrying a subagent child with its other delivery mode. */
+    async sessionCostHistory(session, signal) {
+        let lastError;
+        for (const address of costAddresses(session)) {
+            try {
+                return await this.readCostHistory(address, signal);
+            }
+            catch (error) {
+                lastError = error;
+                // Only a delivery-mode mismatch justifies the other form; every other failure is final here.
+                if (!(error instanceof RemoteError && error.code === 'subagent/unauthorized'))
+                    throw error;
+            }
+        }
+        throw lastError;
+    }
+    /** Page one addressed session's history into the billing events the ledger folds. */
+    async readCostHistory(address, signal) {
+        const client = this.host;
+        const snapshot = await new Promise((resolve, reject) => {
+            let sub;
+            const timeout = setTimeout(() => finish(new Error('Cost history snapshot timed out')), client.timeoutMs);
+            const onAbort = () => finish(new Error('Cost refresh cancelled'));
+            const finish = (error, frame) => {
+                clearTimeout(timeout);
+                signal.removeEventListener('abort', onAbort);
+                sub?.cancel();
+                if (error)
+                    reject(error);
+                else
+                    resolve(frame);
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            try {
+                sub = client.subscribe('session/follow', { request: { address, maxMessages: 80, assistantStream: true } }, {
+                    item: value => { const frame = object(value); if (frame.type === 'snapshot')
+                        finish(undefined, frame); },
+                    end: error => finish(error ?? new Error('Cost history stream ended')),
+                });
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(errorText(error)));
+            }
+        });
+        const cursor = snapshot.cursor;
+        if (typeof cursor !== 'number' || !Number.isSafeInteger(cursor))
+            throw new Error('Invalid cost history cursor');
+        let page = snapshot;
+        const events = [];
+        while (true) {
+            signal.throwIfAborted();
+            const records = array(page.records);
+            events.push(...costRecords(records));
+            if (!page.hasMore)
+                break;
+            const seqs = records.map(r => object(object(r).event).seq);
+            if (!seqs.length || seqs.some(n => typeof n !== 'number' || !Number.isSafeInteger(n)))
+                throw new Error('Invalid cost history page');
+            const beforeSeq = Math.min(...seqs);
+            page = object(await client.call('session/page', { request: { address, throughSeq: cursor, beforeSeq, maxMessages: 80 } }, signal));
+            if (page.hasMore && array(page.records).every(r => Number(object(object(r).event).seq) >= beforeSeq))
+                throw new Error('Cost history page did not advance');
+        }
+        if (object(snapshot.header).isSeeded === true && !events.some(e => e.type === 'session/end-seed' && object(e.data).inherited === true))
+            throw new Error('Cannot attribute inherited session usage');
+        return { cursor, events };
+    }
     /** Refresh both lists from the host, then show the requested picker. */
     async showPicker(screen) {
-        await this.releasePending();
         const [workspaces, sessions] = await Promise.all([this.host.listWorkspaces(), this.host.listSessions()]);
         this.update({ screen, workspaces, sessions });
     }
+    /** Resolve a removal command to one reviewable object without changing the selection.
+     * @param kind - Workspace registration removal or session archival.
+     * @param query - Exact name, ID, or unambiguous ID prefix.
+     * @returns The fixed identity and display details for confirmation.
+     */
+    async removalTarget(kind, query) {
+        const items = kind === 'workspace' ? await this.host.listWorkspaces() : await this.host.listSessions();
+        const row = resolveTarget(items, query, kind === 'workspace' ? 'workspaceId' : 'sessionId', item => kind === 'workspace' ? [string(item.title), string(item.path)] : [sessionLabel(item)]);
+        return kind === 'workspace' ? { kind, id: string(row.workspaceId), name: string(row.title), path: string(row.path) }
+            : { kind, id: string(row.sessionId), name: sessionLabel(row),
+                empty: row.blank === true && row.running === false
+                    && !this.runningUpdates.get(string(row.sessionId))
+                    && !(this.telemetry.view(string(row.sessionId)).queued ?? 0)
+                    && !(this.telemetry.view(string(row.sessionId)).jobs ?? 0)
+                    && !(this.state.sessionId === row.sessionId && this.admission) };
+    }
+    /** Apply a confirmed removal or freshly verified empty-session archival; directories and logs are preserved.
+     * @param target - Exact workspace or session identity reviewed by the user.
+     */
+    async removeTarget(target) {
+        const client = this.host;
+        const receipt = object(await client.call(target.kind === 'workspace' ? 'workspace/delete' : 'workspace/archiveSession', {
+            request: target.kind === 'workspace' ? { workspaceId: target.id } : { sessionId: target.id },
+        }));
+        if (client !== this.client)
+            return;
+        if (target.kind === 'session') {
+            client.archivedSessionIds = new Set(array(receipt.archivedSessionIds).map(string));
+            if (this.state.sessionId === target.id) {
+                this.pickWorkspace(this.state.workspaceId);
+            }
+        }
+        else {
+            if (receipt.deleted !== true)
+                throw new Error('Host did not confirm workspace removal');
+            this.update({ workspaces: this.state.workspaces.filter(row => row.workspaceId !== target.id),
+                ...(this.state.workspaceId === target.id ? { workspaceId: undefined } : {}) });
+        }
+        this.update({ screen: target.kind === 'workspace' ? 'workspaces' : 'sessions',
+            status: target.kind === 'workspace' ? 'Workspace registration removed' : 'Session archived' });
+        // A refresh failure must not make a successful mutation look like a rejected deletion.
+        try {
+            await this.showPicker(target.kind === 'workspace' ? 'workspaces' : 'sessions');
+        }
+        catch (error) {
+            this.update({ error: `Removal completed; list refresh failed: ${errorText(error)}` });
+        }
+    }
     /** Pick a workspace, or use all sessions when the identity is omitted. */
     pickWorkspace(workspaceId) {
-        this.follow?.cancel();
         this.selection++;
+        this.follow?.cancel();
+        this.follow = undefined;
+        this.releaseTranscript();
         this.update({ workspaceId, sessionId: undefined, showAllSessions: false, transcript: new Transcript(), screen: 'sessions' });
     }
     /** Open a workspace picker, or resolve a workspace by ID, exact title/path, or unique ID prefix. */
@@ -267,7 +449,6 @@ export class Controller {
         const workspaces = await this.host.listWorkspaces();
         const workspace = resolveTarget(workspaces, query, 'workspaceId', item => [string(item.title), string(item.path)]);
         const sessions = await this.host.listSessions();
-        await this.releasePending();
         this.update({ workspaces, sessions });
         this.pickWorkspace(string(workspace.workspaceId));
     }
@@ -302,9 +483,10 @@ export class Controller {
     /** Replace the selected transcript and cancel its preceding follow stream. */
     async selectSession(sessionId) {
         this.stoppingSession = undefined;
-        await this.releasePending();
-        this.follow?.cancel();
         const selection = ++this.selection;
+        this.follow?.cancel();
+        this.follow = undefined;
+        this.releaseTranscript();
         const transcript = new Transcript();
         const workspace = this.state.workspaces.find(item => array(item.sessionIds).includes(sessionId));
         const workspaceId = workspace ? string(workspace.workspaceId)
@@ -320,10 +502,11 @@ export class Controller {
                     return;
                 try {
                     transcript.accept(value);
+                    this.reclaimHistory();
                     const frame = object(value);
                     if (frame.type === 'snapshot')
                         this.telemetry.snapshot(sessionId, frame.projections);
-                    this.update({ transcript, status: this.stoppingSession === sessionId ? this.state.status : transcript.liveText ? 'Responding…' : 'Connected' });
+                    this.update({ transcript, status: this.stoppingSession === sessionId ? this.state.status : transcript.hasLiveContent ? 'Responding…' : 'Connected' });
                 }
                 catch (error) {
                     this.generationFailed?.(new Error(errorText(error)));
@@ -382,13 +565,50 @@ export class Controller {
     async references(query, signal) {
         return fileReferences(await this.host.call('fileReferences/list', { agentId: this.sessionId, query }, signal));
     }
-    /** Admit a prompt once; a failed response can have an uncertain delivery outcome. */
-    async prompt(text, mode = 'queue') {
+    /** Execute a human command directly, outside the model prompt queue.
+     * @param line - Complete slash command, including arguments.
+     * @param signal - Cancels the request while the host performs compaction.
+     * @returns The host's successful command result text.
+     */
+    async command(line, signal) {
+        if (!this.state.transcript.ready)
+            throw new Error('Wait for the session snapshot before running commands');
+        const execution = await this.host.call('commands/execute', {
+            agentId: this.sessionId, line, submittedAttachments: [],
+        }, signal, null);
+        if (execution === undefined)
+            throw new Error(`This host does not provide ${line.split(/\s/, 1)[0]}`);
+        const result = object(object(execution).result);
+        if ((result.kind !== 'success' && result.kind !== 'error') || (result.text !== undefined && typeof result.text !== 'string')) {
+            throw new Error('Invalid command result from host');
+        }
+        if (result.kind === 'error')
+            throw new Error(string(result.text));
+        return result.text === undefined ? 'Command completed.' : string(result.text);
+    }
+    /** Remove one host-owned pending input; an already claimed item reports a host error.
+     * @param itemId - Queue occurrence identity from session/control.
+     */
+    async removeQueued(itemId) {
+        await this.host.call('session/updateQueue', { request: { sessionId: this.sessionId, itemId, action: { kind: 'remove' } } });
+    }
+    /** Export the selected host log to a new local ZIP file.
+     * @param path - Optional local destination; existing files are never overwritten.
+     * @param signal - Cancels the download and removes an incomplete file.
+     * @returns Absolute saved filename.
+     */
+    async exportLog(path, signal) {
+        return saveSessionLog(this.host, this.sessionId, path, signal);
+    }
+    /** Admit text once as steering while running, or a new turn while idle; a lost response can leave delivery uncertain. */
+    async prompt(text) {
+        if (this.state.pending.length)
+            throw new Error('Answer the pending question or approval first');
         this.stoppingSession = undefined;
         if (!this.state.transcript.ready)
             throw new Error('Wait for the session snapshot before sending');
         const admission = this.host.call('session/prompt', { request: {
-                sessionId: this.sessionId, requestId: randomUUID(), mode,
+                sessionId: this.sessionId, requestId: randomUUID(), mode: this.running ? 'steer' : 'queue',
                 content: [{ type: 'text', text }], clientTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
             } });
         this.admission = admission;
@@ -407,18 +627,109 @@ export class Controller {
         this.update({ status: 'Cancellation requested' });
     }
     /** Add a page before the retained window using its fixed opening cut. */
-    async older(signal) {
-        const transcript = this.state.transcript;
+    async older(signal, transcript = this.state.transcript) {
+        const selection = this.selection;
+        if (transcript === this.state.transcript)
+            this.historyPinned = true;
         if (!transcript.ready || !transcript.hasMore || transcript.beforeSeq === undefined)
             return;
         const result = await this.host.call('session/page', { request: {
                 address: { kind: 'session', sessionId: this.sessionId }, throughSeq: transcript.cursor,
                 beforeSeq: transcript.beforeSeq, maxMessages: 80,
             } }, signal);
-        if (transcript !== this.state.transcript)
+        if (selection !== this.selection)
             return;
         transcript.addPage(result);
-        this.update({ transcript });
+        this.update({});
+    }
+    /** Search one page at a time, preserving only the first 200 matches and releasing temporary content.
+     * @param query - Literal, case-insensitive text including folded reasoning.
+     * @param signal - Cancels HTTP and processing without cancelling the agent.
+     * @returns Newest-first bounded summaries and an explicit truncation flag.
+     */
+    async searchHistory(query, signal) {
+        const source = this.state.transcript;
+        if (!source.ready)
+            throw new Error('Wait for the session snapshot');
+        const sessionId = this.sessionId;
+        const selection = this.selection;
+        const throughSeq = source.readThrough;
+        const needle = query.toLowerCase();
+        const result = { items: [], truncated: false };
+        const scan = (transcript) => {
+            const messages = transcript.messages;
+            for (let index = messages.length - 1; index >= 0; index--) {
+                signal.throwIfAborted();
+                const message = messages[index];
+                if (message.role === 'Tool')
+                    continue;
+                const text = message.text;
+                const match = text.toLowerCase().indexOf(needle);
+                if (match < 0)
+                    continue;
+                if (result.items.length === 200) {
+                    result.truncated = true;
+                    return false;
+                }
+                result.items.push({ seq: message.seq, role: message.role, preview: Buffer.from(toolLine(text.slice(Math.max(0, match - 40), match + needle.length + 100), 160)).toString('utf8') });
+            }
+            return true;
+        };
+        signal.throwIfAborted();
+        if (!scan(source))
+            return result;
+        let beforeSeq = source.beforeSeq;
+        let hasMore = source.hasMore;
+        while (hasMore && beforeSeq !== undefined) {
+            const page = object(await this.host.call('session/page', { request: {
+                    address: { kind: 'session', sessionId }, throughSeq, beforeSeq, maxMessages: 80,
+                } }, signal));
+            signal.throwIfAborted();
+            if (selection !== this.selection)
+                throw new Error('Session changed while searching history');
+            const temporary = new Transcript();
+            try {
+                temporary.accept({ type: 'snapshot', cursor: throughSeq, assistantStream: { revision: 0 }, records: page.records, hasMore: page.hasMore });
+                const next = temporary.beforeSeq;
+                if (temporary.hasMore && (next === undefined || next >= beforeSeq))
+                    throw new Error('Host history page did not advance');
+                if (!scan(temporary))
+                    return result;
+                beforeSeq = next;
+                hasMore = temporary.hasMore;
+            }
+            finally {
+                temporary.dispose();
+            }
+        }
+        return result;
+    }
+    /** Load a separate small window ending at a search target; the live transcript keeps following.
+     * @param target - Durable message sequence to display.
+     * @param signal - Cancels the target-page request.
+     * @returns A caller-owned historical window that must be disposed when closed.
+     */
+    async historyAt(target, signal) {
+        const source = this.state.transcript;
+        const selection = this.selection;
+        const page = object(await this.host.call('session/page', { request: {
+                address: { kind: 'session', sessionId: this.sessionId }, throughSeq: source.readThrough,
+                beforeSeq: target + 1, maxMessages: 80,
+            } }, signal));
+        signal.throwIfAborted();
+        if (selection !== this.selection)
+            throw new Error('Session changed while opening history');
+        const window = new Transcript();
+        try {
+            window.accept({ type: 'snapshot', cursor: source.readThrough, assistantStream: { revision: 0 }, records: page.records, hasMore: page.hasMore });
+            if (!window.messages.some(message => message.seq === target))
+                throw new Error('The host did not return the requested message');
+            return window;
+        }
+        catch (error) {
+            window.dispose();
+            throw error;
+        }
     }
     /** Load the prefix required for an explicit history jump; never loop on an unadvancing page.
      * @param target - Visible record sequence, or first for the oldest available history.
@@ -445,7 +756,8 @@ export class Controller {
         if (!pending)
             throw new Error('No pending interaction');
         await this.reply(pending, { kind: 'result', value });
-        this.update({ pending: this.state.pending.filter(item => item.eventId !== pending.eventId) });
+        this.interactions.delete(string(pending.eventId));
+        this.update({});
     }
     /** Restrict an approval command to an approval request. */
     async approve(allowed) {
@@ -455,11 +767,12 @@ export class Controller {
     }
     /** Present only sessions explicitly accounted to the selected workspace. */
     get visibleSessions() {
+        const sessions = this.state.sessions.filter(item => !this.client?.archivedSessionIds.has(string(item.sessionId)));
         if (this.state.showAllSessions || !this.state.workspaceId)
-            return this.state.sessions;
+            return sessions;
         const workspace = this.state.workspaces.find(item => item.workspaceId === this.state.workspaceId);
         const ids = new Set(array(workspace?.sessionIds ?? []).map(string));
-        return this.state.sessions.filter(item => ids.has(string(item.sessionId)));
+        return sessions.filter(item => ids.has(string(item.sessionId)));
     }
     get host() {
         if (!this.client || !this.state.online)
@@ -472,18 +785,16 @@ export class Controller {
         return this.state.sessionId;
     }
     update(patch) {
-        this.state = { ...this.state, ...patch, version: this.state.version + 1 };
+        const next = { ...this.state, ...patch, version: this.state.version + 1 };
+        next.pending = next.online && next.screen === 'chat'
+            ? [...this.interactions.values()].filter(frame => frame.agentId === next.sessionId) : [];
+        this.state = next;
         for (const observer of this.observers)
             observer();
     }
     async reply(frame, outcome) {
         await this.host.call('$events/result', { clientId: this.clientId, eventId: string(frame.eventId), outcome });
     }
-    async releasePending() {
-        for (const pending of this.state.pending)
-            await this.reply(pending, { kind: 'next' });
-        this.update({ pending: [] });
-    }
     refreshCatalog(client) {
         const revision = ++this.catalogRevision;
         const task = client.call('session/modelCatalog', {}).then(value => {
@@ -506,7 +817,7 @@ export class Controller {
             this.runningUpdates.clear();
             this.observedRunningAt.clear();
             this.telemetry = new Telemetry();
-            this.update({ controlError: undefined, modelError: undefined, defaultModel: undefined });
+            this.update({ controlError: undefined, modelError: undefined, defaultModel: undefined, presets: undefined, presetError: undefined });
             const client = this.makeClient();
             this.client = client;
             try {
@@ -526,9 +837,9 @@ export class Controller {
                                 resolve();
                             }
                             else if (frame.type === 'waterfall') {
-                                if (frame.agentId === this.state.sessionId && this.state.screen === 'chat'
-                                    && ['approval/request', 'user-questions/request'].includes(string(frame.event))) {
-                                    this.update({ pending: [...this.state.pending, frame] });
+                                if (['approval/request', 'user-questions/request'].includes(string(frame.event))) {
+                                    this.interactions.set(string(frame.eventId), frame);
+                                    this.update({});
                                 }
                                 else {
                                     void client.call('$events/result', { clientId: this.clientId,
@@ -536,7 +847,8 @@ export class Controller {
                                 }
                             }
                             else if (frame.type === 'cancel') {
-                                this.update({ pending: this.state.pending.filter(item => item.eventId !== frame.eventId) });
+                                this.interactions.delete(string(frame.eventId));
+                                this.update({});
                             }
                             else if (frame.type === 'emit' && frame.event === 'api-session/status') {
                                 const args = array(frame.args);
@@ -630,6 +942,7 @@ export class Controller {
                 this.generationFailed = undefined;
                 this.selection++;
                 this.state.transcript.ready = false;
+                this.interactions.clear();
                 this.update({ online: false, pending: [] });
                 await client.close();
                 await this.costTask;