dsh-ntr 0.3.0 → 0.3.2

package/lib/client/store.js

@@ -17,6 +17,35 @@ export const PERMISSION_DEADLINE_EXPIRED = 'expired';
 export function permissionsForSession(permissions, dshSessionId) {
     return permissions.filter(permission => permission.dshSessionId === dshSessionId);
 }
+/**
+ * The branch button's state for one conversation, in the precedence it renders:
+ * the host service missing beats everything (nothing can work), then the
+ * agent's fork capability, then the session's own state (a parked session
+ * before a running one), then the DOM's tail verdict, and only then ready.
+ *
+ * Every input is a fact someone else owns — the row's `fork` verdict is the
+ * host's, `hostFork` is the structural probe of the runtime's `sessions.fork`,
+ * `isTail` is read from the host's own `[data-turn-tail]` marker, and
+ * `liveRunning` is the SSE-driven running flag (the row's own `running` only
+ * refreshes on a chat-list read, so it would answer last turn). `undefined`
+ * facts degrade CLOSED: no row and no `fork` verdict both read as not-ready,
+ * never as a click-through.
+ */
+export function forkStateOf(row, hostFork, isTail, liveRunning) {
+    if (!hostFork)
+        return 'hostUnavailable';
+    if (row === undefined)
+        return 'released';
+    if (row.fork === undefined)
+        return 'unsupported';
+    if (row.fork.supported !== true)
+        return row.fork.reason ?? 'unsupported';
+    if (liveRunning === true)
+        return 'busy';
+    if (!isTail)
+        return 'notTail';
+    return 'ready';
+}
 /**
  * Compact countdown for one ask, or `undefined` when there is nothing to count
  * down (`wait` mode, or a frame without a deadline). Pure so the formatting is
@@ -39,6 +68,8 @@ export function deadlineRemainingLabel(deadlineAt, now, mode) {
     const rest = seconds % 60;
     return rest === 0 ? `${String(minutes)}m` : `${String(minutes)}m ${String(rest)}s`;
 }
+/** Cap on retained runtime-log lines; older entries fall off the front. */
+export const LOG_MAX_ENTRIES = 200;
 const MAX_BLOCKS = 400;
 /** How many observed ACP transcripts stay live at once (insertion-ordered eviction). */
 const MAX_WATCHED = 6;
