@itookit/dsht 0.5.1 → 0.5.2

package/dist/session/controller.js

@@ -1,6 +1,5 @@
 /** Session domain: selection, the follow stream, history, interaction and navigation. */
 import { randomUUID } from 'node:crypto';
-import { setTimeout as delay } from 'node:timers/promises';
 import { array, errorText, object, string } from "../transport/wire.js";
 import { saveSessionLog } from "./export.js";
 import { saveTranscriptHtml } from "./export-html.js";
@@ -11,15 +10,14 @@ import { fileReferences } from "./references.js";
 import { SessionRuntime } from "./runtime.js";
 import { PromptCache } from "./info.js";
 import { SessionMutationGate } from "./mutation-gate.js";
-import { recordPrompts, Transcript } from "./transcript.js";
+import { recordPrompts } from "./transcript.js";
 import { projectionSnapshot } from "../transport/events.js";
-import { toolLine } from "../text.js";
+import { HistoryReader } from "./history-reader.js";
+import { SessionInteractions } from "./interactions.js";
+import { SessionNavigator } from "./navigator.js";
+import { PromptBackfill } from "./prompt-backfill.js";
 /** Built-in preset identifiers and the labels the web session header shows. */
 const BUILT_IN_MODES = new Map([['standard', 'Standard mode'], ['ptc', 'PTC mode'], ['minimal', 'Minimal mode'], ['cordis', 'Creator mode']]);
