@itookit/dsht 0.3.8 → 0.5.2

package/dist/session/controller.js

@@ -1,20 +1,23 @@
 /** 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";
-import { releaseHistoryLayout } from "./history.js";
-import { resolveTarget, sessionLabel } from "./navigation.js";
+import { historyLayout, releaseHistoryLayout } from "./history.js";
+import { resolveTarget } from "./navigation.js";
+import { sessionLabel } from "../session-title.js";
 import { fileReferences } from "./references.js";
+import { SessionRuntime } from "./runtime.js";
 import { PromptCache } from "./info.js";
-import { recordPrompts, Transcript, toolLine } from "./transcript.js";
+import { SessionMutationGate } from "./mutation-gate.js";
+import { recordPrompts } from "./transcript.js";
+import { projectionSnapshot } from "../transport/events.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;
@@ -22,27 +25,69 @@ 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. */
+    runtime = new SessionRuntime();
     /** Cancels the background prompt backfill of the previous selection. */
     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;
     interruptTask;
     admission;
-    constructor(store, host, connection, historyLimits) {
+    /** Admission order of this session's writes, so two concurrent decisions cannot interleave. */
+    mutations;
+    constructor(store, host, connection, historyLimits, report) {
         this.store = store;
         this.host = host;
         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() {
         const id = this.store.state.sessionId;
-        return id !== undefined && (this.connection.runningFor(id)
+        return id !== undefined && (this.runtime.runningFor(id)
             ?? this.store.state.sessions.find(row => row.sessionId === id)?.running === true);
     }
     /** Current title projection, falling back to the list title and then the session ID. */
@@ -50,19 +95,19 @@ export class SessionController {
         const id = this.store.state.sessionId;
         if (!id)
             return;
-        const title = this.connection.telemetryView().view(id).values.title;
+        const title = this.runtime.telemetry.view(id).values.title;
         const row = this.store.state.sessions.find(item => item.sessionId === id);
         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() {
+    sessionMode(presets = []) {
         if (!this.store.state.sessionId)
             return undefined;
-        const id = this.connection.telemetryView().view(this.store.state.sessionId).values.agentPreset;
+        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;
     }
@@ -70,40 +115,60 @@ export class SessionController {
     get workingSince() {
         if (!this.running || !this.store.state.sessionId)
             return undefined;
-        return this.info.record.activeTurnStartedAt ?? this.connection.observedAt(this.store.state.sessionId);
+        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. */
+    get window() { return this.info.window; }
+    /** Show a detached history window, releasing the one it replaces.
+     * @param window - Record to display, or undefined to return to the live transcript.
+     */
+    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({});
+    }
+    /** @returns Host projection store of the current generation, owned by this session's runtime. */
+    get telemetry() { return this.runtime.telemetry; }
+    /** Lay out one record for a terminal width.
+     *
+     * The projection engine stays in this domain; the UI receives plain rows and offsets instead of
+     * importing it, and `Reasoning` for committed messages is always the folded default.
+     */
+    render(input) {
+        return historyLayout(input.transcript, input.width, 'row', input.folds, input.liveReasoning);
+    }
+    /** Apply one normalized control frame to this session's runtime. */
+    acceptControl(frame) { this.runtime.acceptControl(frame); }
     /** Whether reading protects the loaded window, suspending history reclamation. */
-    get pinned() { return this.info.view.pinned; }
+    get pinned() { return this.historyPinned; }
     /** Drop generation-scoped state before a new connection generation begins. */
-    beginGeneration() { this.stoppingSession = undefined; }
+    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.agentId === 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
@@ -112,35 +177,22 @@ 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 (typeof frame.agentId !== 'string')
-                continue;
-            counts.set(frame.agentId, (counts.get(frame.agentId) ?? 0) + 1);
-        }
-        return counts;
-    }
-    /** Retain a recognized host waterfall; unknown events stay with the connection to delegate.
-     * @param frame - One decoded waterfall frame.
-     * @returns Whether this domain retained the frame for an answer.
+    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.
      */
-    waterfall(frame) {
-        if (!['approval/request', 'user-questions/request'].includes(string(frame.event)))
-            return false;
-        this.interactions.set(string(frame.eventId), frame);
-        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.
      */
     status(sessionId, running) {
+        this.runtime.accept(sessionId, running);
         if (!running && this.stoppingSession === sessionId)
             this.stoppingSession = undefined;
         this.store.update({ sessions: this.store.state.sessions.map(row => row.sessionId === sessionId ? { ...row, running } : row),
@@ -148,11 +200,11 @@ export class SessionController {
     }
     /** Surface a host-reported error for the selected session.
      * @param sessionId - Session the host reported on.
-     * @param error - Error payload as delivered by the host.
+     * @param error - Already-normalized error text.
      */
     reportError(sessionId, error) {
         if (sessionId === this.store.state.sessionId)
-            this.store.update({ status: 'Agent error', error: errorText(error) });
+            this.store.update({ status: 'Agent error', lastFailure: error });
     }
     /** Stop the selected turn, or allow exit only while idle. Repeated keys share one request.
      * @param force - Send an explicit cancellation even when the cached running flag is idle.
@@ -162,23 +214,27 @@ export class SessionController {
         if (this.interruptTask)
             return this.interruptTask;
         if (!force && !this.running && !this.admission && this.store.state.pending.length === 0) {
-            return Promise.resolve(!this.store.state.busy);
+            // An idle press may exit only when no operation owns the client; the store's failure line is
+            // not that fact, so the application asks itself.
+            return Promise.resolve(!this.store.busy());
         }
         const sessionId = this.sessionId;
         this.stoppingSession = sessionId;
-        this.store.update({ status: 'Stopping…', error: '' });
+        this.store.update({ status: 'Stopping…', lastFailure: '' });
         const task = (async () => {
             try {
                 // Admission must settle before cancellation can address the newly submitted turn.
                 // The prompt caller reports admission failures; an existing turn still needs cancellation.
+                // This wait stays outside the gate: a control admission overtakes the *waiting* queue, and
+                // holding the gate while waiting here would block the very writes it precedes.
                 await this.admission?.catch(() => undefined);
-                await this.host.require().call('session/cancel', { request: { sessionId } });
+                await this.mutations.admit(sessionId, 'control', () => this.host.require().call('session/cancel', { request: { sessionId } }));
                 if (this.stoppingSession === sessionId && this.store.state.sessionId === sessionId)
                     this.store.update({ status: 'Cancellation requested · waiting for host' });
             }
             catch (error) {
                 this.stoppingSession = undefined;
-                this.store.update({ status: 'Cancellation failed', error: errorText(error) });
+                this.store.update({ status: 'Cancellation failed', lastFailure: errorText(error) });
             }
             return false;
         })();
@@ -190,23 +246,34 @@ export class SessionController {
      * @param pinned - Whether the main transcript is actively being read away from its tail.
      */
     pinHistory(pinned) {
-        this.info.view.pinned = pinned;
+        if (this.historyPinned === pinned)
+            return;
+        this.historyPinned = pinned;
         if (!pinned && this.reclaimHistory())
             this.store.update({});
     }
     /** Cancel the active turn; pending queue items remain host-owned. */
     async cancelTurn() {
-        await this.host.require().call('session/cancel', { request: { sessionId: this.sessionId } });
+        const sessionId = this.sessionId;
+        // Cancellation is a control action: it may overtake queued writes, since its whole value is speed.
+        await this.mutations.admit(sessionId, 'control', () => this.host.require().call('session/cancel', { request: { sessionId } }));
         this.store.update({ status: 'Cancellation requested' });
     }
     /** 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() { 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.
@@ -219,9 +286,9 @@ export class SessionController {
         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.connection.runningFor(string(row.sessionId))
-                    && !(this.connection.telemetryView().view(string(row.sessionId)).queued ?? 0)
-                    && !(this.connection.telemetryView().view(string(row.sessionId)).jobs ?? 0)
+                    && !this.runtime.runningFor(string(row.sessionId))
+                    && !(this.runtime.telemetry.view(string(row.sessionId)).queued ?? 0)
+                    && !(this.runtime.telemetry.view(string(row.sessionId)).jobs ?? 0)
                     && !(this.store.state.sessionId === row.sessionId && this.admission) };
     }
     /** Apply a confirmed removal or freshly verified empty-session archival; directories and logs are preserved.
@@ -229,11 +296,14 @@ export class SessionController {
      */
     async removeTarget(target) {
         const client = this.host.require();
-        const receipt = object(await client.call(target.kind === 'workspace' ? 'workspace/delete' : 'workspace/archiveSession', {
-            request: target.kind === 'workspace' ? { workspaceId: target.id } : { sessionId: target.id },
-        }));
+        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)
@@ -245,58 +315,30 @@ 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({ error: `Removal completed; list refresh failed: ${errorText(error)}` });
+            this.store.update({ lastFailure: `Removal completed; list refresh failed: ${errorText(error)}` });
         }
     }
     /** 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
@@ -305,44 +347,58 @@ 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)
+    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
+     * follows the new session and never touches the reader's transcript.
+     * @param title - Session title to apply; hosts without a title service keep the default.
+     * @returns The new session's id, or undefined when its identity could not be read.
+     */
+    async createNamedSession(title) {
+        const workspaceId = this.store.state.workspaceId;
+        if (!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));
+        const created = object(await this.host.require().call('session/create', { request: { workspaceId } }));
+        const sessionId = string(created.sessionId);
+        try {
+            await this.host.require().call('session/rename', { request: { sessionId, title } });
+        }
+        catch { /* A deployment without the title service still gets a usable session. */ }
+        return sessionId;
+    }
+    /** Stop a session this client owns but has not selected, such as a verifier's.
+     *
+     * Killing the child client leaves the host's agent generation running, so the turn has to be
+     * cancelled on the host itself.
+     * @param sessionId - Session whose turn should stop.
+     */
+    async cancelNamedSession(sessionId) {
+        // Keyed by the session being stopped, not the selection: the verifier's session is someone else's.
+        await this.mutations.admit(sessionId, 'control', () => this.host.require().call('session/cancel', { request: { sessionId } }));
     }
     /** Replace the selected transcript and cancel its preceding follow stream.
      * @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();
@@ -353,8 +409,9 @@ export class SessionController {
         const workspace = this.store.state.workspaces.find(item => array(item.sessionIds).includes(sessionId));
         const workspaceId = workspace ? string(workspace.workspaceId)
             : this.store.state.sessions.some(item => item.sessionId === sessionId) ? undefined : this.store.state.workspaceId;
-        this.connection.observe(sessionId);
-        this.store.update({ sessionId, workspaceId, showAllSessions: false, screen: 'chat', status: 'Loading session…' });
+        this.runtime.observe(sessionId);
+        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 },
         }, {
@@ -367,7 +424,7 @@ export class SessionController {
                     this.reclaimHistory();
                     const frame = object(value);
                     if (frame.type === 'snapshot')
-                        this.connection.telemetryView().snapshot(sessionId, frame.projections);
+                        this.runtime.telemetry.snapshot(sessionId, projectionSnapshot(frame.projections));
                     this.store.update({ status: this.stoppingSession === sessionId ? this.store.state.status : transcript.hasLiveContent ? 'Responding…' : 'Connected' });
                 }
                 catch (error) {
@@ -378,26 +435,15 @@ export class SessionController {
                 if (selection !== this.store.selection())
                     return;
                 transcript.ready = false;
-                this.store.update({ status: 'Session disconnected', error: errorText(error ?? 'Session stream ended') });
+                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.
@@ -434,11 +480,14 @@ export class SessionController {
      * @returns The host's successful command result text.
      */
     async command(line, signal) {
-        if (!this.info.record.ready)
-            throw new Error('Wait for the session snapshot before running commands');
-        const execution = await this.host.require().call('commands/execute', {
-            agentId: this.sessionId, line, submittedAttachments: [],
-        }, signal, null);
+        const sessionId = this.sessionId;
+        // The section decides and issues; the host's answer is awaited outside the gate, because a
+        // compaction can take minutes and must not hold every other write on this session.
+        const execution = await this.mutations.admit(sessionId, 'normal', () => {
+            if (!this.info.record.ready)
+                throw new Error('Wait for the session snapshot before running commands');
+            return this.host.require().call('commands/execute', { agentId: 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);
@@ -458,7 +507,10 @@ export class SessionController {
      * @param itemId - Queue occurrence identity from session/control.
      */
     async removeQueued(itemId) {
-        await this.host.require().call('session/updateQueue', { request: { sessionId: this.sessionId, itemId, action: { kind: 'remove' } } });
+        const sessionId = this.sessionId;
+        await this.mutations.admit(sessionId, 'normal', () => this.host.require().call('session/updateQueue', {
+            request: { 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.
@@ -480,16 +532,23 @@ export class SessionController {
      * @param text - Composed prompt text.
      */
     async prompt(text) {
-        if (this.store.state.pending.length)
-            throw new Error('Answer the pending question or approval first');
-        this.stoppingSession = undefined;
-        if (!this.info.record.ready)
-            throw new Error('Wait for the session snapshot before sending');
-        const admission = this.host.require().call('session/prompt', { request: {
-                sessionId: this.sessionId, requestId: randomUUID(), mode: this.running ? 'steer' : 'queue',
-                content: [{ type: 'text', text }], clientTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-            } });
-        this.admission = admission;
+        const sessionId = this.sessionId;
+        // Deciding steer-versus-queue and issuing the request are one admitted step: the loop's own sends
+        // and everything the reader types go through this same point, so two of them cannot be decided
+        // against the same stale running state. The host's answer is awaited outside the gate.
+        const admission = await this.mutations.admit(sessionId, 'normal', () => {
+            if (this.store.state.pending.length)
+                throw new Error('Answer the pending question or approval first');
+            this.stoppingSession = undefined;
+            if (!this.info.record.ready)
+                throw new Error('Wait for the session snapshot before sending');
+            const issued = this.host.require().call('session/prompt', { request: {
+                    sessionId, requestId: randomUUID(), mode: this.running ? 'steer' : 'queue',
+                    content: [{ type: 'text', text }], clientTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                } });
+            this.admission = issued;
+            return issued;
+        });
         try {
             await admission;
         }
@@ -499,41 +558,32 @@ export class SessionController {
         }
         this.store.update({ status: 'Accepted · waiting for host' });
     }
+    /** Send one prompt the client assembled, keeping its durable echo out of composer recall.
+     *
+     * The host records every prompt as a user message, so an agent loop that submits a turn per
+     * attempt would otherwise crowd out the prompts the operator actually typed. Suppressing the text
+     * before sending is what makes the later echo invisible to ↑/↓.
+     * @param text - Prompt the client assembled, not text the operator typed.
+     */
+    async promptInternal(text) {
+        this.prompts.suppress(text);
+        await this.prompt(text);
+    }
     /** 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.reply(pending, { kind: 'result', value });
-        this.interactions.delete(string(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) {
-        if (this.store.state.pending[0]?.event !== 'approval/request')
-            throw new Error('No pending approval');
-        await this.answer(allowed ? 'allowed-once' : 'rejected');
-    }
+    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?.event !== 'user-questions/request')
-            throw new Error('No pending question');
-        await this.reply(pending, { kind: 'rejected', error: {
-                name: 'UserQuestionError', message: 'the user cancelled ask_user_question', code: 'ASK_CANCELLED',
-            } });
-        this.interactions.delete(string(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
@@ -544,103 +594,13 @@ 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.
      * @returns The recalled prompt, or the unsent draft.
      */
     recall(direction, current) { return this.prompts.move(direction, current); }
-    /** Composer draft, caret and parked draft, as the selected session holds them. */
-    get composer() { return this.info.composer; }
-    /** Replace the composer text and caret, publishing only when either actually changed. */
-    setComposer(draft, cursor = draft.length) {
-        const composer = this.info.composer;
-        if (composer.draft === draft && composer.cursor === cursor)
-            return;
-        composer.draft = draft;
-        composer.cursor = cursor;
-        this.store.update({});
-    }
-    /** Move the caret without changing the text. */
-    setComposerCursor(cursor) {
-        const composer = this.info.composer;
-        if (composer.cursor === cursor)
-            return;
-        composer.cursor = cursor;
-        this.store.update({});
-    }
-    /** Move a non-empty draft aside while a dialog owns the keyboard. */
-    parkComposer() {
-        const composer = this.info.composer;
-        if (composer.draft === '')
-            return;
-        composer.parked = composer.draft;
-        composer.draft = '';
-        composer.cursor = 0;
-        this.store.update({});
-    }
-    /** Give a parked draft back once no dialog needs the keyboard. */
-    restoreComposer() {
-        const composer = this.info.composer;
-        if (composer.parked === '')
-            return;
-        composer.draft = composer.parked;
-        composer.cursor = composer.parked.length;
-        composer.parked = '';
-        this.store.update({});
-    }
-    /** How the selected session's record is being read right now. */
-    get view() { return this.info.view; }
-    /** Show a detached history window, releasing the one it replaces.
-     * @param window - Record to display, or undefined to return to the live transcript.
-     */
-    setViewWindow(window) {
-        if (this.info.view.window === window)
-            return;
-        this.info.closeWindow();
-        this.info.view.window = window;
-        this.store.update({});
-    }
-    /** Move the reader's position inside the displayed record.
-     * @param scroll - Rows scrolled back from the live end.
-     */
-    setScroll(scroll) {
-        if (this.info.view.scroll === scroll)
-            return;
-        this.info.view.scroll = scroll;
-        this.store.update({});
-    }
-    /** Replace the set of expanded reasoning blocks, keyed by message sequence.
-     * @param folds - Sequences to expand beyond the default fold.
-     */
-    setFolds(folds) {
-        if (this.info.view.folds === folds)
-            return;
-        this.info.view.folds = folds;
-        this.store.update({});
-    }
-    /** Set the fold mode of the live attempt's completed reasoning.
-     * @param reasoning - `row` to fold, `full` to keep the streamed text.
-     */
-    setLiveReasoning(reasoning) {
-        if (this.info.view.liveReasoning === reasoning)
-            return;
-        this.info.view.liveReasoning = reasoning;
-        this.store.update({});
-    }
     /** Local answer state for the selected session's pending waterfalls. */
     get interaction() { return this.info.interaction; }
     /** Replace the partly collected answers, keyed by the waterfall event id.
@@ -668,73 +628,6 @@ export class SessionController {
         this.info.interaction.approval = approval;
         this.store.update({});
     }
-    /** Composer-adjacent `@` reference menu state. */
-    get reference() { return this.info.reference; }
-    /** Highlight one row of the open reference menu.
-     * @param index - Row index into the current matches.
-     */
-    setReferenceIndex(index) {
-        if (this.info.reference.index === index)
-            return;
-        this.info.reference.index = index;
-        this.store.update({});
-    }
-    /** Remember the draft that dismissed the reference menu, so it does not reopen while it stands.
-     * @param draft - Composer text at dismissal, or undefined to allow the menu again.
-     */
-    setReferenceDismissed(draft) {
-        if (this.info.reference.dismissed === draft)
-            return;
-        this.info.reference.dismissed = draft;
-        this.store.update({});
-    }
-    /** Panels the selected session has open. */
-    get panels() { return this.info.panels; }
-    /** Show or hide the reasoning panel.
-     * @param open - Whether `/think` is open.
-     */
-    openThoughts(open) {
-        if (this.info.panels.thoughts === open)
-            return;
-        this.info.panels.thoughts = open;
-        this.store.update({});
-    }
-    /** Show or hide the pending-input panel.
-     * @param open - Whether `/queue` is open.
-     */
-    openQueue(open) {
-        if (this.info.panels.queue === open)
-            return;
-        this.info.panels.queue = open;
-        this.store.update({});
-    }
-    /** Show the model dialog at one step, or close it.
-     * @param model - Catalog plus the provider or model being inspected; undefined closes the dialog.
-     */
-    setModelPanel(model) {
-        if (this.info.panels.model === model)
-            return;
-        this.info.panels.model = model;
-        this.store.update({});
-    }
-    /** Show the history or content-search dialog, or close it.
-     * @param history - Query, content-search mode and matches; undefined closes the dialog.
-     */
-    setHistoryPanel(history) {
-        if (this.info.panels.history === history)
-            return;
-        this.info.panels.history = history;
-        this.store.update({});
-    }
-    /** Show the host session-search results, or close them.
-     * @param search - Query, results and truncation flag; undefined closes the dialog.
-     */
-    setSearchPanel(search) {
-        if (this.info.panels.search === search)
-            return;
-        this.info.panels.search = search;
-        this.store.update({});
-    }
     /** Remember a locally submitted command, which never becomes a durable session record. */
     recordRecall(value) { this.prompts.record(value); }
     /** Leave recall navigation because the composer was edited or replaced. */
@@ -763,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
@@ -797,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;
         }
     }
@@ -963,26 +707,12 @@ 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.
      */
     reclaimHistory() {
-        if (this.info.view.pinned || !this.store.state.online)
+        if (this.historyPinned || !this.store.state.online)
             return 0;
         const removed = this.info.record.trimHistory(this.historyLimits);
         if (removed)
@@ -991,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. */
@@ -1001,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(frame, outcome) {
-        await this.connection.reply(frame, outcome);
-    }
 }