@0xmaxma/claude-gateway 1.7.9 → 1.8.0

package/dist/agent/runner.js

@@ -51,6 +51,7 @@ const slack_client_1 = require("../api/slack-client");
 const markdown_1 = require("../telegram/markdown");
 const skills_1 = require("../skills");
 const builtin_commands_1 = require("./builtin-commands");
+const model_catalog_1 = require("./model-catalog");
 const safe_mode_1 = require("./safe-mode");
 const recovery_executor_1 = require("./recovery-executor");
 const recovery_policy_1 = require("./recovery-policy");
@@ -434,7 +435,7 @@ class AgentRunner extends events_1.EventEmitter {
                     // Check if this is a built-in channel command
                     const trimmedContent = content.trim();
                     if ((0, builtin_commands_1.isBuiltinCommand)(trimmedContent, channelSource)) {
-                        this.handleSessionCommand(chatId, trimmedContent)
+                        this.handleSessionCommand(chatId, trimmedContent, meta)
                             .then(() => this.writeTypingDone(chatId))
                             .catch((err) => {
                             this.logger.error('Session command failed', { error: err.message });
@@ -685,8 +686,17 @@ class AgentRunner extends events_1.EventEmitter {
             return;
         }
         if (command === 'get_models') {
-            const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-            respond({ models: availableModels.map(m => ({ id: m.id, label: m.label })) });
+            // Live catalog first, static list as the fallback (issue #409). The
+            // picker is a UI action, so a slow or unreachable catalog must not hang
+            // it — fetchModelCatalog is bounded and never rejects.
+            void this.availableModels()
+                .then((availableModels) => {
+                respond({ models: availableModels.map(m => ({ id: m.id, label: m.label })) });
+            })
+                // Without this the request would hang and the picker with it: the
+                // receiver is blocked on this response. Every other async branch in
+                // this handler answers on rejection too.
+                .catch((err) => respond({ success: false, error: String(err) }, 500));
             return;
         }
         // `/cli` webview terminal viewer — create a pairing on behalf of an
@@ -735,15 +745,7 @@ class AgentRunner extends events_1.EventEmitter {
                 respond({ success: false, error: err.message });
                 return;
             }
-            let restarted = false;
-            const restartPromises = [];
-            for (const [key, session] of this.sessions) {
-                if (session.source !== 'api') {
-                    restarted = true;
-                    restartPromises.push(this.restartProcess(key));
-                }
-            }
-            await Promise.all(restartPromises);
+            const restarted = await this.restartChannelSessions();
             respond({ success: true, model: newModel, restarted });
             return;
         }
@@ -788,9 +790,7 @@ class AgentRunner extends events_1.EventEmitter {
                     return respond({ success: true, text: 'No active session found.' });
                 }
                 const effectiveModel = this.agentConfig.claude.model;
-                const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-                const modelConfig = availableModels.find(m => m.id === effectiveModel);
-                const contextWindow = modelConfig?.contextWindow ?? 200000;
+                const contextWindow = await this.contextWindowFor(effectiveModel);
                 const contextTokens = meta.lastInputTokens ?? 0;
                 const usedPct = Math.round((contextTokens / contextWindow) * 100);
                 let msgs;
@@ -1739,16 +1739,23 @@ class AgentRunner extends events_1.EventEmitter {
                         // `session_idle` once it is truly done; headless mode only produces
                         // one `result` per message, so the timer pattern still applies there.
                         if (proc.backend !== 'pty-shell') {
-                            typingDoneTimer = setTimeout(() => {
-                                this.writeTypingDone(mapKey);
-                                typingDoneTimer = null;
-                            }, TYPING_DONE_DELAY_MS);
+                            const waitingForBackgroundWork = proc.retainBackgroundWorkingState();
+                            if (!waitingForBackgroundWork) {
+                                typingDoneTimer = setTimeout(() => {
+                                    this.writeTypingDone(mapKey);
+                                    typingDoneTimer = null;
+                                }, TYPING_DONE_DELAY_MS);
+                            }
                         }
                     }
                     // PTY shell signals "truly idle" (no active turn, empty queue) with this
                     // event. Start the typing-done timer here so the indicator stays alive
                     // through multi-turn tool-call sequences and only stops when all work is done.
                     if (obj['type'] === 'session_idle' && proc.backend === 'pty-shell') {
+                        // A parent can become idle immediately after dispatching background
+                        // Agent/Workflow work. Keep the Telegram typing signal and processing
+                        // sentinel alive until the task notification starts its follow-up turn.
+                        const waitingForBackgroundWork = proc.retainBackgroundWorkingState();
                         // Gateway turn queue: on pty-shell this is the true end of the user's
                         // turn (the wrapper only emits it when its own `this.turn` is null, so
                         // it never fires between sub-turns) — flush the next queued turn.
@@ -1760,10 +1767,12 @@ class AgentRunner extends events_1.EventEmitter {
                         }
                         // Skill-learning: pty-shell session_idle is the true end-of-user-turn.
                         this.skillLearning?.onTurnEnd(mapKey, actualSessionId);
-                        typingDoneTimer = setTimeout(() => {
-                            this.writeTypingDone(mapKey);
-                            typingDoneTimer = null;
-                        }, TYPING_DONE_DELAY_MS);
+                        if (!waitingForBackgroundWork) {
+                            typingDoneTimer = setTimeout(() => {
+                                this.writeTypingDone(mapKey);
+                                typingDoneTimer = null;
+                            }, TYPING_DONE_DELAY_MS);
+                        }
                     }
                 }
                 catch { /* non-JSON */ }
@@ -1798,6 +1807,11 @@ class AgentRunner extends events_1.EventEmitter {
                     messageCountAtSpawn: proc.spawnContext.messageCountAtSpawn,
                 }, this.channelFor(mapKey)).catch(() => { });
             }
