@bubblebrain-ai/bubble 0.0.49 → 0.0.51

package/dist/agent.js

@@ -2,10 +2,10 @@
  * Agent - The core decision loop.
  * It maintains message state, calls the LLM, executes tools, and auto-continues.
  */
-import { compactCurrentTurnToolGroups, compactMessages, isRealUserMessage } from "./context/compact.js";
+import { compactCurrentTurnToolGroups, compactMessages } from "./context/compact.js";
 import { randomUUID } from "node:crypto";
 import { compactMessagesWithLLM } from "./context/compact-llm.js";
-import { estimateContextTokens, getContextBudget } from "./context/budget.js";
+import { getContextBudget } from "./context/budget.js";
 import { buildContextUsageSnapshot } from "./context/usage.js";
 import { isContextOverflowError } from "./context/overflow.js";
 import { computeRetryDelayMs, isProviderStreamInterruption, MAX_STREAM_INTERRUPTION_RETRIES, sleepBeforeRetry, } from "./network/retry.js";
@@ -21,7 +21,12 @@ import { DEFAULT_AGENT_ROUTING, sanitizeAgentRouting } from "./agent/routing-cat
 import { SubagentRouter } from "./agent/subagent/router.js";
 import { normalizeWaitTimeout, SubagentRuntime } from "./agent/subagent/runtime.js";
 import { WorkflowLedger } from "./agent/workflow/runs.js";
-import { AgentAbortError, EMPTY_ASSISTANT_FALLBACK } from "./agent/abort-errors.js";
+import { EMPTY_ASSISTANT_FALLBACK, throwIfAborted, isAbortLikeError, isAbortError } from "./agent/abort-errors.js";
+import { appendProviderContentBlock, buildProviderRequestFingerprint } from "./agent/provider-fingerprint.js";
+import { countUserTurns, estimateResidentChars, estimateToolPayloadChars, getCurrentHeapUsed, RESIDENT_HISTORY_HEAP_HARD_LIMIT, RESIDENT_HISTORY_KEEP_RECENT_TURNS } from "./agent/resident-history.js";
+import { cancelledToolResult, createModelInterruptedMessage, findMissingRequiredArgs, isSubagentLifecycleTool, lastProviderMessage, shouldAppendModelInterruptedBoundary } from "./agent/transcript-helpers.js";
+import { createUpdateQueue } from "./agent/update-queue.js";
+export { createUpdateQueue } from "./agent/update-queue.js";
 import { isHiddenToolResult } from "./agent/tool-visibility.js";
 import { createStreamingInternalReminderSanitizer, sanitizeAssistantProviderMetadata, sanitizeInternalReasoningText, sanitizeInternalReminderBlocks, } from "./agent/internal-reminder-sanitizer.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
@@ -29,8 +34,6 @@ import { buildToolPromptOptions } from "./tools/prompt-metadata.js";
 import { stopAutoServersForSession } from "./tools/server-manager.js";
 import { summarizeAgentEventForTrace, summarizeTraceError, summarizeTraceMessage, summarizeTraceToolResult, summarizeTraceValue, traceEvent, } from "./debug-trace.js";
 const MAX_CONSECUTIVE_OVERFLOW_RECOVERIES = 3;
-const RESIDENT_HISTORY_KEEP_RECENT_TURNS = 3;
-const RESIDENT_HISTORY_HEAP_HARD_LIMIT = 768 * 1024 * 1024;
 const MAX_EMPTY_ASSISTANT_RECOVERIES = 1;
 const EMPTY_ASSISTANT_RECOVERY_REMINDER = "The previous model response contained no user-visible assistant content and no tool calls. " +
     "Respond now with a concise, user-visible answer, or call an available tool if more work is required. " +
