@itookit/dsht 0.3.7 → 0.5.1

package/dist/session/controller.js

@@ -4,11 +4,16 @@ 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, Transcript } from "./transcript.js";
+import { projectionSnapshot } from "../transport/events.js";
+import { toolLine } from "../text.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. */
@@ -23,6 +28,10 @@ export class SessionController {
     historyLimits;
     follow;
     interactions = new Map();
+    /** 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. */
@@ -33,16 +42,19 @@ export class SessionController {
     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);
     }
     /** 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,7 +62,7 @@ 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;
@@ -59,7 +71,7 @@ export class SessionController {
     get sessionMode() {
         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);
@@ -70,7 +82,7 @@ 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() {
@@ -83,10 +95,34 @@ export class SessionController {
     }
     /** 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;
+        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.store.bumpSelection();
@@ -102,7 +138,7 @@ export class SessionController {
      * @returns Retained question and approval frames for that session.
      */
     pendingFor(state) {
-        return [...this.interactions.values()].filter(frame => frame.agentId === state.sessionId);
+        return [...this.interactions.values()].filter(frame => frame.sessionId === state.sessionId);
     }
     /** Unanswered interactions by session, so a list can show who is waiting without opening them.
      *
@@ -115,20 +151,27 @@ export class SessionController {
     pendingCounts() {
         const counts = new Map();
         for (const frame of this.interactions.values()) {
-            if (typeof frame.agentId !== 'string')
+            if (frame.sessionId === '')
                 continue;
-            counts.set(frame.agentId, (counts.get(frame.agentId) ?? 0) + 1);
+            counts.set(frame.sessionId, (counts.get(frame.sessionId) ?? 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.
+    /** 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)))
+    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.interactions.set(string(frame.eventId), frame);
         this.store.update({});
         return true;
     }
@@ -141,6 +184,7 @@ export class SessionController {
      * @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 +192,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 +206,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,13 +238,17 @@ 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.
@@ -207,6 +259,18 @@ export class SessionController {
         const [workspaces, sessions] = await Promise.all([client.listWorkspaces(), client.listSessions()]);
         this.store.update({ screen, workspaces, sessions });
     }
+    /** 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;
+    }
     /** 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 +283,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,9 +293,10 @@ 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 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;
         if (target.kind === 'session') {
@@ -252,7 +317,7 @@ export class SessionController {
             await this.showPicker(target.kind === 'workspace' ? 'workspaces' : 'sessions');
         }
         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.
@@ -297,6 +362,32 @@ export class SessionController {
     }
     /** Prompt for a host path without starting a local agent. */
     enterPath() { this.store.update({ screen: 'path' }); }
+    /** 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
+     * path segments so `/srv/app-old` cannot match `/srv/app`. A remote host's paths usually differ
+     * from the client's, in which case nothing matches and the picker stays exactly as before.
+     * @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;
+    }
     /** Register a host directory and move to its session picker.
      * @param path - Absolute directory path on the host.
      */
@@ -313,6 +404,35 @@ export class SessionController {
         const result = object(await this.host.require().call('session/create', { request: { workspaceId: this.store.state.workspaceId } }));
         await this.selectSession(string(result.sessionId));
     }
+    /** 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 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.
      */
@@ -327,7 +447,7 @@ 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.runtime.observe(sessionId);
         this.store.update({ sessionId, workspaceId, showAllSessions: false, screen: 'chat', status: 'Loading session…' });
         this.follow = this.host.require().subscribe('session/follow', {
             request: { address: { kind: 'session', sessionId }, maxMessages: 80, assistantStream: true },
@@ -341,7 +461,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) {
@@ -352,7 +472,7 @@ 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);
@@ -408,11 +528,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);
@@ -432,7 +555,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.
@@ -454,16 +580,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;
         }
@@ -473,6 +606,17 @@ 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.
      */
@@ -480,17 +624,20 @@ export class SessionController {
         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));
+        await this.mutations.admit(this.sessionId, 'normal', () => this.reply(pending.eventId, { kind: 'result', value }));
+        this.interactions.delete(pending.eventId);
         this.store.update({});
     }
     /** 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')
+        const pending = this.store.state.pending[0];
+        if (pending?.kind !== 'approval')
             throw new Error('No pending approval');
-        await this.answer(allowed ? 'allowed-once' : 'rejected');
+        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({});
     }
     /** Dismiss the whole selected-session question set without answering it.
      *
@@ -500,12 +647,12 @@ export class SessionController {
      */
     async dismissQuestion() {
         const pending = this.store.state.pending[0];
-        if (pending?.event !== 'user-questions/request')
+        if (pending?.kind !== 'question')
             throw new Error('No pending question');
-        await this.reply(pending, { kind: 'rejected', error: {
+        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(string(pending.eventId));
+            } }));
+        this.interactions.delete(pending.eventId);
         this.store.update({});
     }
     /** Add a page before the retained window using its fixed opening cut.
@@ -537,84 +684,6 @@ export class SessionController {
      * @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.
@@ -642,73 +711,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. */
@@ -956,7 +958,7 @@ export class SessionController {
      * @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)
@@ -976,7 +978,7 @@ export class SessionController {
         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);
+    async reply(eventId, outcome) {
+        await this.connection.reply(eventId, outcome);
     }
 }