+            proc.on('backgroundWorkExpired', () => {
+                // The child task never notified its parent within the bounded grace
+                // window; release the Telegram typing signal instead of leaving it live.
+                this.writeTypingDone(mapKey);
+            });
             // Tear down per-chat typing/processing state whenever the subprocess dies.
             // Uses `on` (not `once`): a single SessionProcess can auto-restart its child
             // multiple times over its lifetime, and each death that lacks a final
@@ -1865,7 +1879,7 @@ class AgentRunner extends events_1.EventEmitter {
     /**
      * Dispatch a session management command to the appropriate handler.
      */
-    async handleSessionCommand(chatId, content) {
+    async handleSessionCommand(chatId, content, meta = {}) {
         const agentId = this.agentConfig.id;
         if (content.startsWith('/sessions')) {
             await this.handleCommandSessions(agentId, chatId);
@@ -1887,10 +1901,78 @@ class AgentRunner extends events_1.EventEmitter {
             const name = content.replace('/rename', '').trim();
             await this.handleCommandRename(agentId, chatId, name);
         }
+        else if (content.startsWith('/models')) {
+            await this.handleCommandModels(chatId);
+        }
+        else if (content.startsWith('/model')) {
+            await this.handleCommandModel(chatId, content.replace('/model', '').trim(), meta);
+        }
         else if (content.startsWith('/stop')) {
             await this.handleCommandStop(chatId);
         }
     }
+    /**
+     * /models — the model picker for channels without an inline keyboard.
+     *
+     * Telegram never reaches this: its receiver answers `/models` itself with a
+     * button keyboard and does not forward the message. Discord and LINE have no
+     * picker of their own, so they get the list as text plus the command that
+     * selects from it (issue #409).
+     *
+     * A channel listed in BUILTIN_COMMANDS but missing a branch here is worse
+     * than one not listed at all — the gate swallows the message and the user
+     * gets silence instead of the agent's reply. `/model` on Discord was in
+     * exactly that state before this.
+     */
+    async handleCommandModels(chatId) {
+        const models = await this.availableModels();
+        const current = this.agentConfig.claude.model;
+        const lines = [`Current model: ${current}`, ''];
+        for (const m of models) {
+            const marker = m.id === current ? '✅ ' : '• ';
+            lines.push(`${marker}${m.label} — \`${m.id}\``);
+        }
+        lines.push('', 'Switch with /model <id or alias>');
+        this.writeAutoForward(chatId, lines.join('\n'));
+    }
+    /**
+     * /model — show the current model, or switch to one from the catalog.
+     *
+     * An unrecognised argument is refused rather than persisted: unlike the API
+     * (where the caller is authenticated and the provider validates the id), a
+     * typo in a chat message would otherwise be written into config.json and
+     * break the agent's next spawn. Anything the catalog knows — including a
+     * model that exists only upstream and not in the static list — is accepted.
+     */
+    async handleCommandModel(chatId, arg, meta = {}) {
+        const current = this.agentConfig.claude.model;
+        if (!arg) {
+            this.writeAutoForward(chatId, `Current model: ${current}\n\nUse /models to see the list.`);
+            return;
+        }
+        if (!this.isDirectChat(meta)) {
+            this.writeAutoForward(chatId, 'Switching models is only available in a direct message with the bot — '
+                + 'it changes the model for every chat of this agent and restarts them. '
+                + 'Use /models here to see the list.');
+            return;
+        }
+        const models = await this.selectableModels();
+        const wanted = arg.toLowerCase();
+        const match = models.find((m) => m.id.toLowerCase() === wanted || m.alias.toLowerCase() === wanted);
+        if (!match) {
+            this.writeAutoForward(chatId, `Unknown model "${arg}". Use /models to see the list.`);
+            return;
+        }
+        if (match.id === current) {
+            this.writeAutoForward(chatId, `Already using ${match.label} (${match.id}).`);
+            return;
+        }
+        await this.setModel(match.id);
+        // Same restart the Telegram picker's set_model does — the running session
+        // was spawned with the old model and would otherwise keep using it.
+        const restarted = await this.restartChannelSessions();
+        this.writeAutoForward(chatId, `Model set to ${match.label} (${match.id}).${restarted ? ' Restarting the session…' : ''}`);
+    }
     /**
      * /sessions — list all sessions for this chat.
      */
@@ -1919,9 +2001,7 @@ class AgentRunner extends events_1.EventEmitter {
             return;
         }
         const effectiveModel = this.agentConfig.claude.model;
-        const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-        const modelConfig = availableModels.find(m => m.id === effectiveModel);
-        const contextWindow = modelConfig?.contextWindow ?? 200000;
+        const contextWindow = await this.contextWindowFor(effectiveModel);
         const contextTokens = meta.lastInputTokens ?? 0;
         const usedPct = Math.round((contextTokens / contextWindow) * 100);
         let msgs;
@@ -2039,9 +2119,7 @@ class AgentRunner extends events_1.EventEmitter {
         const meta = index.sessions.find(s => s.id === sessionId);
         const name = meta?.name ?? 'Session';
         const compactModel = this.agentConfig.claude.model;
-        const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-        const modelConfig = availableModels.find(m => m.id === compactModel);
-        const contextWindow = modelConfig?.contextWindow ?? 200000;
+        const contextWindow = await this.contextWindowFor(compactModel);
         this.writeAutoForward(chatId, `⏳ Compacting session "${name}"...`);
         try {
             const compactor = new compactor_1.SessionCompactor(this.sessionStore);
@@ -2239,12 +2317,25 @@ class AgentRunner extends events_1.EventEmitter {
                 proc.markPendingRestart();
                 deferred++;
             }
-            else if (deferIdle && proc.source !== 'api') {
-                // Lossless deferral for CHANNEL sessions only: leave the idle process
-                // running and arm a restart on its next message (mirrors the
-                // image-size-threshold path). Do NOT call proc.markPendingRestart() here
-                // — on an idle process it fires deferredRestartReady immediately and
-                // stops the session.
+            else if ((proc.hasLikelyOutstandingBackgroundWork() || deferIdle) && proc.source !== 'api') {
+                // Lossless deferral for CHANNEL sessions: leave the idle process running
+                // and arm a restart on its next message instead of an immediate stop.
+                // Two independent reasons land here, neither gated by skipBusy (which
+                // only governs the isProcessing branch above — a session that's already
+                // idle isn't the self-restart-footgun case skipBusy exists for):
+                //   - deferIdle: the caller explicitly asked never to SIGKILL an idle
+                //     bystander (mirrors the image-size-threshold path).
+                //   - hasLikelyOutstandingBackgroundWork(): regardless of which tier
+                //     called restartOrDefer — even today's aggressive default — a
+                //     session that dispatched a background Agent/Workflow tool_use and
+                //     then ended its OWN turn looks idle here, but a sub-agent it
+                //     launched may still be doing real work. SIGKILLing it now would
+                //     silently destroy that in-flight work with no notification or
+                //     recovery (the incident this guards against: a CLAUDE.md-triggered
+                //     restart killed a session mid-way through 3 dispatched code-review
+                //     sub-agents).
+                // Do NOT call proc.markPendingRestart() here — on an idle process it
+                // fires deferredRestartReady immediately and stops the session.
                 //
                 // Guard on source: `pendingRestarts` is consumed ONLY in injectTurn (the
                 // channel turn path, keyed by chatId). api / __heartbeat__ sessions are
@@ -2296,6 +2387,22 @@ class AgentRunner extends events_1.EventEmitter {
         const stateDir = channel === 'discord' ? '.discord-state' : '.telegram-state';
         return path.join(this.agentConfig.workspace, stateDir, 'typing');
     }
+    /**
+     * Read the live typing-signal file's timestamp as this turn's id. Shared
+     * with the `telegram_reply` MCP tool (a separate process) purely via this
+     * file, so `.forward`/`.replied` markers written around the same turn carry
+     * a matching id — see writeAutoForward()'s dedup comment.
+     */
+    readCurrentTurnId(chatId) {
+        const typingDir = this.getTypingDir(chatId);
+        try {
+            const raw = fs.readFileSync(path.join(typingDir, chatId), 'utf8').trim();
+            return raw || null;
+        }
+        catch {
+            return null;
+        }
+    }
     writeTypingError(chatId, code) {
         const typingDir = this.getTypingDir(chatId);
         try {
@@ -2365,9 +2472,39 @@ class AgentRunner extends events_1.EventEmitter {
             return;
         }
         const typingDir = this.getTypingDir(chatId);
+        const forwardPath = path.join(typingDir, `${chatId}.forward`);
         try {
             fs.mkdirSync(typingDir, { recursive: true });
-            fs.writeFileSync(path.join(typingDir, `${chatId}.forward`), JSON.stringify({ text, format }));
+            // Append rather than overwrite: two forward-worthy events for the same
+            // chat before the typing loop drains (e.g. two command replies, or the
+            // race where a queued turn's stop() call drains a prior turn's leftover
+            // state) must both reach the user, not have the second clobber the
+            // first. turnId is the live typing-signal timestamp — the receiver uses
+            // it to scope the `.replied` dedup marker to the turn that wrote it.
+            let entries = [];
+            try {
+                const raw = fs.readFileSync(forwardPath, 'utf8').trim();
+                if (raw) {
+                    try {
+                        const parsed = JSON.parse(raw);
+                        entries = Array.isArray(parsed)
+                            ? parsed
+                            : [parsed];
+                    }
+                    catch {
+                        entries = [{ text: raw, format: 'text', turnId: null }];
+                    }
+                }
+            }
+            catch {
+                // No existing file — fresh queue.
+            }
+            entries.push({ text, format, turnId: this.readCurrentTurnId(chatId) });
+            // Atomic write (tmp + rename): the receiver polls this directory on
+            // every typing tick, so a non-atomic write could be read mid-flush.
+            const tmpPath = `${forwardPath}.tmp`;
+            fs.writeFileSync(tmpPath, JSON.stringify(entries));
+            fs.renameSync(tmpPath, forwardPath);
         }
         catch {
             // Non-fatal
@@ -2397,6 +2534,10 @@ class AgentRunner extends events_1.EventEmitter {
     startIdleCleaner() {
         this.idleCleanerTimer = setInterval(async () => {
             for (const [id, proc] of this.sessions) {
+                // A parent that just dispatched Agent/Workflow work is CLI-idle but its
+                // sub-agent may still need this session to receive the task notification.
+                if (proc.hasLikelyOutstandingBackgroundWork())
+                    continue;
                 if (proc.isIdle(this.idleTimeoutMs)) {
                     this.logger.info('Stopping idle session', { sessionId: id });
                     await proc.stop();
@@ -2494,7 +2635,10 @@ class AgentRunner extends events_1.EventEmitter {
     stopTelegramReceiver() {
         if (!this.receiver)
             return;
-        this.receiver.stop();
+        // Hot-remove is a config-change response, not a shutdown: detach immediately
+        // and let teardown finish in the background rather than blocking the caller
+        // for the SIGKILL grace period. stop() never rejects.
+        void this.receiver.stop();
         this.receiver = null;
         this.logger.info('TelegramReceiver stopped', { agentId: this.agentConfig.id });
     }
@@ -2510,7 +2654,10 @@ class AgentRunner extends events_1.EventEmitter {
     stopDiscordReceiver() {
         if (!this.discordReceiver)
             return;
-        this.discordReceiver.stop();
+        // Hot-remove is a config-change response, not a shutdown: detach immediately
+        // and let teardown finish in the background rather than blocking the caller
+        // for the SIGKILL grace period. stop() never rejects.
+        void this.discordReceiver.stop();
         this.discordReceiver = null;
         this.logger.info('DiscordReceiver stopped', { agentId: this.agentConfig.id });
     }
@@ -2532,10 +2679,17 @@ class AgentRunner extends events_1.EventEmitter {
             clearTimeout(buf.timer);
         }
         this.channelCoalesce.clear();
-        this.receiver?.stop();
-        this.discordReceiver?.stop();
+        // Receiver teardown now resolves only once the child has exited, so it must
+        // be awaited or shutdown() can exit the gateway out from under a receiver
+        // that is still shutting down (issue #405). Run it concurrently with session
+        // teardown rather than serially — both are bounded, neither depends on the
+        // other, and shutdown latency is user-visible.
+        const receiversStopped = [this.receiver?.stop(), this.discordReceiver?.stop()];
         this.stopLineReply();
-        await Promise.all([...this.sessions.values()].map((s) => s.stop()));
+        await Promise.all([
+            ...receiversStopped,
+            ...[...this.sessions.values()].map((s) => s.stop()),
+        ]);
         this.sessions.clear();
     }
     /**
@@ -3335,9 +3489,7 @@ class AgentRunner extends events_1.EventEmitter {
                     responseText = `Session: (unnamed)\nMessages: ${messageCount}\nContext used: 0%\nModel: ${effectiveModel}`;
                 }
                 else {
-                    const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-                    const modelConfig = availableModels.find((m) => m.id === effectiveModel);
-                    const contextWindow = modelConfig?.contextWindow ?? 200000;
+                    const contextWindow = await this.contextWindowFor(effectiveModel);
                     const contextUsedPct = Math.round(((meta.lastInputTokens ?? 0) / contextWindow) * 100);
                     result = { sessionId, sessionName: meta.name, messageCount, archivedCount: meta.archivedCount ?? 0, contextUsedPct, model: effectiveModel };
                     responseText = [
@@ -3394,9 +3546,7 @@ class AgentRunner extends events_1.EventEmitter {
                 const ch = 'api';
                 const activeSession = this.sessions.get(sessionId);
                 const compactEffectiveModel = opts?.model ?? activeSession?.modelOverride ?? this.agentConfig.claude.model;
-                const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-                const modelConfig = availableModels.find((m) => m.id === compactEffectiveModel);
-                const contextWindow = modelConfig?.contextWindow ?? 200000;
+                const contextWindow = await this.contextWindowFor(compactEffectiveModel);
                 const compactor = new compactor_1.SessionCompactor(this.sessionStore);
                 const compactResult = await compactor.compact(agentId, storeChatId, sessionId, compactEffectiveModel, contextWindow, ch);
                 await this.sessionStore.updateSessionMeta(agentId, storeChatId, sessionId, {
@@ -3430,6 +3580,88 @@ class AgentRunner extends events_1.EventEmitter {
         persist('assistant', responseText, forcePersist);
         return { result, responseText };
     }
+    /**
+     * Whether an inbound channel message came from a 1:1 chat with the bot.
+     *
+     * Gates the one channel command that reaches past its own chat: `/model <x>`
+     * rewrites `config.json` for the whole agent and restarts every session in
+     * every chat. The channel access gates do not cover that. Discord's, in a
+     * guild, checks the guild, the channel, and a mention — never the user
+     * (`allowFrom` in mcp/tools/discord/access.ts is DM-only), so without this
+     * any member of an allowlisted channel could switch the model out from under
+     * everyone else and kill their in-flight turns. LINE forwards group and room
+     * messages the same way. Telegram's receiver answers `/model` itself behind
+     * a private-chat + allowlist check and does not forward it here.
+     *
+     * Fails closed: a channel that does not report a chat type cannot switch.
+     * Listing models (`/models`, bare `/model`) is unaffected — it reads nothing
+     * and changes nothing.
+     */
+    isDirectChat(meta) {
+        const kind = meta['chat_type'] ?? meta['line_chat_type'] ?? meta['slack_chat_type'];
+        return kind === 'direct' || kind === 'user';
+    }
+    /**
+     * Restart every non-api session so a model change actually takes effect.
+     *
+     * `setModel` only rewrites config — a session process was spawned with the
+     * old model on its command line and keeps using it until it is restarted.
+     * Reporting "model set" without this is a false success: the next turn still
+     * runs on the previous model. Returns whether anything was restarted.
+     */
+    async restartChannelSessions() {
+        const restartPromises = [];
+        for (const [key, session] of this.sessions) {
+            if (session.source !== 'api')
+                restartPromises.push(this.restartProcess(key));
+        }
+        await Promise.all(restartPromises);
+        return restartPromises.length > 0;
+    }
+    /**
+     * The model list this gateway offers: the live catalog when one is reachable,
+     * the configured/static list otherwise (issue #409). Cached upstream, so the
+     * six callers that only want one model's context window pay for at most one
+     * fetch a minute between them.
+     */
+    async availableModels() {
+        const staticModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
+        return (await (0, model_catalog_1.fetchModelCatalog)(staticModels)) ?? staticModels;
+    }
+    /**
+     * Context window for a model id. Resolving this through the live catalog is
+     * what keeps `/session`'s "context used" percentage and `/compact`'s window
+     * honest for a model that exists only upstream — before, any such model fell
+     * through to the 200k default no matter how large its real window.
+     */
+    async contextWindowFor(modelId) {
+        const models = await this.availableModels();
+        // Configured list second, not just as the catalog's fallback: the catalog
+        // *replaces* the list rather than merging with it, so a configured model
+        // the upstream catalog does not list (the local `[1m]` ids are exactly
+        // that shape) would otherwise drop to the 200k default — reporting
+        // /session context use against a fifth of the real window and handing
+        // SessionCompactor a window small enough to compact far too early.
+        return models.find((m) => m.id === modelId)?.contextWindow
+            ?? (this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS).find((m) => m.id === modelId)?.contextWindow
+            ?? model_catalog_1.DEFAULT_CONTEXT_WINDOW;
+    }
+    /**
+     * Models `/model <arg>` may switch to: what the catalog offers, plus the
+     * configured list.
+     *
+     * The union is only for *resolution*, never for the `/models` listing — the
+     * listing has to reflect what upstream actually offers, or a model removed
+     * upstream would linger in the picker forever, which is the bug this all
+     * started from. Without the union a user who switches to a live-only model
+     * is trapped: their previous configured model is no longer nameable.
+     */
+    async selectableModels() {
+        const live = await this.availableModels();
+        const configured = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
+        const ids = new Set(live.map((m) => m.id));
+        return [...live, ...configured.filter((m) => !ids.has(m.id))];
+    }
     async setModel(newModel) {
         // Allow any model string through — BYOK/third-party models (openrouter/* etc.)
         // are validated by the upstream provider, not the local config list.
@@ -3478,9 +3710,7 @@ class AgentRunner extends events_1.EventEmitter {
         if (!meta)
             return null;
         const effectiveModel = this.agentConfig.claude.model;
-        const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-        const modelConfig = availableModels.find((m) => m.id === effectiveModel);
-        const contextWindow = modelConfig?.contextWindow ?? 200000;
+        const contextWindow = await this.contextWindowFor(effectiveModel);
         const contextUsedPct = Math.round(((meta.lastInputTokens ?? 0) / contextWindow) * 100);
         return {
             sessionId: meta.id,