-/** Bounded match count for one history search. */
-const SEARCH_MATCH_LIMIT = 200;
-/** Bounded page count for the prompt backfill that runs once per opened session. */
-const PROMPT_BACKFILL_PAGES = 200;
 /** Owns the selected session: its follow stream, transcript, history window and interactions. */
 export class SessionController {
     store;
@@ -27,7 +25,9 @@ export class SessionController {
     connection;
     historyLimits;
     follow;
-    interactions = new Map();
+    history;
+    interactions;
+    navigation;
     /** Reading protection: reclamation pauses while the reader is away from the live end. */
     historyPinned = false;
     /** Host runtime mirrors for every session this connection has seen. */
@@ -36,7 +36,7 @@ export class SessionController {
     promptBackfill;
     /** Prompts of sessions this process has already read, so re-opening one costs no page request. */
     promptCache = new PromptCache();
-    /** Prompt index, composer and reading view of the selected session; the instance `State.session` exposes. */
+    /** Prompt index, record, history window and interaction state of the selected session. */
     get info() { return this.store.state.session; }
     get prompts() { return this.info.prompts; }
     stoppingSession;
@@ -50,6 +50,39 @@ export class SessionController {
         this.connection = connection;
         this.historyLimits = historyLimits;
         this.mutations = new SessionMutationGate(report);
+        this.promptBackfill = new PromptBackfill({
+            require: () => this.host.require(), signal: () => this.host.signal(), online: () => this.host.online(),
+            current: selection => selection.revision === this.store.selection() && selection.record === this.info.record
+                && selection.sessionId === this.store.state.sessionId,
+            changed: () => this.store.update({}),
+        }, this.promptCache);
+        this.navigation = new SessionNavigator({
+            require: () => this.host.require(), client: () => this.host.client(),
+            online: () => this.host.online(), signal: () => this.host.signal(),
+            read: () => this.store.state, publish: patch => this.store.update(patch),
+            selection: () => this.store.selection(),
+            leave: () => {
+                this.store.bumpSelection();
+                this.follow?.cancel();
+                this.follow = undefined;
+                this.releaseTranscript();
+            },
+            follow: id => this.followSession(id, true),
+        });
+        this.interactions = new SessionInteractions({
+            focused: () => this.store.state.pending[0],
+            admit: async (sessionId, dispatch) => { await this.mutations.admit(sessionId, 'normal', dispatch); },
+            reply: (eventId, outcome) => this.connection.reply(eventId, outcome),
+            changed: () => this.store.update({}),
+        });
+        this.history = new HistoryReader({
+            require: () => this.host.require(), online: () => this.host.online(), signal: () => this.host.signal(),
+            selected: () => ({ sessionId: this.sessionId, revision: this.store.selection(), record: this.info.record }),
+            current: selection => selection.revision === this.store.selection() && selection.sessionId === this.store.state.sessionId
+                && selection.record === this.info.record,
+            owns: source => source === this.info.record || source === this.info.window,
+            changed: () => this.store.update({}),
+        });
     }
     /** Host running state covers model generation, tools, and waits between assistant attempts. */
     get running() {
@@ -68,13 +101,13 @@ export class SessionController {
             : row ? sessionLabel(row) : id;
     }
     /** Current agent-preset name, matching the web header's built-in labels and custom metadata. */
-    get sessionMode() {
+    sessionMode(presets = []) {
         if (!this.store.state.sessionId)
             return undefined;
         const id = this.runtime.telemetry.view(this.store.state.sessionId).values.agentPreset;
         if (typeof id !== 'string')
             return undefined;
-        const preset = this.store.state.presets?.find(item => item.id === id);
+        const preset = presets.find(item => item.id === id);
         return preset?.trust === 'system' && BUILT_IN_MODES.has(id) ? BUILT_IN_MODES.get(id)
             : typeof preset?.name === 'string' ? preset.name : id;
     }
@@ -85,14 +118,7 @@ export class SessionController {
         return this.info.record.activeTurnStartedAt ?? this.runtime.observedAt(this.store.state.sessionId);
     }
     /** Present only sessions explicitly accounted to the selected workspace. */
-    get visibleSessions() {
-        const sessions = this.store.state.sessions.filter(item => !this.host.client()?.archivedSessionIds.has(string(item.sessionId)));
-        if (this.store.state.showAllSessions || !this.store.state.workspaceId)
-            return sessions;
-        const workspace = this.store.state.workspaces.find(item => item.workspaceId === this.store.state.workspaceId);
-        const ids = new Set(array(workspace?.sessionIds ?? []).map(string));
-        return sessions.filter(item => ids.has(string(item.sessionId)));
-    }
+    get visibleSessions() { return this.navigation.visibleSessions; }
     /** Whether a turn, cancellation or prompt admission is still in flight. */
     get active() { return this.interruptTask !== undefined || this.running || this.admission !== undefined; }
     /** @returns The detached history window the reader opened, if any. */
@@ -103,6 +129,8 @@ export class SessionController {
     setViewWindow(window) {
         if (this.info.window === window)
             return;
+        if (this.info.window)
+            this.history.cancel(this.info.window);
         this.info.closeWindow();
         this.info.window = window;
         this.store.update({});
@@ -125,21 +153,22 @@ export class SessionController {
     beginGeneration() { this.stoppingSession = undefined; this.runtime.reset(); }
     /** Invalidate in-flight work and drop transient interactions when a generation ends. */
     endGeneration() {
+        this.promptBackfill.cancel();
+        this.navigation.reset();
+        this.history.cancel();
         this.store.bumpSelection();
         this.info.record.ready = false;
         this.interactions.clear();
     }
-    /** Wait for an in-flight cancellation so shutdown leaves nothing running. */
-    async settle() { await this.interruptTask; }
+    /** Wait for cancellation and foreground history tasks before releasing their records. */
+    async settle() { await this.interruptTask; await this.history.settle(); await this.promptBackfill.settle(); await this.interactions.settle(); await this.navigation.settle(); }
     /** Release the selected transcript and its layout caches. */
-    release() { this.releaseTranscript(); }
+    release() { this.navigation.reset(); this.releaseTranscript(); }
     /** Pending interactions for the selected chat session, derived independently of frame order.
-     * @param state - State being published.
+     * @param sessionId - Session whose pending interactions are being published.
      * @returns Retained question and approval frames for that session.
      */
-    pendingFor(state) {
-        return [...this.interactions.values()].filter(frame => frame.sessionId === state.sessionId);
-    }
+    pendingFor(sessionId) { return this.interactions.pendingFor(sessionId); }
     /** Unanswered interactions by session, so a list can show who is waiting without opening them.
      *
      * The host delivers approval and question waterfalls for every session on one stream, and this
@@ -148,37 +177,16 @@ export class SessionController {
      * until the host replays the pending waterfalls.
      * @returns One count per session holding at least one unanswered interaction.
      */
-    pendingCounts() {
-        const counts = new Map();
-        for (const frame of this.interactions.values()) {
-            if (frame.sessionId === '')
-                continue;
-            counts.set(frame.sessionId, (counts.get(frame.sessionId) ?? 0) + 1);
-        }
-        return counts;
-    }
+    pendingCounts() { return this.interactions.counts(); }
     /** Retain a recognized host interaction; anything else belongs to the connection to delegate.
      * @param event - One normalized host event.
      * @returns Whether this domain retained the event for an answer.
      */
-    accept(event) {
-        if (event.kind === 'approval-request') {
-            this.interactions.set(event.eventId, { kind: 'approval', eventId: event.eventId, sessionId: event.sessionId,
-                description: event.description });
-        }
-        else if (event.kind === 'question-request') {
-            this.interactions.set(event.eventId, { kind: 'question', eventId: event.eventId, sessionId: event.sessionId,
-                questions: event.questions });
-        }
-        else
-            return false;
-        this.store.update({});
-        return true;
-    }
+    accept(event) { return this.interactions.accept(event); }
     /** Drop a waterfall the host cancelled.
      * @param eventId - Correlation id previously retained.
      */
-    cancelled(eventId) { this.interactions.delete(eventId); this.store.update({}); }
+    cancelled(eventId) { this.interactions.cancelled(eventId); }
     /** Apply one host running-state notification to the session list and status line.
      * @param sessionId - Session whose state changed.
      * @param running - Whether the host still runs that session.
@@ -254,23 +262,18 @@ export class SessionController {
     /** Refresh both lists from the host, then show the requested picker.
      * @param screen - Picker to display after the refresh.
      */
-    async showPicker(screen) {
-        const client = this.host.require();
-        const [workspaces, sessions] = await Promise.all([client.listWorkspaces(), client.listSessions()]);
-        this.store.update({ screen, workspaces, sessions });
+    showPicker(screen, signal) {
+        return this.navigation.showPicker(screen, signal);
     }
+    /** Refresh navigation data without taking the reader to another screen. */
+    refreshLists() { return this.navigation.refreshLists(); }
     /** Return to the selected conversation without re-selecting it.
      *
      * A picker opened over a conversation is a detour: leaving it must not re-subscribe, reload the
      * transcript or lose the reading position, so this only changes which screen is shown.
      * @returns Whether there was a selected conversation to return to.
      */
-    showChat() {
-        if (this.store.state.sessionId === undefined)
-            return false;
-        this.store.update({ screen: 'chat' });
-        return true;
-    }
+    showChat() { return this.navigation.showChat(); }
     /** 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.
@@ -293,12 +296,14 @@ export class SessionController {
      */
     async removeTarget(target) {
         const client = this.host.require();
+        const intent = this.navigation.intent;
         const receipt = object(target.kind === 'workspace'
             ? await client.call('workspace/delete', { request: { workspaceId: target.id } })
             // Archiving a session is a write on that session, so it queues behind that session's admissions.
             : await this.mutations.admit(target.id, 'normal', () => client.call('workspace/archiveSession', { request: { sessionId: target.id } })));
         if (client !== this.host.client())
             return;
+        const navigate = intent === this.navigation.intent;
         if (target.kind === 'session') {
             client.archivedSessionIds = new Set(array(receipt.archivedSessionIds).map(string));
             if (this.store.state.sessionId === target.id)
@@ -310,11 +315,11 @@ export class SessionController {
             this.store.update({ workspaces: this.store.state.workspaces.filter(row => row.workspaceId !== target.id),
                 ...(this.store.state.workspaceId === target.id ? { workspaceId: undefined } : {}) });
         }
-        this.store.update({ screen: target.kind === 'workspace' ? 'workspaces' : 'sessions',
+        this.store.update({ ...(navigate ? { 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');
+            await this.refreshLists();
         }
         catch (error) {
             this.store.update({ lastFailure: `Removal completed; list refresh failed: ${errorText(error)}` });
@@ -323,45 +328,17 @@ export class SessionController {
     /** Pick a workspace, or use all sessions when the identity is omitted.
      * @param workspaceId - Workspace to select, if any.
      */
-    pickWorkspace(workspaceId) {
-        this.store.bumpSelection();
-        this.follow?.cancel();
-        this.follow = undefined;
-        this.releaseTranscript();
-        this.store.update({ workspaceId, sessionId: undefined, showAllSessions: false, screen: 'sessions' });
-    }
+    pickWorkspace(workspaceId) { this.navigation.pickWorkspace(workspaceId); }
     /** Open a workspace picker, or resolve a workspace by ID, exact title/path, or unique ID prefix.
      * @param query - Workspace target, if any.
      */
-    async switchWorkspace(query) {
-        if (!query) {
-            await this.showPicker('workspaces');
-            return;
-        }
-        const client = this.host.require();
-        const workspaces = await client.listWorkspaces();
-        const workspace = resolveTarget(workspaces, query, 'workspaceId', item => [string(item.title), string(item.path)]);
-        const sessions = await client.listSessions();
-        this.store.update({ workspaces, sessions });
-        this.pickWorkspace(string(workspace.workspaceId));
-    }
+    switchWorkspace(query, signal) { return this.navigation.switchWorkspace(query, signal); }
     /** Guide workspace selection, list all sessions with `all`, or resolve an exact session target.
      * @param query - Session target, `all`, or nothing for the guided picker.
      */
-    async switchSession(query) {
-        if (!query || query === 'all') {
-            await this.showPicker(query === 'all' || this.store.state.workspaceId ? 'sessions' : 'workspaces');
-            this.store.update({ showAllSessions: query === 'all' });
-            return;
-        }
-        const client = this.host.require();
-        const [workspaces, sessions] = await Promise.all([client.listWorkspaces(), client.listSessions()]);
-        const session = resolveTarget(sessions, query, 'sessionId', item => [sessionLabel(item)]);
-        this.store.update({ workspaces, sessions });
-        await this.selectSession(string(session.sessionId));
-    }
+    switchSession(query, signal) { return this.navigation.switchSession(query, signal); }
     /** Prompt for a host path without starting a local agent. */
-    enterPath() { this.store.update({ screen: 'path' }); }
+    enterPath() { this.navigation.enterPath(); }
     /** Adopt the workspace whose registered path contains the directory this client runs in.
      *
      * Longest path wins, so a workspace nested in another is preferred, and the comparison is on whole
@@ -370,40 +347,13 @@ export class SessionController {
      * @param directory - Directory this client was started in.
      * @returns The adopted workspace's id, or undefined when none matches.
      */
-    adoptLocalWorkspace(directory) {
-        const slashed = (value) => value.replace(/\\/g, '/').replace(/\/+$/, '');
-        const target = slashed(directory);
-        if (target === '')
-            return undefined;
-        let best;
-        for (const workspace of this.store.state.workspaces) {
-            const path = slashed(string(workspace.path));
-            if (path === '' || (target !== path && !target.startsWith(`${path}/`)))
-                continue;
-            if (best === undefined || path.length > best.length)
-                best = { id: string(workspace.workspaceId), length: path.length };
-        }
-        if (best === undefined)
-            return undefined;
-        this.pickWorkspace(best.id);
-        return best.id;
-    }
+    adoptLocalWorkspace(directory) { return this.navigation.adoptLocalWorkspace(directory); }
     /** Register a host directory and move to its session picker.
      * @param path - Absolute directory path on the host.
      */
-    async createWorkspace(path) {
-        const result = object(await this.host.require().call('workspace/create', { request: { path } }));
-        const workspace = object(result.workspace);
-        await this.showPicker('workspaces');
-        this.pickWorkspace(string(workspace.workspaceId));
-    }
+    createWorkspace(path, signal) { return this.navigation.createWorkspace(path, signal); }
     /** Create a session only after the user explicitly selects New session. */
-    async createSession() {
-        if (!this.store.state.workspaceId)
-            throw new Error('Select a workspace before creating a session');
-        const result = object(await this.host.require().call('session/create', { request: { workspaceId: this.store.state.workspaceId } }));
-        await this.selectSession(string(result.sessionId));
-    }
+    createSession(signal) { return this.navigation.createSession(signal); }
     /** Create a session for another purpose without selecting it, named so a reader can tell it apart.
      *
      * A verifier runs in its own session while the reviewed session stays selected, so this never
@@ -437,6 +387,18 @@ export class SessionController {
      * @param sessionId - Session to follow.
      */
     async selectSession(sessionId) {
+        this.navigation.cancel();
+        this.followSession(sessionId, true);
+    }
+    /** Reattach the selected conversation after reconnect, keeping the current navigation context. */
+    restoreSelectedSession() {
+        const sessionId = this.store.state.sessionId;
+        if (sessionId !== undefined)
+            this.followSession(sessionId, false);
+    }
+    followSession(sessionId, navigate) {
+        this.promptBackfill.cancel();
+        this.history.cancel();
         this.stoppingSession = undefined;
         this.store.bumpSelection();
         const selection = this.store.selection();
@@ -448,7 +410,8 @@ export class SessionController {
         const workspaceId = workspace ? string(workspace.workspaceId)
             : this.store.state.sessions.some(item => item.sessionId === sessionId) ? undefined : this.store.state.workspaceId;
         this.runtime.observe(sessionId);
-        this.store.update({ sessionId, workspaceId, showAllSessions: false, screen: 'chat', status: 'Loading session…' });
+        this.store.update({ sessionId, status: 'Loading session…',
+            ...(navigate ? { workspaceId, showAllSessions: false, screen: 'chat' } : {}) });
         this.follow = this.host.require().subscribe('session/follow', {
             request: { address: { kind: 'session', sessionId }, maxMessages: 80, assistantStream: true },
         }, {
@@ -475,23 +438,12 @@ export class SessionController {
                 this.store.update({ status: 'Session disconnected', lastFailure: errorText(error ?? 'Session stream ended') });
             },
         });
-        this.backfillPrompts(sessionId, selection);
+        this.promptBackfill.start({ sessionId, revision: selection, record: transcript, prompts: this.prompts });
     }
     /** Wait for the selected follow snapshot, failing on disconnect or cancellation.
      * @param signal - Cancels waiting without closing the session.
      */
-    async waitForHistory(signal) {
-        const transcript = this.info.record;
-        const deadline = Date.now() + this.host.require().timeoutMs;
-        while (!transcript.ready) {
-            signal.throwIfAborted();
-            if (!this.store.state.online || this.info.record !== transcript)
-                throw new Error('Session changed while loading history');
-            if (Date.now() >= deadline)
-                throw new Error('Session snapshot timed out');
-            await delay(20, undefined, { signal });
-        }
-    }
+    async waitForHistory(signal) { await this.history.waitForHistory(signal); }
     /** Search the host's bounded global results, optionally retaining workspace members.
      * @param query - Literal message text.
      * @param workspaceOnly - Restrict returned hits to the selected workspace's session IDs.
@@ -620,41 +572,18 @@ export class SessionController {
     /** Answer the oldest selected-session interaction, after explicit user action.
      * @param value - Structured answer value or approval outcome.
      */
-    async answer(value) {
-        const pending = this.store.state.pending[0];
-        if (!pending)
-            throw new Error('No pending interaction');
-        await this.mutations.admit(this.sessionId, 'normal', () => this.reply(pending.eventId, { kind: 'result', value }));
-        this.interactions.delete(pending.eventId);
-        this.store.update({});
-    }
+    async answer(value) { await this.interactions.answer(value); }
     /** Restrict an approval command to an approval request.
      * @param allowed - Whether the request is approved once.
      */
-    async approve(allowed) {
-        const pending = this.store.state.pending[0];
-        if (pending?.kind !== 'approval')
-            throw new Error('No pending approval');
-        await this.mutations.admit(this.sessionId, 'normal', () => this.reply(pending.eventId, { kind: 'result', value: allowed ? 'allowed-once' : 'rejected' }));
-        this.interactions.delete(pending.eventId);
-        this.store.update({});
-    }
+    async approve(allowed) { await this.interactions.approve(allowed); }
     /** Dismiss the whole selected-session question set without answering it.
      *
      * The Web client's close button settles the same waterfall the same way — reject with
      * `ASK_CANCELLED` — so the host records a user cancellation rather than an answer. A question
      * batch is answered as one request, so dismissals also discard partial local answers.
      */
-    async dismissQuestion() {
-        const pending = this.store.state.pending[0];
-        if (pending?.kind !== 'question')
-            throw new Error('No pending question');
-        await this.mutations.admit(this.sessionId, 'normal', () => this.reply(pending.eventId, { kind: 'rejected', error: {
-                name: 'UserQuestionError', message: 'the user cancelled ask_user_question', code: 'ASK_CANCELLED',
-            } }));
-        this.interactions.delete(pending.eventId);
-        this.store.update({});
-    }
+    async dismissQuestion() { await this.interactions.dismissQuestion(); }
     /** Add a page before the retained window using its fixed opening cut.
      *
      * Reclamation is deliberately not pinned here. Every caller that needs the fetched page to
@@ -665,19 +594,7 @@ export class SessionController {
      * @param signal - Cancels local paging without interrupting the remote agent.
      * @param transcript - Transcript to extend; defaults to the live one.
      */
-    async older(signal, transcript = this.info.record) {
-        const selection = this.store.selection();
-        if (!transcript.ready || !transcript.hasMore || transcript.beforeSeq === undefined)
-            return;
-        const result = await this.host.require().call('session/page', { request: {
-                address: { kind: 'session', sessionId: this.sessionId }, throughSeq: transcript.cursor,
-                beforeSeq: transcript.beforeSeq, maxMessages: 80,
-            } }, signal);
-        if (selection !== this.store.selection())
-            return;
-        transcript.addPage(result);
-        this.store.update({});
-    }
+    async older(signal, transcript = this.info.record) { await this.history.older(signal, transcript); }
     /** Recall one step through the session's prompt index; navigation never touches the network.
      * @param direction - Negative for older input, positive for newer input.
      * @param current - Composer content before recall began, restored at the newest position.
@@ -739,24 +656,6 @@ export class SessionController {
             return false;
         return this.prompts.prepend(this.info.record.promptsBefore(oldest)) > 0;
     }
-    /** Seed recall from a complete cached entry, so an open that follows a scan costs no request.
-     * @param sessionId - Session being opened.
-     * @returns Whether the cache covered this session.
-     */
-    adoptCachedPrompts(sessionId) {
-        const cached = this.promptCache.get(sessionId);
-        if (!cached?.complete)
-            return false;
-        const oldest = this.prompts.oldest;
-        const older = oldest === undefined ? cached.prompts : cached.prompts.filter(prompt => prompt.seq < oldest);
-        this.prompts.prepend(older);
-        // Same budget as the walk it replaces: `settle` may shed the oldest prefix, and `markComplete`
-        // then refuses, so the lazy backward step stays available for whatever was shed.
-        this.prompts.settle();
-        this.prompts.markComplete();
-        this.store.update({});
-        return true;
-    }
     /** Fold one history page the cost scan already read into the prompt cache.
      *
      * The scan reads every session's whole history on connect, so this is where two readers stop
@@ -773,165 +672,34 @@ export class SessionController {
     rememberScanDone(sessionId) {
         this.promptCache.observe(sessionId, [], true);
     }
-    /** Fold every prompt the host still holds into the recall index, in the background.
-     *
-     * Session start delivers only the newest window, so without this the arrows could reach older
-     * prompts but not show them without paging first. Each page is parsed into a temporary transcript
-     * and only its prompts are kept, so the live record, its memory window and the row cache never
-     * grow. The walk is bounded and the next selection cancels it; anything past the bound is still
-     * reachable through the lazy backward step.
-     * @param sessionId - Session being opened.
-     * @param selection - Selector generation that must still be current.
-     */
-    backfillPrompts(sessionId, selection) {
-        this.promptBackfill?.abort();
-        const abort = new AbortController();
-        this.promptBackfill = abort;
-        void (async () => {
-            try {
-                while (!this.info.record.ready) {
-                    abort.signal.throwIfAborted();
-                    await delay(20, undefined, { signal: abort.signal });
-                }
-                // A cost scan or an earlier open may already have this session's prompts cached.
-                if (this.adoptCachedPrompts(sessionId))
-                    return;
-                const throughSeq = this.info.record.readThrough;
-                let beforeSeq = this.info.record.beforeSeq;
-                let hasMore = this.info.record.hasMore;
-                for (let page = 0; hasMore && beforeSeq !== undefined && page < PROMPT_BACKFILL_PAGES; page++) {
-                    abort.signal.throwIfAborted();
-                    if (selection !== this.store.selection())
-                        return;
-                    const result = object(await this.host.require().call('session/page', { request: {
-                            address: { kind: 'session', sessionId }, throughSeq, beforeSeq, maxMessages: 80,
-                        } }, abort.signal));
-                    abort.signal.throwIfAborted();
-                    if (selection !== this.store.selection())
-                        return;
-                    const temporary = new Transcript();
-                    try {
-                        temporary.accept({ type: 'snapshot', cursor: throughSeq, assistantStream: { revision: 0 }, records: result.records, hasMore: result.hasMore });
-                        const next = temporary.beforeSeq;
-                        if (temporary.hasMore && (next === undefined || next >= beforeSeq))
-                            throw new Error('Host history page did not advance');
-                        this.prompts.prepend(temporary.promptsSince(-1).prompts);
-                        beforeSeq = next;
-                        hasMore = temporary.hasMore;
-                    }
-                    finally {
-                        temporary.dispose();
-                    }
-                    // A scan that finished while this walk ran already established the same list.
-                    if (this.adoptCachedPrompts(sessionId))
-                        return;
-                }
-                this.prompts.settle();
-                // Only a walk that ended because the host said "no more" makes the index exhaustive; one
-                // stopped by the page bound leaves the lazy backward step in charge of the rest.
-                if (!hasMore)
-                    this.prompts.markComplete();
-                // Cache only what the walk established: advertising a capped or shed list would let a later
-                // open skip a fetch it still needs.
-                if (!hasMore)
-                    this.promptCache.put(sessionId, { prompts: this.prompts.durableItems, complete: this.prompts.exhausted });
-                this.store.update({});
-            }
-            catch {
-                // A cancelled, disconnected or unavailable history leaves the lazy backward step in charge.
-            }
-            finally {
-                if (this.promptBackfill === abort)
-                    this.promptBackfill = undefined;
-            }
-        })();
-    }
     /** 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.info.record;
-        if (!source.ready)
-            throw new Error('Wait for the session snapshot');
-        const sessionId = this.sessionId;
-        const selection = this.store.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 === SEARCH_MATCH_LIMIT) {
-                    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.require().call('session/page', { request: {
-                    address: { kind: 'session', sessionId }, throughSeq, beforeSeq, maxMessages: 80,
-                } }, signal));
-            signal.throwIfAborted();
-            if (selection !== this.store.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.
+    async searchHistory(query, signal) { return this.history.searchHistory(query, signal); }
+    /** Select a readable window by sequence; temporary records never escape to the UI.
      * @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.info.record;
-        const selection = this.store.selection();
-        const page = object(await this.host.require().call('session/page', { request: {
-                address: { kind: 'session', sessionId: this.sessionId }, throughSeq: source.readThrough,
-                beforeSeq: target + 1, maxMessages: 80,
-            } }, signal));
+    async openHistory(target, signal) {
         signal.throwIfAborted();
-        if (selection !== this.store.selection())
-            throw new Error('Session changed while opening history');
-        const window = new Transcript();
+        const selection = this.store.selection();
+        const record = this.info.record;
+        const displayed = this.info.window ?? record;
+        const loaded = displayed.messages.some(message => message.seq === target) ? displayed
+            : record.messages.some(message => message.seq === target) ? record : undefined;
+        const window = loaded ?? await this.history.historyAt(target, signal);
         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;
+            signal.throwIfAborted();
+            if (selection !== this.store.selection() || record !== this.info.record || this.store.state.screen !== 'chat') {
+                throw new Error('Session changed while opening history');
+            }
+            this.setViewWindow(window === record ? undefined : window);
         }
         catch (error) {
-            window.dispose();
+            if (!loaded)
+                window.dispose();
             throw error;
         }
     }
@@ -939,21 +707,7 @@ export class SessionController {
      * @param target - Visible record sequence, or first for the oldest available history.
      * @param signal - Cancels local paging without interrupting the remote agent.
      */
-    async historyThrough(target, signal) {
-        const transcript = this.info.record;
-        if (!transcript.ready)
-            throw new Error('Wait for the session snapshot');
-        while (transcript.hasMore && (target === 'first' || transcript.beforeSeq !== undefined && transcript.beforeSeq > target)) {
-            signal.throwIfAborted();
-            const before = transcript.beforeSeq;
-            await this.older(signal);
-            if (this.info.record !== transcript)
-                throw new Error('Session changed while loading history');
-            if (transcript.hasMore && (before === undefined || transcript.beforeSeq === undefined || transcript.beforeSeq >= before)) {
-                throw new Error('Host history page did not advance');
-            }
-        }
-    }
+    async historyThrough(target, signal) { await this.history.historyThrough(target, signal); }
     /** Reclaim reloadable history unless the user is reading away from the tail.
      * @returns Number of removed records.
      */
@@ -967,8 +721,8 @@ export class SessionController {
     }
     /** Release the selected transcript and its layout caches. */
     releaseTranscript() {
-        this.promptBackfill?.abort();
-        this.promptBackfill = undefined;
+        this.history.cancel();
+        this.promptBackfill.cancel();
         this.info.reset();
     }
     /** @returns The selected session identity, or a `Select a session first` failure. */
@@ -977,8 +731,4 @@ export class SessionController {
             throw new Error('Select a session first');
         return this.store.state.sessionId;
     }
-    /** Answer one retained waterfall through the connection's event-result endpoint. */
-    async reply(eventId, outcome) {
-        await this.connection.reply(eventId, outcome);
-    }
 }