@itookit/dsht 0.1.0

package/dist/controller.js

@@ -0,0 +1,640 @@
+/** UI state and connection generations for the standalone terminal client. */
+import { randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { Client, HttpError, RemoteError } from "./client.js";
+import { AuthenticationRequired } from "./auth.js";
+import { resolveTarget, sessionLabel } from "./navigation.js";
+import { costRecords } from "./cost.js";
+import { Telemetry } from "./telemetry.js";
+import { Transcript } from "./transcript.js";
+import { fileReferences } from "./references.js";
+import { array, errorText, object, string } from "./wire.js";
+/** Owns reconnects and subscriptions. User commands remain single-attempt operations. */
+export class Controller {
+    base;
+    initialSession;
+    makeClient;
+    authenticate;
+    costs;
+    state = { version: 0, online: false, busy: false, screen: 'workspaces', status: 'Connecting…',
+        error: '', workspaces: [], sessions: [], showAllSessions: false, pending: [], transcript: new Transcript() };
+    observers = new Set();
+    abort = new AbortController();
+    client;
+    clientId = '';
+    follow;
+    runTask;
+    generationFailed;
+    selection = 0;
+    telemetry = new Telemetry();
+    observedRunningAt = new Map();
+    catalogRevision = 0;
+    catalogTasks = new Set();
+    runningUpdates = new Map();
+    stoppingSession;
+    interruptTask;
+    admission;
+    costUpdates = new Map();
+    costAbort;
+    costTask;
+    costTimer;
+    /** Host running state covers model generation, tools, and waits between assistant attempts. */
+    get running() {
+        const id = this.state.sessionId;
+        return id !== undefined && (this.runningUpdates.get(id)
+            ?? this.state.sessions.find(row => row.sessionId === id)?.running === true);
+    }
+    /** Current title projection, falling back to the list title and then the session ID. */
+    get sessionName() {
+        const id = this.state.sessionId;
+        if (!id)
+            return;
+        const title = this.telemetry.view(id).values.title;
+        const row = this.state.sessions.find(item => item.sessionId === id);
+        return title !== undefined ? sessionLabel({ sessionId: id, projections: { values: { title } } })
+            : row ? sessionLabel(row) : id;
+    }
+    /** Epoch start from the retained turn log, or when this client first observed the run. */
+    get workingSince() {
+        if (!this.running || !this.state.sessionId)
+            return undefined;
+        return this.state.transcript.activeTurnStartedAt ?? this.observedRunningAt.get(this.state.sessionId);
+    }
+    /** 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.
+     * @returns True when the caller may exit; cancellation failures retain the client.
+     */
+    interrupt(force = false) {
+        if (this.interruptTask)
+            return this.interruptTask;
+        if (!force && !this.running && !this.admission && this.state.pending.length === 0) {
+            return Promise.resolve(!this.state.busy);
+        }
+        const sessionId = this.sessionId;
+        this.stoppingSession = sessionId;
+        this.update({ status: 'Stopping…', error: '' });
+        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.
+                await this.admission?.catch(() => undefined);
+                await this.host.call('session/cancel', { request: { sessionId } });
+                if (this.stoppingSession === sessionId && this.state.sessionId === sessionId)
+                    this.update({ status: 'Cancellation requested · waiting for host' });
+            }
+            catch (error) {
+                this.stoppingSession = undefined;
+                this.update({ status: 'Cancellation failed', error: errorText(error) });
+            }
+            return false;
+        })();
+        this.interruptTask = task;
+        void task.finally(() => { this.interruptTask = undefined; });
+        return task;
+    }
+    constructor(base, token, initialSession, makeClient = () => new Client(base), authenticate = client => client.authenticate(token ?? ''), costs) {
+        this.base = base;
+        this.initialSession = initialSession;
+        this.makeClient = makeClient;
+        this.authenticate = authenticate;
+        this.costs = costs;
+    }
+    /** React-compatible state subscription. */
+    subscribe = (listener) => {
+        this.observers.add(listener);
+        return () => this.observers.delete(listener);
+    };
+    /** Snapshot identity changes only when the controller publishes. */
+    snapshot = () => this.state;
+    /** Start one retry loop, with a fresh snapshot generation after every disconnect. */
+    start() { this.runTask ??= this.run(); }
+    /** Cancel retries and HTTP, close the socket, and wait for the loop to settle. */
+    async stop() {
+        this.abort.abort();
+        clearInterval(this.costTimer);
+        this.generationFailed?.(new Error('Client stopped'));
+        await this.client?.close();
+        await this.runTask;
+        await this.interruptTask;
+        await Promise.all(this.catalogTasks);
+        await this.costTask;
+    }
+    /** Run a UI operation and expose errors without destroying the current input. */
+    async perform(operation) {
+        if (this.state.busy || !this.state.online)
+            return false;
+        this.update({ busy: true, error: '' });
+        try {
+            await operation();
+            return true;
+        }
+        catch (error) {
+            this.update({ error: errorText(error) });
+            return false;
+        }
+        finally {
+            this.update({ busy: false });
+        }
+    }
+    /** Refresh all HTTP-visible sessions without changing the selected conversation.
+     * @param signal - Optional cancellation for an explicit /cost refresh.
+     */
+    async refreshCosts(signal = this.abort.signal) {
+        if (!this.costs)
+            return;
+        if (this.costTask) {
+            const cancel = () => this.costAbort?.abort();
+            signal.addEventListener('abort', cancel, { once: true });
+            try {
+                await this.costTask;
+            }
+            finally {
+                signal.removeEventListener('abort', cancel);
+            }
+            return;
+        }
+        this.costAbort = new AbortController();
+        signal = AbortSignal.any([signal, this.abort.signal, this.costAbort.signal]);
+        const ledger = this.costs;
+        const client = this.host;
+        ledger.scanning = true;
+        ledger.error = '';
+        this.update({});
+        const task = (async () => {
+            try {
+                const sessions = array(object(await client.call('session/list', { _request: {} }, signal)).items).map(object);
+                signal.throwIfAborted();
+                for (const session of sessions) {
+                    signal.throwIfAborted();
+                    const sessionId = string(session.sessionId);
+                    if (!session.running && typeof session.updatedAt === 'number' && this.costUpdates.get(sessionId) === session.updatedAt)
+                        continue;
+                    const snapshot = await new Promise((resolve, reject) => {
+                        let sub;
+                        const timeout = setTimeout(() => finish(new Error('Cost history snapshot timed out')), client.timeoutMs);
+                        const onAbort = () => finish(new Error('Cost refresh cancelled'));
+                        const finish = (error, frame) => {
+                            clearTimeout(timeout);
+                            signal.removeEventListener('abort', onAbort);
+                            sub?.cancel();
+                            if (error)
+                                reject(error);
+                            else
+                                resolve(frame);
+                        };
+                        signal.addEventListener('abort', onAbort, { once: true });
+                        try {
+                            sub = client.subscribe('session/follow', { request: { address: { kind: 'session', sessionId }, maxMessages: 80, assistantStream: true } }, {
+                                item: value => { const frame = object(value); if (frame.type === 'snapshot')
+                                    finish(undefined, frame); },
+                                end: error => finish(error ?? new Error('Cost history stream ended')),
+                            });
+                        }
+                        catch (error) {
+                            finish(error instanceof Error ? error : new Error(errorText(error)));
+                        }
+                    });
+                    const cut = snapshot.cursor;
+                    if (typeof cut !== 'number' || !Number.isSafeInteger(cut))
+                        throw new Error('Invalid cost history cursor');
+                    let page = snapshot;
+                    const events = [];
+                    while (true) {
+                        signal.throwIfAborted();
+                        const records = array(page.records);
+                        events.push(...costRecords(records));
+                        if (!page.hasMore)
+                            break;
+                        const seqs = records.map(r => object(object(r).event).seq);
+                        if (!seqs.length || seqs.some(n => typeof n !== 'number' || !Number.isSafeInteger(n)))
+                            throw new Error('Invalid cost history page');
+                        const beforeSeq = Math.min(...seqs);
+                        page = object(await client.call('session/page', { request: { address: { kind: 'session', sessionId }, throughSeq: cut, beforeSeq, maxMessages: 80 } }, signal));
+                        if (page.hasMore && array(page.records).every(r => Number(object(object(r).event).seq) >= beforeSeq))
+                            throw new Error('Cost history page did not advance');
+                    }
+                    if (object(snapshot.header).isSeeded === true && !events.some(e => e.type === 'session/end-seed' && object(e.data).inherited === true))
+                        throw new Error('Cannot attribute inherited session usage');
+                    await ledger.replace(sessionId, cut, events);
+                    if (!session.running && typeof session.updatedAt === 'number')
+                        this.costUpdates.set(sessionId, session.updatedAt);
+                    this.update({});
+                }
+                ledger.scannedAt = Date.now();
+            }
+            catch (error) {
+                ledger.error = errorText(error);
+            }
+            finally {
+                ledger.scanning = false;
+                this.update({});
+            }
+        })();
+        this.costTask = task;
+        try {
+            await task;
+        }
+        finally {
+            this.costTask = undefined;
+        }
+    }
+    /** Refresh both lists from the host, then show the requested picker. */
+    async showPicker(screen) {
+        await this.releasePending();
+        const [workspaces, sessions] = await Promise.all([this.host.listWorkspaces(), this.host.listSessions()]);
+        this.update({ screen, workspaces, sessions });
+    }
+    /** Pick a workspace, or use all sessions when the identity is omitted. */
+    pickWorkspace(workspaceId) {
+        this.follow?.cancel();
+        this.selection++;
+        this.update({ workspaceId, sessionId: undefined, showAllSessions: false, transcript: new Transcript(), screen: 'sessions' });
+    }
+    /** Open a workspace picker, or resolve a workspace by ID, exact title/path, or unique ID prefix. */
+    async switchWorkspace(query) {
+        if (!query) {
+            await this.showPicker('workspaces');
+            return;
+        }
+        const workspaces = await this.host.listWorkspaces();
+        const workspace = resolveTarget(workspaces, query, 'workspaceId', item => [string(item.title), string(item.path)]);
+        const sessions = await this.host.listSessions();
+        await this.releasePending();
+        this.update({ workspaces, sessions });
+        this.pickWorkspace(string(workspace.workspaceId));
+    }
+    /** Guide workspace selection, list all sessions with `all`, or resolve an exact session target. */
+    async switchSession(query) {
+        if (!query || query === 'all') {
+            await this.showPicker(query === 'all' || this.state.workspaceId ? 'sessions' : 'workspaces');
+            this.update({ showAllSessions: query === 'all' });
+            return;
+        }
+        const [workspaces, sessions] = await Promise.all([this.host.listWorkspaces(), this.host.listSessions()]);
+        const session = resolveTarget(sessions, query, 'sessionId', item => [sessionLabel(item)]);
+        this.update({ workspaces, sessions });
+        await this.selectSession(string(session.sessionId));
+    }
+    /** Prompt for a host path without starting a local agent. */
+    enterPath() { this.update({ screen: 'path' }); }
+    /** Register a host directory and move to its session picker. */
+    async createWorkspace(path) {
+        const result = object(await this.host.call('workspace/create', { request: { path } }));
+        const workspace = object(result.workspace);
+        await this.showPicker('workspaces');
+        this.pickWorkspace(string(workspace.workspaceId));
+    }
+    /** Create a session only after the user explicitly selects New session. */
+    async createSession() {
+        if (!this.state.workspaceId)
+            throw new Error('Select a workspace before creating a session');
+        const result = object(await this.host.call('session/create', { request: { workspaceId: this.state.workspaceId } }));
+        await this.selectSession(string(result.sessionId));
+    }
+    /** Replace the selected transcript and cancel its preceding follow stream. */
+    async selectSession(sessionId) {
+        this.stoppingSession = undefined;
+        await this.releasePending();
+        this.follow?.cancel();
+        const selection = ++this.selection;
+        const transcript = new Transcript();
+        const workspace = this.state.workspaces.find(item => array(item.sessionIds).includes(sessionId));
+        const workspaceId = workspace ? string(workspace.workspaceId)
+            : this.state.sessions.some(item => item.sessionId === sessionId) ? undefined : this.state.workspaceId;
+        if (!this.observedRunningAt.has(sessionId))
+            this.observedRunningAt.set(sessionId, Date.now());
+        this.update({ sessionId, workspaceId, showAllSessions: false, transcript, screen: 'chat', status: 'Loading session…' });
+        this.follow = this.host.subscribe('session/follow', {
+            request: { address: { kind: 'session', sessionId }, maxMessages: 80, assistantStream: true },
+        }, {
+            item: value => {
+                if (selection !== this.selection)
+                    return;
+                try {
+                    transcript.accept(value);
+                    const frame = object(value);
+                    if (frame.type === 'snapshot')
+                        this.telemetry.snapshot(sessionId, frame.projections);
+                    this.update({ transcript, status: this.stoppingSession === sessionId ? this.state.status : transcript.liveText ? 'Responding…' : 'Connected' });
+                }
+                catch (error) {
+                    this.generationFailed?.(new Error(errorText(error)));
+                }
+            },
+            end: error => {
+                if (selection !== this.selection)
+                    return;
+                transcript.ready = false;
+                this.update({ status: 'Session disconnected', error: errorText(error ?? 'Session stream ended') });
+            },
+        });
+    }
+    /** 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.state.transcript;
+        const deadline = Date.now() + this.host.timeoutMs;
+        while (!transcript.ready) {
+            signal.throwIfAborted();
+            if (!this.state.online || this.state.transcript !== 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 });
+        }
+    }
+    /** 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.
+     * @param signal - Cancels the HTTP search.
+     * @returns Session snippets and the global truncation flag, preserved after filtering.
+     */
+    async searchSessions(query, workspaceOnly, signal) {
+        const workspace = this.state.workspaces.find(item => item.workspaceId === this.state.workspaceId);
+        if (workspaceOnly && !workspace)
+            throw new Error('Select a workspace first');
+        const result = object(await this.host.call('session/search', { request: { query } }, signal));
+        if (!Array.isArray(result.items) || typeof result.hasMore !== 'boolean')
+            throw new Error('Invalid session search response');
+        const items = result.items.map(value => {
+            const item = object(value);
+            if (typeof item.sessionId !== 'string' || typeof item.snippet !== 'string')
+                throw new Error('Invalid session search item');
+            return item;
+        });
+        const ids = new Set(array(workspace?.sessionIds ?? []));
+        return { items: workspaceOnly ? items.filter(item => ids.has(item.sessionId)) : items, hasMore: result.hasMore };
+    }
+    /** Search paths on the host; does not read or upload file contents.
+     * @param query - Path text after @, relative to the selected session cwd.
+     * @param signal - Cancels an obsolete composer lookup.
+     * @returns Validated candidates in host order.
+     */
+    async references(query, signal) {
+        return fileReferences(await this.host.call('fileReferences/list', { agentId: this.sessionId, query }, signal));
+    }
+    /** Admit a prompt once; a failed response can have an uncertain delivery outcome. */
+    async prompt(text, mode = 'queue') {
+        this.stoppingSession = undefined;
+        if (!this.state.transcript.ready)
+            throw new Error('Wait for the session snapshot before sending');
+        const admission = this.host.call('session/prompt', { request: {
+                sessionId: this.sessionId, requestId: randomUUID(), mode,
+                content: [{ type: 'text', text }], clientTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            } });
+        this.admission = admission;
+        try {
+            await admission;
+        }
+        finally {
+            if (this.admission === admission)
+                this.admission = undefined;
+        }
+        this.update({ status: 'Accepted · waiting for host' });
+    }
+    /** Cancel the active turn; pending queue items remain host-owned. */
+    async cancelTurn() {
+        await this.host.call('session/cancel', { request: { sessionId: this.sessionId } });
+        this.update({ status: 'Cancellation requested' });
+    }
+    /** Add a page before the retained window using its fixed opening cut. */
+    async older(signal) {
+        const transcript = this.state.transcript;
+        if (!transcript.ready || !transcript.hasMore || transcript.beforeSeq === undefined)
+            return;
+        const result = await this.host.call('session/page', { request: {
+                address: { kind: 'session', sessionId: this.sessionId }, throughSeq: transcript.cursor,
+                beforeSeq: transcript.beforeSeq, maxMessages: 80,
+            } }, signal);
+        if (transcript !== this.state.transcript)
+            return;
+        transcript.addPage(result);
+        this.update({ transcript });
+    }
+    /** Load the prefix required for an explicit history jump; never loop on an unadvancing page.
+     * @param target - Visible record sequence, or first for the oldest available history.
+     * @param signal - Cancels local paging without interrupting the remote agent.
+     */
+    async historyThrough(target, signal) {
+        const transcript = this.state.transcript;
+        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.state.transcript !== 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');
+            }
+        }
+    }
+    /** Answer the oldest selected-session interaction, after explicit user action. */
+    async answer(value) {
+        const pending = this.state.pending[0];
+        if (!pending)
+            throw new Error('No pending interaction');
+        await this.reply(pending, { kind: 'result', value });
+        this.update({ pending: this.state.pending.filter(item => item.eventId !== pending.eventId) });
+    }
+    /** Restrict an approval command to an approval request. */
+    async approve(allowed) {
+        if (this.state.pending[0]?.event !== 'approval/request')
+            throw new Error('No pending approval');
+        await this.answer(allowed ? 'allowed-once' : 'rejected');
+    }
+    /** Present only sessions explicitly accounted to the selected workspace. */
+    get visibleSessions() {
+        if (this.state.showAllSessions || !this.state.workspaceId)
+            return this.state.sessions;
+        const workspace = this.state.workspaces.find(item => item.workspaceId === this.state.workspaceId);
+        const ids = new Set(array(workspace?.sessionIds ?? []).map(string));
+        return this.state.sessions.filter(item => ids.has(string(item.sessionId)));
+    }
+    get host() {
+        if (!this.client || !this.state.online)
+            throw new Error('Not connected');
+        return this.client;
+    }
+    get sessionId() {
+        if (!this.state.sessionId)
+            throw new Error('Select a session first');
+        return this.state.sessionId;
+    }
+    update(patch) {
+        this.state = { ...this.state, ...patch, version: this.state.version + 1 };
+        for (const observer of this.observers)
+            observer();
+    }
+    async reply(frame, outcome) {
+        await this.host.call('$events/result', { clientId: this.clientId, eventId: string(frame.eventId), outcome });
+    }
+    async releasePending() {
+        for (const pending of this.state.pending)
+            await this.reply(pending, { kind: 'next' });
+        this.update({ pending: [] });
+    }
+    refreshCatalog(client) {
+        const revision = ++this.catalogRevision;
+        const task = client.call('session/modelCatalog', {}).then(value => {
+            if (client === this.client && revision === this.catalogRevision)
+                this.update({ defaultModel: object(object(value).default), modelError: undefined });
+        }, error => {
+            if (client === this.client && revision === this.catalogRevision)
+                this.update({ defaultModel: undefined, modelError: errorText(error) });
+        }).catch(error => {
+            if (client === this.client && revision === this.catalogRevision)
+                this.update({ defaultModel: undefined, modelError: errorText(error) });
+        });
+        this.catalogTasks.add(task);
+        void task.finally(() => this.catalogTasks.delete(task));
+    }
+    async run() {
+        let attempt = 0;
+        while (!this.abort.signal.aborted) {
+            this.stoppingSession = undefined;
+            this.runningUpdates.clear();
+            this.observedRunningAt.clear();
+            this.telemetry = new Telemetry();
+            this.update({ controlError: undefined, modelError: undefined, defaultModel: undefined });
+            const client = this.makeClient();
+            this.client = client;
+            try {
+                await this.authenticate(client);
+                await client.connect();
+                let fail;
+                const disconnected = new Promise(resolve => { fail = resolve; });
+                this.generationFailed = fail;
+                const ready = new Promise((resolve, reject) => {
+                    const timer = setTimeout(() => reject(new Error('Host ready timed out')), client.timeoutMs);
+                    client.subscribe('$events', {}, {
+                        item: value => {
+                            const frame = object(value);
+                            if (frame.type === 'ready') {
+                                this.clientId = string(frame.clientId);
+                                clearTimeout(timer);
+                                resolve();
+                            }
+                            else if (frame.type === 'waterfall') {
+                                if (frame.agentId === this.state.sessionId && this.state.screen === 'chat'
+                                    && ['approval/request', 'user-questions/request'].includes(string(frame.event))) {
+                                    this.update({ pending: [...this.state.pending, frame] });
+                                }
+                                else {
+                                    void client.call('$events/result', { clientId: this.clientId,
+                                        eventId: string(frame.eventId), outcome: { kind: 'next' } }).catch(error => fail(new Error(errorText(error))));
+                                }
+                            }
+                            else if (frame.type === 'cancel') {
+                                this.update({ pending: this.state.pending.filter(item => item.eventId !== frame.eventId) });
+                            }
+                            else if (frame.type === 'emit' && frame.event === 'api-session/status') {
+                                const args = array(frame.args);
+                                const sessionId = string(args[0]);
+                                if (typeof args[1] !== 'boolean')
+                                    throw new Error('Invalid session running state');
+                                if (args[1] && !this.runningUpdates.get(sessionId))
+                                    this.observedRunningAt.set(sessionId, Date.now());
+                                if (!args[1]) {
+                                    this.observedRunningAt.delete(sessionId);
+                                    if (this.stoppingSession === sessionId)
+                                        this.stoppingSession = undefined;
+                                }
+                                this.runningUpdates.set(sessionId, args[1]);
+                                this.update({ sessions: this.state.sessions.map(row => row.sessionId === sessionId ? { ...row, running: args[1] } : row),
+                                    ...(sessionId === this.state.sessionId ? { status: args[1] ? 'Running…' : 'Idle' } : {}) });
+                                if (!args[1] && this.costs && this.state.online)
+                                    void this.refreshCosts();
+                            }
+                            else if (frame.type === 'emit' && ['llm/adapters-updated', 'settings/document-updated', 'credentials/reference-updated'].includes(String(frame.event))) {
+                                this.refreshCatalog(client);
+                            }
+                            else if (frame.type === 'emit' && frame.event === 'api-session/error') {
+                                const args = array(frame.args);
+                                if (args[0] === this.state.sessionId)
+                                    this.update({ status: 'Agent error', error: errorText(args[1]) });
+                            }
+                        },
+                        end: error => { clearTimeout(timer); const reason = error ?? new Error('Event stream ended'); reject(reason); fail(reason); },
+                    });
+                });
+                await ready;
+                await new Promise((resolve, reject) => {
+                    const timer = setTimeout(() => reject(new Error('Session control baseline timed out')), client.timeoutMs);
+                    client.subscribe('session/control', {}, {
+                        item: value => {
+                            try {
+                                this.telemetry.accept(value);
+                                this.update({});
+                                clearTimeout(timer);
+                                resolve();
+                            }
+                            catch (error) {
+                                clearTimeout(timer);
+                                reject(error);
+                                fail(new Error(errorText(error)));
+                            }
+                        },
+                        end: error => {
+                            clearTimeout(timer);
+                            if (error instanceof RemoteError && error.code === 'gateway/method-unavailable') {
+                                this.update({ controlError: 'Live metrics unavailable on this host' });
+                                resolve();
+                            }
+                            else {
+                                const reason = error ?? new Error('Session control stream ended');
+                                reject(reason);
+                                fail(reason);
+                            }
+                        },
+                    });
+                });
+                this.refreshCatalog(client);
+                this.update({ online: true, status: 'Connected', error: '', pending: [] });
+                const screen = this.state.screen;
+                await this.showPicker(screen === 'sessions' ? 'sessions' : 'workspaces');
+                const sessionId = this.state.sessionId ?? this.initialSession;
+                if (sessionId && (screen === 'chat' || this.initialSession && !this.state.sessionId))
+                    await this.selectSession(sessionId);
+                attempt = 0;
+                if (this.costs) {
+                    void this.refreshCosts();
+                    clearInterval(this.costTimer);
+                    this.costTimer = setInterval(() => { if (this.state.online)
+                        void this.refreshCosts(); }, 60_000);
+                }
+                const error = await disconnected;
+                if (!this.abort.signal.aborted)
+                    throw error;
+            }
+            catch (error) {
+                if (error instanceof AuthenticationRequired || error instanceof HttpError && [401, 403].includes(error.status)) {
+                    this.update({ error: `${errorText(error)}. Set DSH_TOKEN and restart to log in.`, status: 'Login required' });
+                    return;
+                }
+                if (!this.abort.signal.aborted)
+                    this.update({ error: errorText(error), status: 'Reconnecting…' });
+            }
+            finally {
+                clearInterval(this.costTimer);
+                this.generationFailed = undefined;
+                this.selection++;
+                this.state.transcript.ready = false;
+                this.update({ online: false, pending: [] });
+                await client.close();
+                await this.costTask;
+            }
+            if (!this.abort.signal.aborted) {
+                try {
+                    await delay(Math.min(500 * 2 ** attempt++, 10_000) * (0.8 + Math.random() * 0.4), undefined, { signal: this.abort.signal });
+                }
+                catch (error) {
+                    if (!this.abort.signal.aborted)
+                        throw error;
+                }
+            }
+        }
+    }
+}

