@itookit/dsht 0.3.3 → 0.3.7

package/dist/session/controller.js

@@ -7,11 +7,14 @@ import { saveTranscriptHtml } from "./export-html.js";
 import { releaseHistoryLayout } from "./history.js";
 import { resolveTarget, sessionLabel } from "./navigation.js";
 import { fileReferences } from "./references.js";
-import { Transcript, toolLine } from "./transcript.js";
+import { PromptCache } from "./info.js";
+import { recordPrompts, Transcript, toolLine } from "./transcript.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;
@@ -20,7 +23,13 @@ export class SessionController {
     historyLimits;
     follow;
     interactions = new Map();
-    historyPinned = false;
+    /** 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. */
+    get info() { return this.store.state.session; }
+    get prompts() { return this.info.prompts; }
     stoppingSession;
     interruptTask;
     admission;
@@ -61,7 +70,7 @@ export class SessionController {
     get workingSince() {
         if (!this.running || !this.store.state.sessionId)
             return undefined;
-        return this.store.state.transcript.activeTurnStartedAt ?? this.connection.observedAt(this.store.state.sessionId);
+        return this.info.record.activeTurnStartedAt ?? this.connection.observedAt(this.store.state.sessionId);
     }
     /** Present only sessions explicitly accounted to the selected workspace. */
     get visibleSessions() {
@@ -75,13 +84,13 @@ 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; }
     /** Whether reading protects the loaded window, suspending history reclamation. */
-    get pinned() { return this.historyPinned; }
+    get pinned() { return this.info.view.pinned; }
     /** Drop generation-scoped state before a new connection generation begins. */
     beginGeneration() { this.stoppingSession = undefined; }
     /** Invalidate in-flight work and drop transient interactions when a generation ends. */
     endGeneration() {
         this.store.bumpSelection();
-        this.store.state.transcript.ready = false;
+        this.info.record.ready = false;
         this.interactions.clear();
     }
     /** Wait for an in-flight cancellation so shutdown leaves nothing running. */
@@ -95,6 +104,23 @@ export class SessionController {
     pendingFor(state) {
         return [...this.interactions.values()].filter(frame => frame.agentId === state.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
+     * client already retains them to answer later, so the counts are a fact of this generation rather
+     * than a new subscription. They live only as long as the connection: a reconnect clears the map
+     * 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.
@@ -164,7 +190,7 @@ export class SessionController {
      * @param pinned - Whether the main transcript is actively being read away from its tail.
      */
     pinHistory(pinned) {
-        this.historyPinned = pinned;
+        this.info.view.pinned = pinned;
         if (!pinned && this.reclaimHistory())
             this.store.update({});
     }
@@ -237,7 +263,7 @@ export class SessionController {
         this.follow?.cancel();
         this.follow = undefined;
         this.releaseTranscript();
-        this.store.update({ workspaceId, sessionId: undefined, showAllSessions: false, transcript: new Transcript(), screen: 'sessions' });
+        this.store.update({ workspaceId, sessionId: undefined, showAllSessions: false, screen: 'sessions' });
     }
     /** Open a workspace picker, or resolve a workspace by ID, exact title/path, or unique ID prefix.
      * @param query - Workspace target, if any.
@@ -296,13 +322,13 @@ export class SessionController {
         const selection = this.store.selection();
         this.follow?.cancel();
         this.follow = undefined;
-        this.releaseTranscript();
-        const transcript = new Transcript();
+        this.info.reset(sessionId);
+        const transcript = this.info.record;
         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, transcript, screen: 'chat', status: 'Loading session…' });
+        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 },
         }, {
@@ -311,11 +337,12 @@ export class SessionController {
                     return;
                 try {
                     transcript.accept(value);
+                    this.prompts.fold(transcript.promptsSince(this.prompts.through));
                     this.reclaimHistory();
                     const frame = object(value);
                     if (frame.type === 'snapshot')
                         this.connection.telemetryView().snapshot(sessionId, frame.projections);
-                    this.store.update({ transcript, status: this.stoppingSession === sessionId ? this.store.state.status : transcript.hasLiveContent ? 'Responding…' : 'Connected' });
+                    this.store.update({ status: this.stoppingSession === sessionId ? this.store.state.status : transcript.hasLiveContent ? 'Responding…' : 'Connected' });
                 }
                 catch (error) {
                     this.connection.fail(new Error(errorText(error)));
@@ -328,16 +355,17 @@ export class SessionController {
                 this.store.update({ status: 'Session disconnected', error: errorText(error ?? 'Session stream ended') });
             },
         });
+        this.backfillPrompts(sessionId, selection);
     }
     /** 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.store.state.transcript;
+        const transcript = this.info.record;
         const deadline = Date.now() + this.host.require().timeoutMs;
         while (!transcript.ready) {
             signal.throwIfAborted();
-            if (!this.store.state.online || this.store.state.transcript !== transcript)
+            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');
@@ -380,7 +408,7 @@ export class SessionController {
      * @returns The host's successful command result text.
      */
     async command(line, signal) {
-        if (!this.store.state.transcript.ready)
+        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: [],
@@ -393,6 +421,11 @@ export class SessionController {
         }
         if (result.kind === 'error')
             throw new Error(string(result.text));
+        // Compaction rewrites the host log, so a cached prompt list for this session may describe
+        // records that no longer exist. The live index keeps what the reader already sees; the cache is
+        // dropped so the next open reads the rewritten history.
+        if (line.trim().split(/\s/, 1)[0] === '/compact')
+            this.promptCache.drop(this.sessionId);
         return result.text === undefined ? 'Command completed.' : string(result.text);
     }
     /** Remove one host-owned pending input; an already claimed item reports a host error.
@@ -415,7 +448,7 @@ export class SessionController {
      * @returns Absolute saved filename.
      */
     async exportHtml(path, signal) {
-        return saveTranscriptHtml(this.store.state.transcript, this.sessionId, path, signal);
+        return saveTranscriptHtml(this.info.record, this.sessionId, path, signal);
     }
     /** Admit text once as steering while running, or a new turn while idle; a lost response can leave delivery uncertain.
      * @param text - Composed prompt text.
@@ -424,7 +457,7 @@ export class SessionController {
         if (this.store.state.pending.length)
             throw new Error('Answer the pending question or approval first');
         this.stoppingSession = undefined;
-        if (!this.store.state.transcript.ready)
+        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',
@@ -459,14 +492,34 @@ export class SessionController {
             throw new Error('No pending approval');
         await this.answer(allowed ? 'allowed-once' : 'rejected');
     }
+    /** 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({});
+    }
     /** 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
+     * survive is already covered by the view: scrolling back sets a scroll position, `/think` opens a
+     * panel, and a recall page folds its prompts into the index before this resolves. A pin set here
+     * had no clearing edge, so after one recall page the history budget silently stopped applying for
+     * the rest of the session while every following page kept adding records.
      * @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.store.state.transcript) {
+    async older(signal, transcript = this.info.record) {
         const selection = this.store.selection();
-        if (transcript === this.store.state.transcript)
-            this.historyPinned = true;
         if (!transcript.ready || !transcript.hasMore || transcript.beforeSeq === undefined)
             return;
         const result = await this.host.require().call('session/page', { request: {
@@ -478,13 +531,326 @@ export class SessionController {
         transcript.addPage(result);
         this.store.update({});
     }
+    /** 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.
+     * @param answers - Answers collected so far, by event id.
+     */
+    setAnswers(answers) {
+        this.info.interaction.answers = answers;
+        this.store.update({});
+    }
+    /** Replace the pending question's option keyboard state.
+     * @param option - Highlighted option, toggled labels and free-text mode; undefined clears it.
+     */
+    setOption(option) {
+        if (this.info.interaction.option === option)
+            return;
+        this.info.interaction.option = option;
+        this.store.update({});
+    }
+    /** Replace the pending approval's selected row.
+     * @param approval - Selected approval row; undefined clears the highlight.
+     */
+    setApproval(approval) {
+        if (this.info.interaction.approval === approval)
+            return;
+        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. */
+    resetRecall() { this.prompts.resetCursor(); }
+    /** Whether recall is parked on the oldest prompt it retains in memory. */
+    get recallAtOldest() { return this.prompts.atOldest; }
+    /** How many prompts the session retains for recall. */
+    get recallLength() { return this.prompts.length; }
+    /** Whether an older prompt is reachable at all: shed from the window, or still on the host. */
+    get recallHasOlder() {
+        const transcript = this.info.record;
+        const oldest = this.prompts.oldest;
+        const refillable = oldest !== undefined && transcript.beforeSeq !== undefined && oldest > transcript.beforeSeq;
+        return refillable || (!this.prompts.exhausted && transcript.hasMore);
+    }
+    /** Recover older prompts from the loaded window before spending a page request.
+     *
+     * The transcript window can still hold prompts the index's budgets evicted, so a backward step
+     * refills from memory first and only then asks the caller to page. That is what keeps recall
+     * complete across submissions, where the previous buffer lost them at the eviction boundary.
+     * @returns Whether any older prompt was recovered.
+     */
+    refillRecall() {
+        const oldest = this.prompts.oldest;
+        if (oldest === undefined)
+            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
+     * paying twice: it hands over pages it already has, and an open that follows reads the cache.
+     * @param sessionId - Session the page belongs to.
+     * @param records - Raw records of one scanned page.
+     */
+    rememberScanPage(sessionId, records) {
+        this.promptCache.observe(sessionId, recordPrompts(records), false);
+    }
+    /** Report that the scanned session's history was read to its beginning.
+     * @param sessionId - Session the scan finished.
+     */
+    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.store.state.transcript;
+        const source = this.info.record;
         if (!source.ready)
             throw new Error('Wait for the session snapshot');
         const sessionId = this.sessionId;
@@ -546,7 +912,7 @@ export class SessionController {
      * @returns A caller-owned historical window that must be disposed when closed.
      */
     async historyAt(target, signal) {
-        const source = this.store.state.transcript;
+        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,
@@ -572,14 +938,14 @@ export class SessionController {
      * @param signal - Cancels local paging without interrupting the remote agent.
      */
     async historyThrough(target, signal) {
-        const transcript = this.store.state.transcript;
+        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.store.state.transcript !== transcript)
+            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');
@@ -590,18 +956,18 @@ export class SessionController {
      * @returns Number of removed records.
      */
     reclaimHistory() {
-        if (this.historyPinned || !this.store.state.online)
+        if (this.info.view.pinned || !this.store.state.online)
             return 0;
-        const removed = this.store.state.transcript.trimHistory(this.historyLimits);
+        const removed = this.info.record.trimHistory(this.historyLimits);
         if (removed)
-            releaseHistoryLayout(this.store.state.transcript);
+            releaseHistoryLayout(this.info.record);
         return removed;
     }
     /** Release the selected transcript and its layout caches. */
     releaseTranscript() {
-        releaseHistoryLayout(this.store.state.transcript);
-        this.store.state.transcript.dispose();
-        this.historyPinned = false;
+        this.promptBackfill?.abort();
+        this.promptBackfill = undefined;
+        this.info.reset();
     }
     /** @returns The selected session identity, or a `Select a session first` failure. */
     get sessionId() {

package/dist/session/index.d.ts

@@ -9,6 +9,8 @@ export { Telemetry } from './telemetry.ts';
 export type { QueuedInput } from './telemetry.ts';
 export { DEFAULT_HISTORY_LIMITS, historyLimits } from './memory.ts';
 export type { HistoryLimits } from './memory.ts';
+export { DEFAULT_PROMPT_LIMITS, promptText, PromptIndex, SessionInfo } from './info.ts';
+export type { ComposerState, InteractionState, ModelState, OptionState, PanelState, PromptEntry, PromptLimits, PromptRecord, ReferenceState, ViewState } from './info.ts';
 export { navigationCommand, resolveTarget, sessionLabel } from './navigation.ts';
 export { activeReference, fileMention, fileReferences } from './references.ts';
 export type { FileReference } from './references.ts';

package/dist/session/index.js

@@ -5,6 +5,7 @@ export { historyLayout, layoutStats, releaseHistoryLayout } from "./history.js";
 export { markdownCacheStats } from "./markdown.js";
 export { Telemetry } from "./telemetry.js";
 export { DEFAULT_HISTORY_LIMITS, historyLimits } from "./memory.js";
+export { DEFAULT_PROMPT_LIMITS, promptText, PromptIndex, SessionInfo } from "./info.js";
 export { navigationCommand, resolveTarget, sessionLabel } from "./navigation.js";
 export { activeReference, fileMention, fileReferences } from "./references.js";
 export { saveSessionLog } from "./export.js";