allaboard 0.4.0 → 0.6.0

package/dist/core/sessions/session.js

@@ -49,15 +49,18 @@ import { errorName } from "../../values.js";
 import { footerFields, formatStatusFields, gitState, sessionTokens, } from "../footer.js";
 import { modelName } from "../models.js";
 import { resolvePath } from "../paths.js";
+import { described } from "../reply/previews.js";
 import { endedLine, TurnRenderer, taskTitle, } from "../reply/renderer.js";
 import { oneLine, TITLE_LIMIT } from "../reply/words.js";
 import { DENY, toAnswer } from "../requests.js";
 import { DEFAULT } from "../setup.js";
 import * as texts from "../texts.js";
 import { FAILURE_LIMIT, HOLD_MARKER, IDLE_CLOSE_SECONDS, INJECTED_TURN_WAIT, PROCESS_EXITED, STOP_TAIL_WAIT, SUMMARY_IS_END_LINE, TASK_EVENTS, TASK_REPLIES_KEPT, TASK_WORDS, TASKS_KEPT, TURN_EVENTS, } from "./constants.js";
-import { checkDirectory, repositoryBy, terminalLine, trustedBy } from "./directory.js";
+import { checkDirectory, repositoryBy, terminalLine, trustedBy, untrustedNotice, } from "./directory.js";
 import { BypassUnavailable, DirectoryUnavailable, SessionClosed, SessionGone, StartsBlocked, } from "./errors.js";
+import { quoted } from "./quote.js";
 import { Cancelled, cancellable, Event, Mutex, Queue, Task } from "./tasks.js";
+import { ThreadTitle } from "./title.js";
 import { notSent, Turn, takenNote } from "./turn.js";
 export const logger = getLogger("allaboard.core.sessions");
 /** The signal for a `finally`: none once it has aborted, since an aborted signal stays aborted. */