@@ -74,7 +77,23 @@ function agentEventFromHookProgress(event) {
     };
 }
 export class Agent {
-    messages = [];
+    /**
+     * Backing store for the public `messages` accessor. All whole-array
+     * rewrites (clear/compact/rewind/session switch/subagent fork) go through
+     * the setter, which notifies `onContextChanged` subscribers — that push
+     * channel is what keeps derived UI (e.g. the footer usage readout) in sync
+     * without per-path refresh calls that are easy to forget.
+     */
+    _messages = [];
+    contextChangedListeners = new Set();
+    notifyingContextChange = false;
+    get messages() {
+        return this._messages;
+    }
+    set messages(value) {
+        this._messages = value;
+        this.notifyContextChanged();
+    }
     provider;
     sessionID;
     /**
@@ -101,9 +120,6 @@ export class Agent {
     _modeVersion = 0;
     onModeUpdate;
     onCompactionApplied;
-    _todos;
-    _todosVersion = 0;
-    onTodosUpdate;
     onMessageAppend;
     onToolResult;
     hookDefinitions;
@@ -151,10 +167,8 @@ export class Agent {
         this.temperature = options.temperature ?? 0.2;
         this.thinkingLevel = options.thinkingLevel ?? "off";
         this._mode = options.mode ?? "default";
-        this._todos = options.todos ? [...options.todos] : [];
         this.onMessageAppend = options.onMessageAppend;
         this.onToolResult = options.onToolResult;
-        this.onTodosUpdate = options.onTodosUpdate;
         this.onModeUpdate = options.onModeUpdate;
         this.onCompactionApplied = options.onCompactionApplied;
         this.hookDefinitions = options.hooks ?? [];
@@ -216,7 +230,7 @@ export class Agent {
             persistDir,
         });
         if (options.systemPrompt) {
-            this.messages.push({ role: "system", content: options.systemPrompt });
+            this._messages.push({ role: "system", content: options.systemPrompt });
         }
         for (const tool of options.tools) {
             this.tools.set(tool.name, tool);
@@ -362,6 +376,46 @@ export class Agent {
     renderModelRoutingPromptFor(parent) {
         return this.router.promptSectionFor(parent);
     }
+    /**
+     * Push subscription for derived-context consumers (TUI footer, hosts).
+     * Fires whenever resident context mutates in a way that changes a
+     * `getContextUsageSnapshot()` reading: whole-array message rewrites,
+     * appended messages, system-prompt replacement, or model/provider switches
+     * (window size / estimation basis). Returns an unsubscribe function.
+     */
+    onContextChanged(listener) {
+        this.contextChangedListeners.add(listener);
+        return () => {
+            this.contextChangedListeners.delete(listener);
+        };
+    }
+    notifyContextChanged() {
+        if (this.notifyingContextChange)
+            return;
+        this.notifyingContextChange = true;
+        try {
+            for (const listener of [...this.contextChangedListeners]) {
+                try {
+                    listener();
+                }
+                catch (error) {
+                    // A broken subscriber must never corrupt agent state mid-mutation,
+                    // but leave a trace — otherwise a throwing consumer (e.g. the footer
+                    // readout hitting a pathological message) fails silently forever.
+                    traceEvent("context_listener_error", {
+                        error: error instanceof Error ? error.message : String(error),
+                    }, {
+                        sessionFile: this.sessionID,
+                        provider: this._providerId || "none",
+                        model: this.apiModel || "none",
+                    });
+                }
+            }
+        }
+        finally {
+            this.notifyingContextChange = false;
+        }
+    }
     getContextUsageSnapshot() {
         return buildContextUsageSnapshot({
             providerId: this.providerId,
@@ -434,13 +488,21 @@ export class Agent {
         return this._model;
     }
     set model(value) {
+        if (this._model === value)
+            return;
         this._model = value;
+        // Context window (and thus usage readings) is model-derived.
+        this.notifyContextChanged();
     }
     get providerId() {
         return this._providerId;
     }
     set providerId(value) {
+        if (this._providerId === value)
+            return;
         this._providerId = value;
+        // Token estimation basis is provider-specific.
+        this.notifyContextChanged();
     }
     get apiModel() {
         if (this._model.includes(":")) {
@@ -489,25 +551,17 @@ export class Agent {
     get modeVersion() {
         return this._modeVersion;
     }
-    getTodos() {
-        return this._todos.map((todo) => ({ ...todo }));
-    }
-    setTodos(next) {
-        this._todos = next.map((todo) => ({ ...todo }));
-        this._todosVersion += 1;
-        this.onTodosUpdate?.(this.getTodos());
-    }
-    /** Internal: snapshot counter that bumps on every setTodos. Used by run loop to detect mutations. */
-    get todosVersion() {
-        return this._todosVersion;
-    }
     setSystemPrompt(prompt) {
         const systemMessage = { role: "system", content: prompt };
         if (this.messages[0]?.role === "system") {
+            if (this.messages[0].content === prompt)
+                return;
             this.messages[0] = systemMessage;
+            this.notifyContextChanged();
             return;
         }
         this.messages.unshift(systemMessage);
+        this.notifyContextChanged();
     }
     async *run(userInput, cwd, options = {}) {
         const abortSignal = options.abortSignal;
@@ -615,10 +669,6 @@ export class Agent {
                 this.injectSystemReminder(reminder);
             }
         };
-        if (this._todos.length > 0 && this._todos.every((t) => t.status === "completed")) {
-            this.setTodos([]);
-            yield emit({ type: "todos_updated", todos: [] });
-        }
         if (!options.resumeWithoutInput) {
             const promptHook = await this.runExternalHook({
                 eventName: "UserPromptSubmit",
@@ -1185,7 +1235,6 @@ export class Agent {
                             argsCorrupt: tc.argsCorrupt,
                         }, traceContext);
                         yield emit({ type: "tool_start", id: tc.id, name: tc.name, args: tc.parsedArgs });
-                        const todosVersionBefore = this._todosVersion;
                         const modeVersionBefore = this._modeVersion;
                         const updateQueue = createUpdateQueue();
                         let result;
@@ -1311,9 +1360,6 @@ export class Agent {
                         yield emit({ type: "tool_end", id: tc.id, name: tc.name, result });
                         for (const update of this.subagents.drainToolUpdates())
                             yield emit(update);
-                        if (this._todosVersion !== todosVersionBefore) {
-                            yield emit({ type: "todos_updated", todos: this.getTodos() });
-                        }
                         if (this._modeVersion !== modeVersionBefore) {
                             yield emit({ type: "mode_changed", mode: this._mode });
                         }
@@ -1385,15 +1431,10 @@ export class Agent {
         catch (error) {
             if (isAbortError(error, abortSignal)) {
                 const appendedBoundary = this.appendInterruptedAssistantBoundary(currentAssistantMsg, currentAssistantAppended);
-                const clearedTodos = this.clearTodosAfterInterruptedRun();
                 traceEvent("agent_run_interrupted", {
                     appendedBoundary,
-                    clearedTodos,
                     messageCount: this.messages.length,
                 }, traceContext);
-                if (clearedTodos) {
-                    yield emit({ type: "todos_updated", todos: this.getTodos() });
-                }
             }
             else {
                 const stopFailureHook = await this.runExternalHook({
@@ -1836,6 +1877,7 @@ export class Agent {
             model: this.apiModel || "none",
         });
         this.onMessageAppend?.(message);
+        this.notifyContextChanged();
     }
     appendInterruptedAssistantBoundary(currentAssistant, currentAssistantAppended) {
         const last = lastProviderMessage(this.messages);
@@ -1858,12 +1900,6 @@ export class Agent {
         });
         return true;
     }
-    clearTodosAfterInterruptedRun() {
-        if (this._todos.length === 0)
-            return false;
-        this.setTodos([]);
-        return true;
-    }
     async executeTool(toolCall, cwd, abortSignal, emitUpdate) {
         throwIfAborted(abortSignal);
         if (toolCall.name === "exit_plan_mode" && this._mode !== "plan") {
@@ -1882,7 +1918,7 @@ export class Agent {
         if (this._mode === "plan" && !tool.readOnly) {
             return {
                 content: `Error: Tool "${toolCall.name}" is not allowed in plan mode. ` +
-                    `In plan mode you may only use read-only tools (read, glob, grep, web_search, web_fetch, spawn_agent, wait_agent, send_input, skill_search, skill, todo_write, tool_search, question, exit_plan_mode). ` +
+                    `In plan mode you may only use read-only tools (read, glob, grep, web_search, web_fetch, spawn_agent, wait_agent, send_input, skill_search, skill, tool_search, question, exit_plan_mode). ` +
                     `To modify files or run commands, present your proposal and call exit_plan_mode so the user can review and approve it.`,
                 isError: true,
             };
@@ -1946,293 +1982,3 @@ export class Agent {
         }
     }
 }
-function findMissingRequiredArgs(schema, args) {
-    const required = schema?.required;
-    if (!required || required.length === 0)
-        return [];
-    const missing = [];
-    for (const name of required) {
-        const value = args ? args[name] : undefined;
-        // Empty strings/arrays are intentionally allowed — writing an empty file
-        // or passing an empty list can be legitimate. Only undefined/null counts
-        // as "missing", because the observed failure mode is `finalArgs: "{}"`
-        // where the field is entirely absent.
-        if (value === undefined || value === null) {
-            missing.push(name);
-        }
-    }
-    return missing;
-}
-function estimateResidentChars(messages) {
-    let total = 0;
-    for (const message of messages) {
-        switch (message.role) {
-            case "system":
-            case "meta":
-                total += message.content.length;
-                break;
-            case "tool":
-                total += message.content.length + message.toolCallId.length;
-                break;
-            case "assistant":
-                total += message.content.length + (message.reasoning?.length ?? 0);
-                total += message.toolCalls?.reduce((sum, toolCall) => sum + toolCall.id.length + toolCall.name.length + toolCall.arguments.length, 0) ?? 0;
-                break;
-            case "user":
-                if (typeof message.content === "string") {
-                    total += message.content.length;
-                }
-                else {
-                    total += message.content.reduce((sum, part) => {
-                        if (part.type === "text") {
-                            return sum + part.text.length;
-                        }
-                        return sum + part.image_url.url.length;
-                    }, 0);
-                }
-                break;
-        }
-    }
-    return total;
-}
-function appendProviderContentBlock(message, provider, block) {
-    const current = message.providerMetadata?.[provider]?.contentBlocks ?? [];
-    message.providerMetadata = {
-        ...message.providerMetadata,
-        [provider]: {
-            ...message.providerMetadata?.[provider],
-            contentBlocks: [...current, cloneProviderRawContentBlock(block)],
-        },
-    };
-}
-function buildProviderRequestFingerprint(messages, tools, providerId, toolChoice) {
-    const roleCounts = {};
-    let contentChars = 0;
-    let reasoningChars = 0;
-    let toolResultChars = 0;
-    let maxToolResultChars = 0;
-    let assistantToolCalls = 0;
-    let rawAnthropicBlocks = 0;
-    let rawAnthropicThinkingBlocks = 0;
-    let rawAnthropicSignatureChars = 0;
-    for (const message of messages) {
-        roleCounts[message.role] = (roleCounts[message.role] ?? 0) + 1;
-        if (message.role === "assistant") {
-            contentChars += message.content.length;
-            reasoningChars += message.reasoning?.length ?? 0;
-            assistantToolCalls += message.toolCalls?.length ?? 0;
-            const blocks = message.providerMetadata?.anthropic?.contentBlocks ?? [];
-            rawAnthropicBlocks += blocks.length;
-            for (const block of blocks) {
-                if (block.type === "thinking" || block.type === "redacted_thinking") {
-                    rawAnthropicThinkingBlocks += 1;
-                }
-                if (typeof block.signature === "string") {
-                    rawAnthropicSignatureChars += block.signature.length;
-                }
-            }
-        }
-        else if (message.role === "tool") {
-            toolResultChars += message.content.length;
-            maxToolResultChars = Math.max(maxToolResultChars, message.content.length);
-        }
-        else if (message.role === "user") {
-            contentChars += typeof message.content === "string"
-                ? message.content.length
-                : message.content.reduce((sum, part) => sum + (part.type === "text" ? part.text.length : part.image_url.url.length), 0);
-        }
-        else {
-            contentChars += message.content.length;
-        }
-    }
-    const systemMessages = messages.filter((message) => message.role === "system");
-    const bodyMessages = messages.filter((message) => message.role !== "system");
-    const systemJsonBytes = Buffer.byteLength(JSON.stringify(systemMessages), "utf8");
-    const bodyJsonBytes = Buffer.byteLength(JSON.stringify(bodyMessages), "utf8");
-    const toolSchemaJsonBytes = Buffer.byteLength(JSON.stringify(tools), "utf8");
-    return {
-        roleCounts,
-        estimatedTokens: estimateContextTokens(messages, providerId),
-        projectedJsonBytes: Buffer.byteLength(JSON.stringify(messages), "utf8"),
-        systemJsonBytes,
-        bodyJsonBytes,
-        toolSchemaJsonBytes,
-        staticPrefixJsonBytes: Buffer.byteLength(JSON.stringify({
-            system: systemMessages,
-            tools,
-            tool_choice: toolChoice,
-        }), "utf8"),
-        toolChoice,
-        contentChars,
-        reasoningChars,
-        toolResultChars,
-        maxToolResultChars,
-        assistantToolCalls,
-        rawAnthropicBlocks,
-        rawAnthropicThinkingBlocks,
-        rawAnthropicSignatureChars,
-    };
-}
-function cloneProviderRawContentBlock(block) {
-    return JSON.parse(JSON.stringify(block));
-}
-function throwIfAborted(signal) {
-    if (!signal?.aborted)
-        return;
-    const reason = signal.reason;
-    if (reason instanceof Error)
-        throw reason;
-    throw new AgentAbortError(typeof reason === "string" ? reason : undefined);
-}
-function isAbortLikeError(error, signal) {
-    if (signal?.aborted)
-        return true;
-    if (error instanceof AgentAbortError)
-        return true;
-    if (error instanceof DOMException && error.name === "AbortError")
-        return true;
-    if (typeof error === "object" && error !== null && error.name === "AbortError")
-        return true;
-    return false;
-}
-function isAbortError(error, signal) {
-    return isAbortLikeError(error, signal);
-}
-function shouldAppendModelInterruptedBoundary(messages) {
-    return messages.at(-1)?.role === "tool";
-}
-function createModelInterruptedMessage(error, metadata) {
-    return {
-        role: "assistant",
-        content: `[model request interrupted before a final answer was produced: ${summarizeInterruptError(error)}]`,
-        model: metadata.model,
-        providerId: metadata.providerId,
-        modelId: metadata.modelId,
-    };
-}
-function summarizeInterruptError(error) {
-    const message = error instanceof Error
-        ? error.message
-        : typeof error === "string"
-            ? error
-            : String(error);
-    return message.replace(/\s+/g, " ").trim().slice(0, 240) || "unknown error";
-}
-function lastProviderMessage(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        if (message.role === "system" || message.role === "meta")
-            continue;
-        return message;
-    }
-    return undefined;
-}
-function cancelledToolResult(toolName) {
-    return {
-        content: `Tool "${toolName}" was cancelled.`,
-        isError: true,
-        status: "cancelled",
-        metadata: { reason: "cancelled" },
-    };
-}
-/** Exported for tests: the wake latch below is easiest to pin directly. */
-export function createUpdateQueue() {
-    const items = [];
-    let waiter;
-    let abortCleanup;
-    // Latch for wakes that arrive with no parked waiter — a wake() fired while
-    // the consuming generator is suspended at a yield would otherwise be lost.
-    // Callers today each pair their wake with a synchronously-checked flag
-    // (items / settled / pendingSubagentUpdates), so no wake is currently
-    // dropped; the latch keeps that correctness inside the queue instead of
-    // depending on every future caller repeating the pairing.
-    let signaled = false;
-    return {
-        push(item) {
-            items.push(item);
-            this.wake();
-        },
-        drain() {
-            return items.splice(0, items.length);
-        },
-        hasItems() {
-            return items.length > 0;
-        },
-        wait(signal) {
-            if (items.length > 0)
-                return Promise.resolve("woken");
-            if (signaled) {
-                signaled = false;
-                return Promise.resolve("woken");
-            }
-            if (signal?.aborted)
-                return Promise.resolve("aborted");
-            return new Promise((resolve) => {
-                abortCleanup?.();
-                abortCleanup = undefined;
-                const finish = (status) => {
-                    if (waiter !== resolve)
-                        return;
-                    waiter = undefined;
-                    abortCleanup?.();
-                    abortCleanup = undefined;
-                    resolve(status);
-                };
-                if (signal) {
-                    const onAbort = () => finish("aborted");
-                    signal.addEventListener("abort", onAbort, { once: true });
-                    abortCleanup = () => signal.removeEventListener("abort", onAbort);
-                }
-                waiter = resolve;
-            });
-        },
-        wake() {
-            const resolve = waiter;
-            if (!resolve) {
-                signaled = true;
-                return;
-            }
-            waiter = undefined;
-            abortCleanup?.();
-            abortCleanup = undefined;
-            resolve("woken");
-        },
-    };
-}
-function estimateToolPayloadChars(messages) {
-    return messages.reduce((sum, message) => {
-        if (message.role !== "tool") {
-            return sum;
-        }
-        return sum + message.content.length;
-    }, 0);
-}
-function countUserTurns(messages) {
-    // Real user turns only: projected reminders and summary envelopes are
-    // user-ROLE but not user TURNS — counting them used to shrink the keep
-    // window and fire compaction almost every turn.
-    return messages.reduce((count, message) => count + (isRealUserMessage(message) ? 1 : 0), 0);
-}
-function getCurrentHeapUsed() {
-    try {
-        return process.memoryUsage().heapUsed;
-    }
-    catch {
-        return 0;
-    }
-}
-function isSubagentLifecycleTool(name) {
-    return name === "subagent"
-        || name === "spawn_agent"
-        || name === "wait_agent"
-        || name === "send_input"
-        || name === "close_agent"
-        || name === "list_agents"
-        || name === "run_workflow"
-        || name === "wait_workflow"
-        // Legacy names: still present in transcripts recorded before the tools
-        // were removed (2026-07-06); forked children must not inherit their
-        // dangling tool_calls either.
-        || name === "agent_team"
-        || name === "agent_batch";
-}

package/dist/debug-trace.js

@@ -235,8 +235,6 @@ export function summarizeAgentEventForTrace(event) {
                 ...event,
                 content: summarizeTraceText(event.content),
             };
-        case "todos_updated":
-            return { type: event.type, count: event.todos.length };
         default:
             return { ...event };
     }

package/dist/external-runtime/grok-runtime.js

@@ -530,7 +530,7 @@ export class GrokRuntimeManager {
         try {
             if (!this.lock)
                 temporaryLock = await this.acquireProfileLock();
-            const { profile, env, binary } = await this.prepareAndVerify();
+            const { env, binary } = await this.prepareAndVerify();
             const result = await runGrokCommand(this.spawn, binary.path, ["--no-auto-update", "--cwd", this.workspace, "models"], { cwd: this.workspace, env, maxStdoutBytes: 64 * 1024 });
             if (result.code !== 0) {
                 throw new GrokRuntimeError("protocol_error", "Grok could not list subscription models.", result.stderr);

package/dist/feishu/agent-host/run-driver.js

@@ -70,12 +70,7 @@ export class RunDriver {
             ({ action: "reject", reason: "Plan approval over Feishu not implemented; use /mode default." }),
             setMode: (mode) => agentForPlan?.setMode(mode),
         };
-        const todoStore = {
-            getTodos: () => agentRef?.getTodos() ?? [],
-            setTodos: (todos) => agentRef?.setTodos(todos),
-        };
         const tools = createAllTools(session.cwd, this.opts.deps.skillRegistry, {
-            todoStore,
             planController,
             approvalController,
             lspService,
@@ -125,7 +120,6 @@ export class RunDriver {
             temperature: 0.2,
             thinkingLevel,
             mode: initialMode,
-            todos: session.manager.getTodos(),
             onMessageAppend: (message) => {
                 if (message.role === "system" || message.role === "meta")
                     return;
@@ -145,7 +139,6 @@ export class RunDriver {
                 if (match?.[1])
                     session.manager.appendMarker("skill_activated", match[1].trim());
             },
-            onTodosUpdate: (todos) => session.manager.appendTodosSnapshot(todos),
             onModeUpdate: (mode) => {
                 session.manager.appendMarker("mode_switch", mode);
                 this.opts.binder.setMode(req.scopeKey, mode);
@@ -301,7 +294,7 @@ export class RunDriver {
             this.opts.approvalUI.cancelForChat(req.chatId, "Run ended");
         }
     }
-    async resolveProvider(session, promptCacheKey) {
+    async resolveProvider(_session, promptCacheKey) {
         const registry = this.opts.deps.providerRegistry;
         const userConfig = this.opts.deps.userConfig;
         // Read session metadata for an explicit model preference, fall back to

package/dist/feishu/card/run-state.js

@@ -97,9 +97,6 @@ export function reduceRunState(state, event) {
         case "mode_changed":
             state.mode = event.mode;
             return state;
-        case "todos_updated":
-            // Todos render is deferred (would need a todos block kind). v1 ignores.
-            return state;
         case "context_recovered":
             // Internal recovery — silent.
             return state;

package/dist/lsp/service.js

@@ -436,7 +436,7 @@ const TypeScriptServer = {
     extensions: TS_EXTENSIONS,
     root: nearestRoot(NODE_ROOT_MARKERS, DENO_ROOT_MARKERS),
     languageId: languageIdFor,
-    async spawn(root, ctx) {
+    async spawn(root, _ctx) {
         const requireFromRoot = createRequire(join(root, "package.json"));
         const requireFromSelf = createRequire(import.meta.url);
         const tsserverPath = resolveModule(requireFromRoot, "typescript/lib/tsserver.js")
@@ -495,7 +495,7 @@ const ESLintServer = {
     extensions: [...TS_EXTENSIONS, ".vue"],
     root: eslintRoot,
     languageId: languageIdFor,
-    async spawn(root, ctx) {
+    async spawn(root, _ctx) {
         const requireFromRoot = createRequire(join(root, "package.json"));
         const requireFromSelf = createRequire(import.meta.url);
         const eslint = resolveModule(requireFromRoot, "eslint");