@@ -339,6 +370,8 @@ export class AcpStore {
         blocks: [],
         permissions: [],
         busy: false,
+        logs: [],
+        logUnread: 0,
         detectedAgents: [...DEFAULT_KNOWN_PRESETS],
         detecting: false,
         modelCatalogs: {},
@@ -348,6 +381,7 @@ export class AcpStore {
         chatSessions: [],
         tagHalo: { ...DEFAULT_TAG_HALO },
         approvalDeadlines: undefined,
+        idleRelease: undefined,
         chatTranscripts: {},
         acpMode: {},
         chatBoundAgent: {},
@@ -360,11 +394,20 @@ export class AcpStore {
     };
     listeners = new Set();
     source;
+    /** Monotonic id source for {@link AcpLogEntry}s (never reset by `clearLogs`). */
+    logSeq = 0;
     lastSeq = new Map();
     /** Sessions with a finalized turn (dedups the cancel-fallback + late real turn/end pair). */
     openTurns = new Set();
     /** In-flight `session/chat-list` reads, keyed by chat session id. */
     chatSessionReads = new Map();
+    /**
+     * ACP session ids whose chat-list row was requested mid-turn (one read each).
+     * A conversation's first ACP session does not exist when the composer's
+     * mount/running read fires, so its first `usage_update` would find no row to
+     * patch; `turn/start` asks again once the host has materialized the session.
+     */
+    chatSessionRowReads = new Set();
     /**
      * Chat sessions whose list has answered at least once in this page. The
      * FIRST answer only seeds the lock; a lock appearing on a later answer is a
@@ -445,6 +488,23 @@ export class AcpStore {
         for (const listener of [...this.listeners])
             listener();
     }
+    /**
+     * Build the log patch for one line. Does NOT mutate: the caller merges it
+     * into the single `mutate` call it was already making for the same event.
+     */
+    logPatch(level, text, agentId) {
+        const entry = {
+            id: ++this.logSeq,
+            at: Date.now(),
+            level,
+            text,
+            ...(agentId === undefined ? {} : { agentId }),
+        };
+        return {
+            logs: [...this.state.logs, entry].slice(-LOG_MAX_ENTRIES),
+            logUnread: this.state.logUnread + 1,
+        };
+    }
     // ---- Streaming update coalescing ----
     /**
      * Live `session/update` frames waiting to be folded. Agents stream at token
@@ -471,9 +531,17 @@ export class AcpStore {
                 list.push(item);
         }
         let chatTranscripts = this.state.chatTranscripts;
+        let chatSessions = this.state.chatSessions;
         let blocksChanged = false;
         for (const [sessionId, items] of bySession) {
             const last = items[items.length - 1];
+            // `usage_update` is state, not stream content: it never becomes a block,
+            // but both observed snapshots that carry usage must move with it —
+            // otherwise the ACP view header and the composer's occupancy ring only
+            // refresh when some other RPC re-reads the session.
+            const usage = usageOfBatch(items);
+            if (usage !== undefined)
+                chatSessions = withSessionUsage(chatSessions, sessionId, usage);
             // The observed transcript folds every frame (a watched session's cards
             // and prose); blocks are copied only when something actually changed, so
             // a usage-only tick costs one record object, not a re-render payload.
@@ -484,9 +552,12 @@ export class AcpStore {
                     if (foldUpdate(record.blocks, item.update))
                         changed = true;
                 }
+                const session = usage !== undefined && !sameUsage(record.session.usage, usage)
+                    ? { ...record.session, usage }
+                    : record.session;
                 chatTranscripts = {
                     ...chatTranscripts,
-                    [sessionId]: { ...record, seq: last.seq, ...(changed ? { blocks: [...record.blocks] } : {}) },
+                    [sessionId]: { ...record, session, seq: last.seq, ...(changed ? { blocks: [...record.blocks] } : {}) },
                 };
             }
             if (sessionId !== this.state.activeSessionId) {
@@ -509,6 +580,8 @@ export class AcpStore {
         const patch = {};
         if (chatTranscripts !== this.state.chatTranscripts)
             patch.chatTranscripts = chatTranscripts;
+        if (chatSessions !== this.state.chatSessions)
+            patch.chatSessions = chatSessions;
         if (blocksChanged)
             patch.blocks = [...this.state.blocks];
         if (Object.keys(patch).length > 0)
@@ -563,7 +636,7 @@ export class AcpStore {
     /** Snapshot refresh used on panel open and after a stream outage. */
     async resync() {
         try {
-            const [{ agents }, { sessions }, defaultAgentInfo, detectResult, presetResult, tagHaloResult, deadlinesResult, versionResult] = await Promise.all([
+            const [{ agents }, { sessions }, defaultAgentInfo, detectResult, presetResult, tagHaloResult, deadlinesResult, idleReleaseResult, versionResult] = await Promise.all([
                 this.call('agents/list'),
                 this.call('sessions/list'),
                 // The plugin's OWN default ACP agent — a plugin-private id, not a DSH
@@ -577,6 +650,9 @@ export class AcpStore {
                 // `undefined` (older half) hides the deadline card instead of showing a
                 // number this browser made up.
                 this.call('ui/approval-deadlines').catch(() => ({ deadlines: undefined })),
+                // `undefined` (older half) hides the tab instead of showing a
+                // number this browser made up.
+                this.call('ui/idle-release').catch(() => ({ idleRelease: undefined })),
                 // The settings badge's data source; older halves answer `unknown
                 // endpoint`, which hides the badge.
                 this.call('plugin/version').catch(() => null),
@@ -594,8 +670,14 @@ export class AcpStore {
                 preset: presetResult?.preset ?? undefined,
                 tagHalo: tagHaloResult?.halo ?? { ...DEFAULT_TAG_HALO },
                 approvalDeadlines: deadlinesResult.deadlines,
+                idleRelease: idleReleaseResult.idleRelease,
                 pluginVersion: versionResult?.version !== undefined && versionResult.version !== '' ? versionResult.version : undefined,
             });
+            // `sessions/list` is the `/acp` RPC face; the composer's chat rows
+            // (agent modes, occupancy) are a separate list. A reconnect must refresh
+            // that list too or the ring keeps a pre-outage sample until a turn ends.
+            if (this.state.chatSessionsFor !== undefined)
+                void this.loadChatSessions(this.state.chatSessionsFor);
             const active = this.state.activeSessionId ?? sessions[0]?.sessionId;
             if (active !== undefined)
                 await this.loadTranscript(active);
@@ -1057,9 +1139,9 @@ export class AcpStore {
      * the frame's authority.
      */
     loadChatSessions(dshSessionId, options) {
-        // Two composer entries read this (the agent-mode control and the ACP
-        // cluster) and both re-read when a turn settles; one round-trip answers
-        // for both instead of two racing ones. A caller arriving mid-read waits
+        // The composer entries (agent-mode control, ACP cluster, occupancy ring)
+        // read this and re-read when a turn settles; one round-trip answers for
+        // all of them instead of racing reads. A caller arriving mid-read waits
         // for THAT read rather than returning immediately: the slash source's
         // one-shot "do I have a verdict yet?" ask is only useful if it can
         // receive the answer of a read already in flight.
@@ -1074,7 +1156,7 @@ export class AcpStore {
     async readChatSessionList(dshSessionId, options, read) {
         const settle = options?.settleVerdict === true || !this.acpModeLive.has(dshSessionId);
         try {
-            const { sessions, acpMode, boundAgentId, lockedAgentId, choice } = await this.call('session/chat-list', { dshSessionId, refresh: true });
+            const { sessions = [], acpMode, boundAgentId, lockedAgentId, choice } = await this.call('session/chat-list', { dshSessionId, refresh: true });
             // A committed `agent-preset/selected` frame may have settled this
             // session's verdict while the read was in flight; the host answer then
             // describes the log as of BEFORE that switch and must not overwrite it.
@@ -1229,6 +1311,13 @@ export class AcpStore {
      * being the one authorized exception. Same no-op-when-unchanged discipline as
      * the other accessors, so a frame restating the held verdict costs no
      * listener churn.
+     *
+     * The seat gate (`syncAcpMode`) is the SECOND caller: it folds the runtime
+     * row's own `agentPreset` — the same session-log source the frames announce —
+     * through here, in both directions. That hands the row the frame's authority
+     * on purpose (one provenance, one rank): a stale projection is corrected by
+     * the gate's next evaluation with fresher row data, and only HOST READS are
+     * barred from regressing what the runtime itself already said.
      */
     noteAcpMode(dshSessionId, acpMode) {
         this.acpModeLive.add(dshSessionId);
@@ -1313,11 +1402,92 @@ export class AcpStore {
     async setChatSessionMode(dshSessionId, modeId, agentId) {
         try {
             await this.call('session/chat-mode-set', { dshSessionId, modeId, ...(agentId === undefined ? {} : { agentId }) });
+            const safeAgent = (agentId && agentId.trim()) || undefined;
+            this.writeChoice(dshSessionId, choice => ({ ...choice, mode: modeId }), safeAgent);
+            if (this.state.chatSessionsFor === dshSessionId) {
+                const owner = safeAgent ?? this.state.chatChoice[dshSessionId]?.agentId ?? this.state.chatBoundAgent[dshSessionId] ?? this.state.defaultAgent;
+                let changed = false;
+                const chatSessions = this.state.chatSessions.map(s => {
+                    if (s.agentId !== owner || !s.modes || s.modes.currentModeId === modeId)
+                        return s;
+                    changed = true;
+                    return { ...s, modes: { ...s.modes, currentModeId: modeId } };
+                });
+                if (changed)
+                    this.mutate({ chatSessions });
+            }
+        }
+        catch (error) {
+            this.flashError(error);
+        }
+        await this.loadChatSessions(dshSessionId);
+    }
+    /**
+     * Bring the conversation's released ACP session back on a fresh process —
+     * the released banner's explicit form of the "next message resumes it"
+     * promise (`session/chat-resume`). A failure is reported through the notice
+     * AND rethrown (the `respondPermission` contract), so the banner can pin
+     * the message beside the button the user just pressed; the binding is
+     * re-read either way so the row follows the host's real answer.
+     */
+    async resumeChatSession(dshSessionId) {
+        let failure;
+        try {
+            await this.call('session/chat-resume', { dshSessionId });
         }
         catch (error) {
             this.flashError(error);
+            failure = error;
         }
         await this.loadChatSessions(dshSessionId);
+        if (failure !== undefined)
+            throw failure;
+    }
+    /**
+     * Branch one conversation (the NTR branch button's click): the fixed
+     * two-stage order — the HOST forks the DSH session tree first (copied
+     * history, `(1)` title, workspace), then the plugin adopts the ACP side via
+     * `session/chat-fork-adopt`, which runs the agent's own `session/fork` so
+     * the child actually remembers the parent context. Host first is structural:
+     * ACP fork has no cut-point parameter and nothing to return to if the host
+     * half failed second (see the plan's §D7).
+     *
+     * Resolves `{ childId }` on success, or `{ failure }` with one actionable
+     * line — the reason is ALSO flashed into the notice banner (a user-action
+     * failure, so the banner is its surface), and the local line is what the
+     * conversation renders beside the button (the user is not on the settings
+     * page). A failed adopt leaves the child an ordinary copied-history
+     * conversation (its first message starts a fresh `session/new` — today's
+     * behavior), never a half-bound one, and NOTHING is opened.
+     *
+     * `forkHost` is the runtime's `sessions.fork` face, resolved structurally by
+     * the entry and injected here: the store stays transport-free.
+     */
+    async forkChatSession(dshSessionId, forkHost) {
+        let childId;
+        try {
+            childId = await forkHost(dshSessionId);
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error.message : String(error);
+            this.flashError(failure);
+            return { failure };
+        }
+        if (typeof childId !== 'string' || childId === '') {
+            const failure = this.locale('宿主没有返回分支会话，分支未完成。', 'The host returned no branched session; the branch did not complete.');
+            this.flashError(new Error(failure));
+            return { failure };
+        }
+        try {
+            await this.call('session/chat-fork-adopt', { dshSessionId: childId, parentDshSessionId: dshSessionId });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            const failure = this.locale(`分支会话已创建，但没有接上 agent 的上下文（${reason}）；在子会话里发送的第一条消息会开启全新会话。`, `The branched session was created but the agent context was not attached (${reason}); its first message will start a fresh session.`);
+            this.flashError(new Error(failure));
+            return { failure };
+        }
+        return { childId };
     }
     // ---- ACP transcript observation (the conversation's ACP view) ----
     /**
@@ -1489,6 +1659,34 @@ export class AcpStore {
     async resetApprovalDeadlines() {
         await this.writeApprovalDeadlines({ reset: true });
     }
+    /**
+     * Write the idle-release window (in ms).
+     *
+     * The host answer — the same route returns the window now in force — is
+     * the authority, so an optimistic write that the host trims self-corrects
+     * instead of drifting from what runs.
+     */
+    async setIdleRelease(idleTimeoutMs) {
+        await this.writeIdleRelease({ idleTimeoutMs });
+    }
+    /**
+     * Drop the persisted override: the config file (or the built-in default)
+     * decides again.
+     */
+    async resetIdleRelease() {
+        await this.writeIdleRelease({ reset: true });
+    }
+    async writeIdleRelease(payload) {
+        const previous = this.state.idleRelease;
+        try {
+            const result = await this.call('ui/idle-release-set', payload);
+            this.mutate({ idleRelease: result.idleRelease });
+        }
+        catch (error) {
+            this.mutate({ idleRelease: previous });
+            this.flashError(error);
+        }
+    }
     async writeApprovalDeadlines(payload) {
         const previous = this.state.approvalDeadlines;
         // Optimistic only where it is safe: the effective numbers and the mode move
@@ -1542,7 +1740,21 @@ export class AcpStore {
             // Optimistic for the same reason the binding is: the host recorded the
             // pick, and a conversation with no ACP session yet would otherwise show
             // the agent's default until its first turn created one.
-            this.writeChoice(dshSessionId, choice => ({ ...choice, modelId }), agentId);
+            const safeAgent = (agentId && agentId.trim()) || undefined;
+            const targetAgent = safeAgent ?? (modelId ? splitModelAgentId(modelId) : undefined);
+            this.writeChoice(dshSessionId, choice => ({ ...choice, modelId }), targetAgent);
+            if (this.state.chatSessionsFor === dshSessionId) {
+                const owner = targetAgent ?? this.state.chatChoice[dshSessionId]?.agentId ?? this.state.chatBoundAgent[dshSessionId] ?? this.state.defaultAgent;
+                let changed = false;
+                const chatSessions = this.state.chatSessions.map(s => {
+                    if (s.agentId !== owner || s.modelId === modelId)
+                        return s;
+                    changed = true;
+                    return { ...s, modelId };
+                });
+                if (changed)
+                    this.mutate({ chatSessions });
+            }
         }
         catch (error) {
             this.flashError(error);
@@ -1557,10 +1769,23 @@ export class AcpStore {
                 ...(effort === undefined ? {} : { effort }),
                 ...(agentId === undefined ? {} : { agentId }),
             });
+            const targetAgent = (agentId && agentId.trim()) || undefined;
             this.writeChoice(dshSessionId, choice => {
                 const { effort: _dropped, ...rest } = choice;
                 return effort === undefined ? rest : { ...rest, effort };
-            }, agentId);
+            }, targetAgent);
+            if (this.state.chatSessionsFor === dshSessionId) {
+                const owner = targetAgent ?? this.state.chatChoice[dshSessionId]?.agentId ?? this.state.chatBoundAgent[dshSessionId] ?? this.state.defaultAgent;
+                let changed = false;
+                const chatSessions = this.state.chatSessions.map(s => {
+                    if (s.agentId !== owner || s.reasoningEffort === effort)
+                        return s;
+                    changed = true;
+                    return { ...s, reasoningEffort: effort };
+                });
+                if (changed)
+                    this.mutate({ chatSessions });
+            }
         }
         catch (error) {
             this.flashError(error);
@@ -1628,6 +1853,16 @@ export class AcpStore {
     clearNotice() {
         this.mutate({ notice: undefined });
     }
+    /** Drop every retained runtime-log line (the unread counter restarts too). */
+    clearLogs() {
+        this.mutate({ logs: [], logUnread: 0 });
+    }
+    /** The user looked at the log: clear the unread badge. */
+    markLogsRead() {
+        if (this.state.logUnread === 0)
+            return;
+        this.mutate({ logUnread: 0 });
+    }
     flashError(error) {
         this.mutate({ notice: error instanceof Error ? error.message : String(error) });
     }
@@ -1635,7 +1870,7 @@ export class AcpStore {
     applyEvent(event) {
         switch (event.type) {
             case 'agent/notice': {
-                this.mutate({ notice: event.text });
+                this.mutate(this.logPatch(event.level, event.text, event.agentId));
                 return Promise.resolve();
             }
             case 'agent/status': {
@@ -1658,14 +1893,24 @@ export class AcpStore {
                 return Promise.resolve();
             }
             case 'session/meta': {
-                // Host re-published the session view after mode/config changes.
+                // Host re-published the session view after mode/config changes or a
+                // resume. The composer's occupancy ring reads the chat-list row, so
+                // that row must follow the snapshot's usage too — including an absent
+                // one, which must clear an older reading rather than outlive it.
                 const sessions = this.state.sessions.some(s => s.sessionId === event.sessionId)
                     ? this.state.sessions.map(s => (s.sessionId === event.sessionId ? event.session : s))
                     : this.state.sessions;
-                this.mutate({ sessions, ...this.watchedSessionPatch(event.sessionId, event.session) });
+                let chatSessions = withSessionUsage(this.state.chatSessions, event.sessionId, event.session.usage);
+                chatSessions = withSessionModes(chatSessions, event.sessionId, event.session.modes);
+                this.mutate({
+                    sessions,
+                    ...(chatSessions === this.state.chatSessions ? {} : { chatSessions }),
+                    ...this.watchedSessionPatch(event.sessionId, event.session),
+                });
                 return Promise.resolve();
             }
             case 'session/closed': {
+                const closingSession = this.state.sessions.find(s => s.sessionId === event.sessionId);
                 const sessions = this.state.sessions.filter(s => s.sessionId !== event.sessionId);
                 const active = this.state.activeSessionId === event.sessionId ? sessions[0]?.sessionId : this.state.activeSessionId;
                 this.openTurns.delete(event.sessionId);
@@ -1681,7 +1926,9 @@ export class AcpStore {
                     chatTranscripts: closedTranscripts,
                     ...(chatSessions.length !== this.state.chatSessions.length ? { chatSessions } : {}),
                     permissions: this.state.permissions.filter(p => p.sessionId !== event.sessionId),
-                    ...(event.reason === 'agent-died' ? { notice: this.locale('会话因 agent 进程退出而终止', 'session ended: agent process died') } : {}),
+                    ...(event.reason === 'agent-died'
+                        ? this.logPatch('error', this.locale('会话因 agent 进程退出而终止', 'session ended: agent process died'), closingSession?.agentId)
+                        : {}),
                 });
                 return Promise.resolve();
             }
@@ -1695,9 +1942,23 @@ export class AcpStore {
                 // The composer's own list (`session/chat-list` views) must flip too, or
                 // the agent tag's live halo keeps breathing for a process that is gone:
                 // nothing else re-reads this list until the next turn settles.
-                const chatSessions = this.state.chatSessions.some(s => s.sessionId === event.sessionId)
-                    ? this.state.chatSessions.map(s => (s.sessionId === event.sessionId ? { ...s, released: true } : s))
-                    : this.state.chatSessions;
+                const chatSessions = withSessionReleased(this.state.chatSessions, event.sessionId, true);
+                // One runtime-log line per release cause; `idle` stays silent on
+                // purpose (an expected lifecycle transition, not a fault).
+                const cause = event.cause ?? 'died';
+                let log = {};
+                if (cause === 'workspace') {
+                    log = this.logPatch('info', this.locale('agent 为切换工作区重启，会话已挂起；再次发送消息将自动恢复。', 'agent restarted for its workspace; the session is paused and will resume on your next message.'), event.session.agentId);
+                }
+                else if (cause === 'resume-failed') {
+                    log = this.logPatch('error', this.locale('会话恢复失败；再次发送消息将重试恢复。', 'session resume failed; your next message will retry it.'), event.session.agentId);
+                }
+                else if (cause === 'stalled') {
+                    log = this.logPatch('error', this.locale('agent 未响应卡死的回合，会话已挂起；再次发送消息将自动恢复。', 'agent did not acknowledge the stalled turn; the session is paused and will resume on your next message.'), event.session.agentId);
+                }
+                else if (cause === 'died') {
+                    log = this.logPatch('error', this.locale('agent 进程已退出，会话已挂起；再次发送消息将自动恢复。', 'agent process died; the session is paused and will resume on your next message.'), event.session.agentId);
+                }
                 this.mutate({
                     sessions,
                     ...(chatSessions !== this.state.chatSessions ? { chatSessions } : {}),
@@ -1705,7 +1966,7 @@ export class AcpStore {
                     // An observed transcript keeps its buffer but flips to released, so
                     // the ACP view can say "会恢复" instead of silently looking dead.
                     ...this.watchedSessionPatch(event.sessionId, event.session),
-                    notice: this.locale('agent 进程已退出，会话已挂起；再次发送消息将自动恢复。', 'agent process died; the session is paused and will resume on your next message.'),
+                    ...log,
                 });
                 return Promise.resolve();
             }
@@ -1723,8 +1984,15 @@ export class AcpStore {
                 // an observed transcript must drop both its blocks and its watermark
                 // or the replay would be read as a gap and refetched forever.
                 const watched = this.state.chatTranscripts[event.sessionId];
+                // ...and the composer's own list must flip back to live on the same
+                // event (mirror of the `session/released` flip): the released banner
+                // and the tag's halo read that row, and nothing else re-reads it until
+                // a turn settles — a resume would leave the banner claiming a parked
+                // process that is already back.
+                const chatSessions = withSessionReleased(this.state.chatSessions, event.sessionId, false);
                 this.mutate({
                     sessions,
+                    ...(chatSessions === this.state.chatSessions ? {} : { chatSessions }),
                     ...(isActive ? { blocks: [] } : {}),
                     ...(watched === undefined ? {} : {
                         chatTranscripts: {
@@ -1836,6 +2104,17 @@ export class AcpStore {
             case 'turn/start': {
                 this.openTurns.add(event.sessionId);
                 this.markWatchedRunning(event.sessionId, true);
+                // The session materializes inside this turn; if the composer's list
+                // has not seen its row yet (the mount/running read beat session/new),
+                // read once now so the occupancy ring has a row for the live usage
+                // ticks. The per-session set bounds this to one extra read.
+                const chatSessionId = this.state.chatSessionsFor;
+                if (chatSessionId !== undefined
+                    && !this.state.chatSessions.some(row => row.sessionId === event.sessionId)
+                    && !this.chatSessionRowReads.has(event.sessionId)) {
+                    this.chatSessionRowReads.add(event.sessionId);
+                    void this.loadChatSessions(chatSessionId);
+                }
                 if (event.sessionId === this.state.activeSessionId) {
                     this.state.blocks.push({ kind: 'user', text: event.text });
                     trimBlocks(this.state.blocks);
@@ -2018,6 +2297,114 @@ export const STATE_ONLY_UPDATES = new Set([
     'usage_update',
     'session_info_update',
 ]);
+/**
+ * Context occupancy carried by one raw `usage_update` frame, in the shape the
+ * session snapshots already use. A malformed frame is ignored (the last good
+ * sample stays on screen) instead of zeroing the meter.
+ */
+export function usageFromUpdate(update) {
+    const used = update.used;
+    const size = update.size;
+    if (typeof used !== 'number' || !Number.isFinite(used))
+        return undefined;
+    if (typeof size !== 'number' || !Number.isFinite(size))
+        return undefined;
+    const cost = update.cost;
+    if (cost !== null && typeof cost === 'object' && !Array.isArray(cost)) {
+        const row = cost;
+        if (typeof row.amount === 'number' && Number.isFinite(row.amount)
+            && typeof row.currency === 'string' && row.currency !== '') {
+            return { used, size, cost: { amount: row.amount, currency: row.currency } };
+        }
+    }
+    return { used, size };
+}
+function sameUsage(left, right) {
+    if (left === right)
+        return true;
+    if (left === undefined || right === undefined)
+        return false;
+    if (left.used !== right.used || left.size !== right.size)
+        return false;
+    const leftCost = left.cost;
+    const rightCost = right.cost;
+    if (leftCost === undefined || rightCost === undefined)
+        return leftCost === rightCost;
+    return leftCost.amount === rightCost.amount && leftCost.currency === rightCost.currency;
+}
+/** Patch one session row's usage; other rows and an unchanged value keep their identities. */
+function withSessionUsage(rows, sessionId, usage) {
+    let changed = false;
+    const next = rows.map(row => {
+        if (row.sessionId !== sessionId || sameUsage(row.usage, usage))
+            return row;
+        changed = true;
+        return { ...row, usage };
+    });
+    return changed ? next : rows;
+}
+/**
+ * Flip one chat row's `released` flag (release/resume bookkeeping). The
+ * composer's own list (`session/chat-list` rows) has no other live writer —
+ * `session/released` must mark it, `session/reset` must un-mark it, or the
+ * agent tag's halo and the released banner read yesterday's process state.
+ */
+function withSessionReleased(rows, sessionId, released) {
+    let changed = false;
+    const next = rows.map(row => {
+        if (row.sessionId !== sessionId || (row.released === true) === released)
+            return row;
+        changed = true;
+        return { ...row, released };
+    });
+    return changed ? next : rows;
+}
+function sameModes(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.currentModeId !== b.currentModeId)
+        return false;
+    const aModes = a.availableModes ?? [];
+    const bModes = b.availableModes ?? [];
+    if (aModes.length !== bModes.length)
+        return false;
+    return aModes.every((m, i) => {
+        const o = bModes[i];
+        return m != null && o != null && m.id === o.id && m.name === o.name && m.description === o.description;
+    });
+}
+function withSessionModes(rows, sessionId, modes) {
+    if (!modes)
+        return rows;
+    let changed = false;
+    const next = rows.map(row => {
+        if (row.sessionId !== sessionId || sameModes(row.modes, modes))
+            return row;
+        changed = true;
+        return { ...row, modes };
+    });
+    return changed ? next : rows;
+}
+function splitModelAgentId(modelId) {
+    const at = modelId.indexOf('@');
+    const agent = at === -1 ? modelId.trim() : (at === 0 ? '' : modelId.slice(0, at).trim());
+    return agent || undefined;
+}
+/** Last well-formed `usage_update` in one coalesced batch (later ticks win). */
+function usageOfBatch(items) {
+    let usage;
+    for (const item of items) {
+        const update = item.update;
+        if (update.sessionUpdate !== 'usage_update')
+            continue;
+        const parsed = usageFromUpdate(update);
+        if (parsed !== undefined)
+            usage = parsed;
+    }
+    return usage;
+}
 function trimBlocks(blocks) {
     if (blocks.length > MAX_BLOCKS)
         blocks.splice(0, blocks.length - MAX_BLOCKS);