@@ -88,6 +91,8 @@ export class ThreadSession {
     // for a thread not open yet).
     resolved;
     deps;
+    // The session's title on the root, asked for at the end of each turn.
+    title;
     // One status on the session's root message, which `threadId` always is, and the line under
     // the thread's last message (issues #83 and #95): both are the chat's to draw.
     thread;
@@ -165,6 +170,11 @@ export class ThreadSession {
     endedAhead = [];
     // Each task's type and description, for the list of what still runs and the task's end line.
     tasks = new Map();
+    // A subagent's tasks by the call that started them, and the step each is at: when it started,
+    // the call it made last as the thread words it, and how many calls it has made. They follow
+    // `tasks`: an entry goes with its task's end and with the task a cap drops.
+    agentCalls = new Map();
+    steps = new Map();
     // How many times each task started, kept past its end: a resumed task keeps its id (SDK
     // 0.3.300, `SDKTaskStartedMessage.run_id`), and nothing else says it is one. A reply asks
     // here, so that an agent a message continues gets no second launch line.
@@ -186,6 +196,23 @@ export class ThreadSession {
     // Tasks `!stop` ended. Claude Code starts no turn to report such a task: its notification
     // stays queued (measured twice on 2026-09-27, Claude Code 2.1.283), so none is awaited.
     stopped = new Set();
+    // True from the start of a process that resumes a session until its first turn. Such a process
+    // tells first of the tasks the session before it lost ("didn't finish before the previous
+    // session ended", measured 2026-10-18, Claude Code 2.1.302, as the cut of `!stop` or of a forced
+    // restart leaves them) and ends an empty turn; an event for a task this daemon never saw is
+    // dropped then, so neither shows nor is awaited as a report.
+    resumedAtStart = false;
+    // The footer's model and context, read from the process `!stop` is about to close.
+    closingContext = null;
+    // The last model and context share a live read gave (a footer or `!status`). A footer drawn
+    // with no process to ask (after a `!stop` whose own read did not answer) shows it; a process
+    // that resumes the session replaces it with its first read. A model switch or a compaction
+    // drops it, since its share no longer holds. Never shared with another session.
+    lastContext = null;
+    // Counts the invalidations of `lastContext`: a read that started before one is not kept.
+    contextGeneration = 0;
+    // Whether this turn's end already asked for the read `keepContext` makes: one per turn.
+    contextKept = false;
     // The replies already logged as ended with no report under them: `closeOut` sets its flag
     // after an await, so two timers waking together would log one reply twice.
     endedUnreported = new WeakSet();
@@ -313,6 +340,7 @@ export class ThreadSession {
         this.directory = directory;
         this.resolved = resolvePath(directory);
         this.deps = deps;
+        this.title = new ThreadTitle(deps, channelId, threadId, directory, options.stopped);
         this.names = texts.namesOf(deps.agent, deps.chat);
         this.thread = deps.chat.thread({ channel: channelId, thread: threadId });
         this.predecessor = options.predecessor ?? null;
@@ -390,6 +418,10 @@ export class ThreadSession {
     get waitingForOwner() {
         return this.waiting.size > 0;
     }
+    /** Working or waiting for the owner: a thread that is never deleted (`SessionManager.release`). */
+    get inUse() {
+        return this.waitingForOwner || !this.idle;
+    }
     /**
      * What the thread's activity line says, empty for nothing, and the same after the app's
      * name. `Working…` while a prompt of the owner's is owed its answer (`promptOwed`), however
@@ -838,6 +870,7 @@ export class ThreadSession {
                 throw error;
             }
             this.client = client;
+            this.resumedAtStart = sessionId !== null;
             this.clientEffort = effort;
             this.clientBypass = this.bypassRuns(choice);
             this.mode = mode;
@@ -1033,21 +1066,25 @@ export class ThreadSession {
     async dropClient() {
         const release = await this.connectLock.acquire();
         try {
-            const reader = this.reader;
-            this.reader = null;
-            const client = this.client;
-            this.client = null;
-            if (reader !== null) {
-                reader.cancel();
-                await reader.settled();
-            }
-            if (client !== null)
-                await this.disconnect(client);
+            await this.dropClientLocked();
         }
         finally {
             release();
         }
     }
+    /** `dropClient` for a caller that holds the connect lock. */
+    async dropClientLocked() {
+        const reader = this.reader;
+        this.reader = null;
+        const client = this.client;
+        this.client = null;
+        if (reader !== null) {
+            reader.cancel();
+            await reader.settled();
+        }
+        if (client !== null)
+            await this.disconnect(client);
+    }
     /**
      * During a stop: bring the thread's activity line up to date. Once only background tasks are
      * left it says which ones the restart waits for (`threadLine`), since only the owner knows
@@ -1100,7 +1137,11 @@ export class ThreadSession {
         if (client === null)
             return held ? null : false;
         const tasks = this.background ? this.runningTaskIds() : [];
-        if (!this.busy && tasks.length === 0) {
+        // A task that has just ended by itself leaves the agent about to open the turn that reports
+        // it (1.3 to 1.8 s later, measured for #338 on Claude Code 2.1.302), and carry on from
+        // there: that is still work to stop (issue #375).
+        const reportOwed = this.injectedExpected || this.reporting;
+        if (!this.busy && tasks.length === 0 && !reportOwed) {
             // A Start being applied may be inside the agent's own model command, a turn no reply
             // shows: the interrupt ends it, and the setup then fails into `forgetSetup`, which the
             // cancelled hold turns into `Not sent.`
@@ -1113,22 +1154,27 @@ export class ThreadSession {
         // says after a task stopped with no turn running. Its next word counts again.
         this.agentState = null;
         this.showThreadStatus();
-        if (this.busy) {
-            // A denial `denyAll` triggers below resolves `askOwner`'s own wait, whose `finally`
-            // would otherwise race this method's own closing ✅ back to working; this flag makes it
-            // skip that instead. `finish` or `abandon` clears it once this turn's own tail ends.
-            this.interrupting = true;
-            this.stopTail = this.stopTail ?? new Event();
-            for (const pending of this.deps.approvals.denyAll(this.channelId, this.threadId)) {
-                await this.deleteRequest(pending.messageTs);
-            }
-            try {
-                await client.interrupt();
-            }
-            catch (error) {
-                // A query already closed refuses the request; the tasks below still stop.
-                logger.warning(`could not interrupt ${this.where}: ${errorName(error)}`);
-            }
+        // Only background tasks, or the report of one, are left. Stopping them one by one makes the
+        // agent open a turn of its own to react 1-2 s later and carry on (issue #338); closing its
+        // process ends them all for good, and the owner's next message resumes the session.
+        if (!this.busy && (await this.endWithProcess(client, tasks))) {
+            this.react("done");
+            return true;
+        }
+        // A denial `denyAll` triggers below resolves `askOwner`'s own wait, whose `finally`
+        // would otherwise race this method's own closing ✅ back to working; this flag makes it
+        // skip that instead. `finish` or `abandon` clears it once this turn's own tail ends.
+        this.interrupting = true;
+        this.stopTail = this.stopTail ?? new Event();
+        for (const pending of this.deps.approvals.denyAll(this.channelId, this.threadId)) {
+            await this.deleteRequest(pending.messageTs);
+        }
+        try {
+            await client.interrupt();
+        }
+        catch (error) {
+            // A query already closed refuses the request; the tasks below still stop.
+            logger.warning(`could not interrupt ${this.where}: ${errorName(error)}`);
         }
         for (const taskId of tasks) {
             this.stopped.add(taskId);
@@ -1145,6 +1191,82 @@ export class ThreadSession {
         this.react("done");
         return true;
     }
+    /**
+     * Close the agent's process, which ends its background tasks (measured 2026-10-18, Claude
+     * Code 2.1.302: none survives), and draw each task's end as the agent would report it. The
+     * session keeps its thread, id, bypass and effort: `ensureConnected` resumes it. False, with
+     * nothing done, when a turn started while this waited for the lock.
+     */
+    async endWithProcess(client, tasks) {
+        // Held until the ends are drawn: a process resumed meanwhile would deliver its own word on
+        // the lost tasks into the middle of them.
+        const release = await this.connectLock.acquire();
+        // The reader kept dispatching while the lock was taken: a report turn that started meanwhile
+        // is a running turn, which the caller interrupts instead. From here to the reader's cancel in
+        // `dropClientLocked` nothing awaits, so no turn can start in between.
+        if (this.busy) {
+            release();
+            return false;
+        }
+        try {
+            for (const taskId of tasks)
+                this.stopped.add(taskId);
+            // The footer the stop draws names the model and the context. The read starts while the
+            // process lives, and the close does not wait for it: a CLI that never answers a control
+            // request would hold the lock for good, and the SDK rejects a request still pending when
+            // the query closes (sdk.mjs 0.3.302). Used only if it answered before the process ended.
+            let answered = false;
+            void client.contextUsage().then((usage) => {
+                this.closingContext = usage;
+                answered = true;
+            }, () => { });
+            this.interrupting = true;
+            await this.dropClientLocked();
+            // An approval a background agent waits on goes with the process, as in a stopped turn.
+            for (const pending of this.deps.approvals.denyAll(this.channelId, this.threadId)) {
+                await this.deleteRequest(pending.messageTs);
+            }
+            if (!answered) {
+                this.closingContext = null;
+                logger.warning(`the context usage did not answer before the stop closed ${this.where}`);
+            }
+            for (const taskId of tasks) {
+                await this.dispatch({
+                    type: "task_ended",
+                    taskId,
+                    status: "stopped",
+                    summary: "",
+                    durationMs: null,
+                    callId: null,
+                    foldNamed: false,
+                });
+            }
+            // A report the agent was about to open, or a task's notification still on its way, went
+            // with the process (issue #375): what waited on them ends now, as when none comes. A
+            // resumed process's word on such a task is not shown, as for a stopped one.
+            for (const taskId of this.unreported.keys())
+                this.stopped.add(taskId);
+            this.unreported.clear();
+            for (const expiry of this.expiring)
+                expiry.cancel();
+            this.notificationWaits = false;
+            if (this.injectedExpected) {
+                this.expiry?.cancel();
+                await this.reportNotComing();
+            }
+            else {
+                await this.sweepClosedOut(undefined, { unreported: true });
+                await this.reactDoneIfIdle();
+            }
+        }
+        finally {
+            this.interrupting = false;
+            this.closingContext = null;
+            release();
+        }
+        this.idleTimerCheck();
+        return true;
+    }
     async interruptApplied(client) {
         try {
             await client.interrupt();
@@ -1215,6 +1337,16 @@ export class ThreadSession {
                 ];
             }
         }
+        // Not with a folder no session can start in: that is what the owner acts on first.
+        const untrusted = usable ? await this.untrustedLines() : [];
+        // The agent's title is read with the footer's values, before the check below: it is the last
+        // await of this call, so a close that came while it ran is seen.
+        const stored = this.deps.state.thread(this.channelId, this.threadId);
+        const sessionId = stored?.sessionId ?? null;
+        const title = sessionId ? await this.readTitle(sessionId) : null;
+        // A title the turn's end missed (written a moment after it) reaches the root now too.
+        if (title !== null)
+            void this.title.refresh();
         // The daemon closed the session (shutdown, an idle close) while this call was reading it.
         if (this.closedFlag && !gone)
             throw new SessionClosed();
@@ -1227,24 +1359,68 @@ export class ThreadSession {
         const running = this.runningKindsOf();
         if (running)
             fields.push(texts.fill(texts.STATUS_BACKGROUND, { counts: running }));
-        const stored = this.deps.state.thread(this.channelId, this.threadId);
         const activity = this.busy
             ? texts.fill(texts.ACTIVITY_BUSY, { queued: this.queue.size })
             : texts.ACTIVITY_IDLE;
-        const sessionId = stored?.sessionId ?? null;
         const head = [
             texts.fill(texts.STATUS, { directory: this.directory, session: sessionId || "new" }),
         ];
         // Left out with a folder the line above cannot use: its `cd` would fail there.
         if (sessionId && usable)
             head.push(terminalLine(this.deps.agent.words.terminal, this.directory, sessionId, (text) => this.deps.chat.escape(text, "reference")));
+        if (title) {
+            head.push(
+            // On one line, as the root shows it: a title set from a pasted text may hold a break.
+            texts.fill(texts.STATUS_TITLE, {
+                title: this.deps.chat.escape(title.replace(/\s+/g, " ").trim(), "reference"),
+            }));
+        }
         const state = texts.fill(texts.named(texts.STATUS_STATE, this.names), {
             mode: this.bypass ? (this.bypassMode ?? this.mode) : this.mode,
             // Only a turn's first event carries the version, never the start (measured).
             version: this.cliVersion || (this.client !== null ? texts.VERSION_PENDING : "not started"),
             activity,
         });
-        return [...head, state, ...fields, ...unavailable].join("\n");
+        // Last: a line after a quote would read as part of it. The root's text is the chat's own
+        // markup, shown as it was written. A message past the chat's limit is split by the chat at
+        // line breaks, and every line of the quote carries its mark.
+        const prompt = stored?.rootPrompt
+            ? [
+                texts.fill(texts.STATUS_PROMPT, {
+                    quote: quoted(stored.rootPrompt, (piece) => this.deps.chat.escape(piece, "words")),
+                }),
+            ]
+            : [];
+        return [...head, state, ...fields, ...unavailable, ...untrusted, ...prompt].join("\n");
+    }
+    /**
+     * What tells the owner which repositories below the thread's folder still need the agent's
+     * trust (issue #247); nothing for an agent that keeps no record of trust.
+     */
+    async untrustedLines() {
+        try {
+            return await untrustedNotice(this.deps.agent, this.directory, this.names, (text) => this.deps.chat.escape(text, "reference"));
+        }
+        catch (error) {
+            if (error instanceof Cancelled)
+                throw error;
+            // The status still answers, without the list.
+            logger.warning(`could not look for repositories to trust in ${this.where}: ${errorName(error)}`);
+            return [];
+        }
+    }
+    /**
+     * The agent's title for the session, or null when it has none or cannot be read: `!status` then
+     * leaves the line out and says nothing of it beyond a log line.
+     */
+    async readTitle(sessionId) {
+        try {
+            return await this.title.read(sessionId);
+        }
+        catch (error) {
+            logger.warning(`could not read the session's title for ${this.where}: ${errorName(error)}`);
+            return null;
+        }
     }
     now() {
         return (this.deps.now ?? Date.now)();
@@ -1708,6 +1884,8 @@ export class ThreadSession {
             case "model_changed":
                 this.modelSwitched = event.model;
                 this.modelSwitchedInTurn = this.active !== null;
+                // The share was measured against the old model's window.
+                this.forgetContext();
                 return;
             case "folder_changed":
                 this.workingDirectory = event.folder;
@@ -1737,6 +1915,9 @@ export class ThreadSession {
                 // seconds later in the recordings (2026-10-08, CLI 2.1.292). The back end says each
                 // once.
                 const compacting = event.type === "compaction_started";
+                // A compaction shrinks the context: a share read before it is no longer true.
+                if (compacting)
+                    this.forgetContext();
                 if (compacting !== this.compacting) {
                     this.compacting = compacting;
                     this.showThreadStatus();
@@ -1746,7 +1927,16 @@ export class ThreadSession {
             default:
                 break;
         }
+        this.followStep(event);
         const task = isTaskEvent(event) ? event : null;
+        if (this.resumedAtStart) {
+            if (TURN_EVENTS.has(event.type)) {
+                this.resumedAtStart = false;
+            }
+            else if (task !== null && event.type !== "task_started" && !this.tasks.has(task.taskId)) {
+                return;
+            }
+        }
         if (task !== null) {
             const inner = this.nestingReply(task);
             if (inner !== null) {
@@ -1819,6 +2009,7 @@ export class ThreadSession {
             // Read above for the end line, which comes after the terminal task_updated (recorded
             // order); a task whose notification never comes goes with the process.
             this.tasks.delete(event.taskId);
+            this.forgetSteps(event.taskId);
         }
         const holder = task === null ? undefined : this.taskReplies.get(task.taskId);
         if (task !== null && holder !== undefined) {
@@ -1968,11 +2159,17 @@ export class ThreadSession {
             finally {
                 this.turnEnding = false;
                 this.showThreadStatus();
+                void this.title.refresh();
             }
         }
     }
     recordTask(event) {
         this.tasks.set(event.taskId, [event.kind, event.description, event.agentType]);
+        if (event.kind === "subagent" && event.callId !== null) {
+            this.agentCalls.set(event.callId, event.taskId);
+            // A resumed subagent runs again from its latest start, its calls counted anew.
+            this.steps.set(event.taskId, { since: this.deps.clock.time(), words: null, calls: 0 });
+        }
         if (this.mayHaveOrderedRestart)
             this.afterRestart.add(event.taskId);
         const starts = (this.starts.get(event.taskId) ?? 0) + 1;
@@ -1986,6 +2183,41 @@ export class ThreadSession {
                 known.delete(taskId);
             }
         }
+        for (const taskId of [...this.steps.keys(), ...this.agentCalls.values()]) {
+            if (!this.tasks.has(taskId))
+                this.forgetSteps(taskId);
+        }
+    }
+    /** Drops what is kept of a subagent's calls. */
+    forgetSteps(taskId) {
+        this.steps.delete(taskId);
+        for (const [callId, owner] of this.agentCalls) {
+            if (owner === taskId)
+                this.agentCalls.delete(callId);
+        }
+    }
+    /**
+     * Keeps the step of each subagent up to date from the calls it starts, which arrive while it
+     * runs and after its turn has ended: a call whose parent is the call that started the
+     * subagent. A call nested deeper has the nested agent's call as parent and is none of this
+     * subagent's. The list is redrawn when the subagent shows on it; the activity line is not.
+     */
+    followStep(event) {
+        if (event.type !== "call_started" || event.parentCallId === null)
+            return;
+        const taskId = this.agentCalls.get(event.parentCallId);
+        const before = taskId === undefined ? undefined : this.steps.get(taskId);
+        if (taskId === undefined || before === undefined)
+            return;
+        const words = described(event.toolName, event.input) ?? taskTitle(event.toolName, event.input);
+        this.steps.set(taskId, {
+            ...before,
+            words: oneLine(words, TITLE_LIMIT),
+            calls: before.calls + 1,
+        });
+        if (this.taskReplies.get(taskId)?.backgroundTasks.includes(taskId)) {
+            this.thread.showRunning(this.runningList());
+        }
     }
     /**
      * Tasks that just outlived the nested call that started them are ordinary background tasks
@@ -2162,6 +2394,13 @@ export class ThreadSession {
         if (!this.injectedExpected || this.active !== null)
             return;
         logger.warning(`no turn followed a task notification in ${this.where}`);
+        await this.reportNotComing(signal);
+    }
+    /**
+     * The report turn a task notification made the session expect will not come: say the end
+     * lines it would have carried where they belong, and end the replies that waited on it.
+     */
+    async reportNotComing(signal) {
         this.injectedExpected = false;
         const held = this.held;
         this.held = [];
@@ -2330,8 +2569,12 @@ export class ThreadSession {
      */
     async showFooterIfEnded(signal, options = {}) {
         const reply = this.footerOwedTo;
-        if (reply === null || !this.sessionEnded())
+        if (reply === null)
             return;
+        if (!this.sessionEnded()) {
+            this.keepContext();
+            return;
+        }
         const footer = await this.readFooter(signal, options.live ?? true);
         if (footer === null || this.footerOwedTo !== reply || !this.sessionEnded())
             return;
@@ -2340,6 +2583,32 @@ export class ThreadSession {
                 this.footerOwedTo = null;
         }
     }
+    /** Drop the kept model and context share, and any read that is on its way to replace it. */
+    forgetContext() {
+        this.lastContext = null;
+        this.contextGeneration += 1;
+    }
+    /**
+     * A turn has ended and its footer waits for background work: ask for the context usage now,
+     * while the process is alive and idle, and keep it for the footer a `!stop` draws after it
+     * closed the process (a read made at the stop loses the race against the close, measured
+     * 2026-10-18, Claude Code 2.1.302). One request per turn; it delays nothing, and a model
+     * switch or a compaction that comes first voids it.
+     */
+    keepContext() {
+        const client = this.client;
+        if (client === null || this.busy || this.contextKept || !this.runningKindsOf())
+            return;
+        this.contextKept = true;
+        const generation = this.contextGeneration;
+        client.contextUsage().then((usage) => {
+            if (generation === this.contextGeneration && this.client === client) {
+                this.lastContext = usage;
+            }
+        }, (error) => {
+            logger.warning(`could not read the context usage in ${this.where}: ${errorName(error)}`);
+        });
+    }
     /**
      * The footer as the session stands now; null when it would say nothing or cannot be read.
      * `live` false leaves the agent unasked (a forced end: its process is lost, closing or busy
@@ -2443,6 +2712,10 @@ export class ThreadSession {
         // await itself.
         this.idleExpiry = null;
         await this.close(texts.ENDED_IDLE);
+        // The agent may write its title a moment after the turn's end, when the turn's own read had
+        // already found none: a session that rested an hour asks once more, after its close so that
+        // nothing awaited sits between the idle check and the close. The read needs no live process.
+        void this.title.refresh();
     }
     /**
      * The prompt the turn that starts now answers, taken out of `sent`; null for a turn the
@@ -2605,6 +2878,8 @@ export class ThreadSession {
         this.taskReplies.clear();
         this.resting.clear();
         this.tasks.clear();
+        this.agentCalls.clear();
+        this.steps.clear();
         this.ended = [];
         this.opening = null;
         this.endedAhead = [];
@@ -2803,12 +3078,14 @@ export class ThreadSession {
             .sort(([a], [b]) => rank(a) - rank(b))
             .map(([taskId, renderer]) => {
             const [kind, description, agentType] = this.tasks.get(taskId) ?? ["other", "", null];
+            const agent = kind === "subagent" ? this.agentOf(taskId) : null;
             let label;
             if (description && kind === "subagent") {
                 // The terminal's row: the agent's type, then what it does.
                 if (agentType !== null) {
                     const type = oneLine(agentType, TITLE_LIMIT / 2);
-                    return `${type}  ${oneLine(description, TITLE_LIMIT - Array.from(type).length - 2)}`;
+                    const text = `${type}  ${oneLine(description, TITLE_LIMIT - Array.from(type).length - 2)}`;
+                    return { text, agent };
                 }
                 label = `${TASK_WORDS.subagent[1]}: ${description}`;
             }
@@ -2818,10 +3095,17 @@ export class ThreadSession {
             else {
                 label = renderer.taskTitle(taskId) || taskId;
             }
-            return oneLine(label, TITLE_LIMIT);
+            return { text: oneLine(label, TITLE_LIMIT), agent };
         });
         return { title: texts.fill(texts.STILL_RUNNING, { counts }), lines };
     }
+    /** A subagent as the list shows it; null before its first call. */
+    agentOf(taskId) {
+        const step = this.steps.get(taskId);
+        if (step?.words === undefined || step.words === null)
+            return null;
+        return { since: step.since, calls: step.calls, step: step.words };
+    }
     newRenderer(reply) {
         const renderer = new TurnRenderer(reply, this.names, this.directory, this.deps.chat.capabilities.nativeStreaming, 
         // Recorded before any reply sees the start (`dispatch`), so a first start counts one.
@@ -2867,6 +3151,7 @@ export class ThreadSession {
             // Kept for `!status`, even when this result reports none (`/usage`, `/clear`): the two
             // lines never disagree.
             this.sessionTokens = sessionTokens(result.tokens);
+            this.contextKept = false;
             stopped = result.ending === "interrupted";
             // A turn that did not end well is no ground to wait for a report under its reply.
             if (result.ending !== "done")
@@ -3116,9 +3401,13 @@ export class ThreadSession {
      */
     async footerData(tokens, live = true) {
         let context = { model: null, percentage: null };
-        if (live && this.client !== null) {
+        if (live && this.client === null) {
+            context = this.closingContext ?? this.lastContext ?? context;
+        }
+        else if (live && this.client !== null) {
             try {
                 context = await this.client.contextUsage();
+                this.lastContext = context;
             }
             catch (error) {
                 // model and context are left out of the footer