package/dist/cost-view.d.ts

@@ -0,0 +1,8 @@
+import type { Controller } from './controller.ts';
+/** Render cached totals while the independent HTTP cost scan refreshes.
+ * @param controller - Selected session and origin-scoped cost ledger.
+ * @returns Billing panel, including unpriced models and refresh errors.
+ */
+export declare function CostPanel({ controller }: {
+    controller: Controller;
+}): import("react").JSX.Element;

package/dist/cost-view.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Billing estimates with explicit coverage, calendar and unknown-price indicators. */
+import { Box, Text } from 'ink';
+import { costText } from "./cost.js";
+import { safeText } from "./wire.js";
+/** Render cached totals while the independent HTTP cost scan refreshes.
+ * @param controller - Selected session and origin-scoped cost ledger.
+ * @returns Billing panel, including unpriced models and refresh errors.
+ */
+export function CostPanel({ controller }) {
+    const costs = controller.costs;
+    if (!costs)
+        return _jsx(Text, { children: "Cost tracking is unavailable" });
+    const id = controller.state.sessionId;
+    const rows = [
+        ['Session', id && costs.hasSession(id) ? costs.total(id) : undefined],
+        ['Today', costs.total(undefined, 1)], ['3 days (today + previous 2)', costs.total(undefined, 3)],
+    ];
+    return _jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Cost \u00B7 CNY estimate \u00B7 Asia/Shanghai \u00B7 /cost closes" }), rows.map(([label, total]) => _jsxs(Text, { children: [label, ": ", total ? `${costText(total)} · ${total.unknown} unpriced / ${total.records} requests` : '?'] }, label)), _jsx(Text, { dimColor: true, children: costs.scanning ? 'Refreshing all visible sessions…' : costs.scannedAt ? `Last refresh: ${new Date(costs.scannedAt).toISOString()}` : 'Partial cached totals · awaiting complete scan' }), _jsx(Text, { dimColor: true, children: "Recorded settlement time determines tariff; * means incomplete. Provider invoices are authoritative." }), costs.error && _jsxs(Text, { color: "yellow", children: ["Partial totals: ", safeText(costs.error)] }), costs.missing().slice(0, 6).map(reason => _jsx(Text, { color: "yellow", children: safeText(reason) }, reason))] });
+}