@cjhyy/code-shell-core 0.5.0-rc.1 → 0.6.0-rc.1

package/dist/protocol/chat-session.js

@@ -1,3 +1,4 @@
+import { isAbortError } from "../llm/client-base.js";
 /**
  * One ChatSession per UI chat tab. Owns a single Engine, an AbortController
  * for the active turn, and a FIFO queue so a fast second send waits for the
@@ -19,6 +20,30 @@ export class ChatSession {
     active = null;
     controller = null;
     defaultOnStream;
+    /**
+     * Model-pool key requested via requestModelSwitch while a turn was in
+     * flight. Applied at the next run boundary (before the next turn starts) so
+     * we never swap the model out from under a running LLM client — the bug the
+     * session-isolation research flagged. null = nothing pending.
+     */
+    pendingModel = null;
+    /**
+     * Set by cancel() so the in-flight turn's abort error resolves as a clean
+     * "cancelled" result instead of rejecting (which the RPC layer would surface
+     * as a scary red Error in the UI for what was a user-initiated Stop). The
+     * onboarding flow cancels + immediately re-runs the same task; without this
+     * the cancelled first run popped "Error: Request cancelled".
+     */
+    cancelledActive = false;
+    /**
+     * Sticky flag: the user cancelled (Stop) and has not started a new turn
+     * since. cancel() leaves the session idle (active=null), so isBusy() can't
+     * distinguish "naturally idle" from "user just stopped me". A background-job
+     * completion that lands in this window must NOT auto-resume the session —
+     * that would defeat the Stop. Cleared the moment a real turn is enqueued
+     * (the user is engaging again) so normal wakeups resume working afterward.
+     */
+    cancelledSinceLastTurn = false;
     constructor(opts) {
         this.id = opts.id;
         this.engine = opts.engine;
@@ -26,11 +51,24 @@ export class ChatSession {
     }
     enqueueTurn(task, opts) {
         this.lastActivityAt = Date.now();
+        // The user (or a wakeup the guard already let through) is starting a turn —
+        // clear the post-Stop suppression so future background-job completions
+        // wake the session again.
+        this.cancelledSinceLastTurn = false;
         return new Promise((resolve, reject) => {
             this.queue.push({ task, opts, resolve, reject });
             this.pump();
         });
     }
+    /**
+     * True when the user hit Stop and hasn't started a new turn since. The server
+     * consults this before auto-waking an idle session on a background-job
+     * completion, so a download finishing right after Stop doesn't restart the
+     * agent the user just halted.
+     */
+    wasCancelledSinceLastTurn() {
+        return this.cancelledSinceLastTurn;
+    }
     /**
      * Abort the in-flight turn and drain queued turns.
      *
@@ -40,6 +78,12 @@ export class ChatSession {
      * are always rejected regardless.
      */
     cancel() {
+        // Mark the in-flight turn as user-cancelled so pump()'s catch resolves it
+        // as a clean aborted result rather than rejecting (→ UI Error).
+        if (this.active)
+            this.cancelledActive = true;
+        // Suppress auto-wakeup until the user engages again (see the field doc).
+        this.cancelledSinceLastTurn = true;
         this.controller?.abort();
         // Drain queued turns as cancelled
         const drained = this.queue.splice(0);
@@ -50,6 +94,55 @@ export class ChatSession {
     isBusy() {
         return this.active !== null;
     }
+    /**
+     * Extend the in-flight goal run's turn/budget ceilings (TODO 3.1). Delegates
+     * to the engine, which forwards to the active TurnLoop. Returns null when no
+     * run is active (or the run has no extendable loop). Mirrors the cancel()
+     * mid-run control path.
+     */
+    extendGoalRun(opts) {
+        return this.engine.extendGoalRun(opts);
+    }
+    /**
+     * Read this session's persisted active goal (state.activeGoal), or undefined
+     * when none. Cheap — reads only state.json. The host calls this on session
+     * load to re-surface the goal block + Cancel button after a reload.
+     */
+    getGoal() {
+        return this.engine.getGoal(this.id);
+    }
+    /**
+     * Clear this session's persisted active goal (CC /goal clear). Works idle or
+     * mid-run. Returns true if a goal was actually cleared.
+     */
+    clearGoal() {
+        return this.engine.clearGoal(this.id);
+    }
+    /**
+     * Switch this session's active model (per-session, not worker-global).
+     * Applies immediately when idle; defers to the next run boundary when a
+     * turn is in flight so a hot switch never mutates the model under a
+     * running LLM client.
+     */
+    requestModelSwitch(key) {
+        if (this.isBusy()) {
+            this.pendingModel = key;
+            return;
+        }
+        this.applyModelSwitch(key);
+    }
+    /**
+     * Perform the actual model switch for this session: rotate the engine's model
+     * and reset the session's cumulative usage on disk — a different model has a
+     * different prompt cache, so the old cache-hit stats no longer apply. The
+     * renderer zeroes its own cumulative display when it issues the switch (it's
+     * renderer-initiated), so no stream event is needed here. Shared by the idle
+     * path and the deferred run-boundary path.
+     */
+    applyModelSwitch(key) {
+        this.engine.switchModel(key);
+        this.engine.resetSessionUsage(this.id);
+    }
     queueDepth() {
         return this.queue.length;
     }
@@ -60,6 +153,7 @@ export class ChatSession {
         if (!next)
             return;
         this.active = next;
+        this.cancelledActive = false;
         this.controller = new AbortController();
         try {
             const onStream = next.opts.onStream ?? this.defaultOnStream;
@@ -68,16 +162,42 @@ export class ChatSession {
                 sessionId: this.id,
                 signal: this.controller.signal,
                 onStream,
+                goal: next.opts.goal,
+                injected: next.opts.injected,
             });
             this.lastActivityAt = Date.now();
             next.resolve(result);
         }
         catch (err) {
-            next.reject(err);
+            // A user-initiated cancel (Stop, or the onboarding cancel+rerun flow)
+            // aborts the in-flight run. That's not a failure — resolve it as a clean
+            // aborted result so the RPC layer doesn't surface "Error: Request
+            // cancelled" in the UI. Only abort errors on a cancelled turn are
+            // swallowed this way; a genuine error still rejects.
+            if (this.cancelledActive && (isAbortError(err) || this.controller?.signal.aborted)) {
+                next.resolve({
+                    text: "",
+                    reason: "aborted_streaming",
+                    sessionId: this.id,
+                    turnCount: 0,
+                    usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+                });
+            }
+            else {
+                next.reject(err);
+            }
         }
         finally {
             this.active = null;
             this.controller = null;
+            this.cancelledActive = false;
+            // Run boundary: apply any model switch that was deferred because it was
+            // requested mid-run. Done here (not in pump) so it still applies when
+            // no further turn is queued.
+            if (this.pendingModel !== null) {
+                this.applyModelSwitch(this.pendingModel);
+                this.pendingModel = null;
+            }
             // Drain the next turn if one is waiting.
             if (this.queue.length > 0)
                 void this.pump();

package/dist/protocol/client.d.ts

@@ -64,6 +64,33 @@ export declare class AgentClient {
      * Legacy form:        cancel(reason?)
      */
     cancel(sessionId?: string, reason?: string): Promise<void>;
+    /**
+     * Clear a session's persisted active goal (CC `/goal clear`). Returns whether
+     * a goal was actually cleared (false = there was none).
+     */
+    goalClear(sessionId?: string): Promise<boolean>;
+    /**
+     * Read a session's persisted active goal objective, or null when there's
+     * none. The host calls this on session load to re-surface the goal block +
+     * Cancel button after a reload (a persistent goal isn't replayed from the
+     * transcript, so the live stream never re-announces it).
+     */
+    goalGet(sessionId: string): Promise<string | null>;
+    /**
+     * Steer an in-flight run: queue a user message spliced in at the next
+     * turn-loop step (不打断 — does not abort the current step). `id` is a stable
+     * host-side handle that rides through to the steer_injected event and lets
+     * unsteer() revoke a still-pending entry. Mirrors the server's handleSteer +
+     * the desktop preload's steer(); without it the SDK can't reach the method
+     * (request() is private) — the protocol was asymmetric after the steer merge.
+     */
+    steer(sessionId: string, text: string, id?: string): Promise<void>;
+    /**
+     * Revoke a still-pending steer entry by id (before the loop consumes it).
+     * Returns false when the loop already consumed it (not an error — it will
+     * arrive as a normal user bubble).
+     */
+    unsteer(sessionId: string, id: string): Promise<boolean>;
     /**
      * Update runtime configuration on the server.
      */

package/dist/protocol/client.js

@@ -99,6 +99,44 @@ export class AgentClient {
     async cancel(sessionId, reason) {
         await this.request(Methods.Cancel, { sessionId, reason });
     }
+    /**
+     * Clear a session's persisted active goal (CC `/goal clear`). Returns whether
+     * a goal was actually cleared (false = there was none).
+     */
+    async goalClear(sessionId) {
+        const res = (await this.request(Methods.GoalClear, { sessionId }));
+        return res?.cleared === true;
+    }
+    /**
+     * Read a session's persisted active goal objective, or null when there's
+     * none. The host calls this on session load to re-surface the goal block +
+     * Cancel button after a reload (a persistent goal isn't replayed from the
+     * transcript, so the live stream never re-announces it).
+     */
+    async goalGet(sessionId) {
+        const res = (await this.request(Methods.GoalGet, { sessionId }));
+        return res?.goal ?? null;
+    }
+    /**
+     * Steer an in-flight run: queue a user message spliced in at the next
+     * turn-loop step (不打断 — does not abort the current step). `id` is a stable
+     * host-side handle that rides through to the steer_injected event and lets
+     * unsteer() revoke a still-pending entry. Mirrors the server's handleSteer +
+     * the desktop preload's steer(); without it the SDK can't reach the method
+     * (request() is private) — the protocol was asymmetric after the steer merge.
+     */
+    async steer(sessionId, text, id) {
+        await this.request(Methods.Steer, { sessionId, text, id });
+    }
+    /**
+     * Revoke a still-pending steer entry by id (before the loop consumes it).
+     * Returns false when the loop already consumed it (not an error — it will
+     * arrive as a normal user bubble).
+     */
+    async unsteer(sessionId, id) {
+        const res = (await this.request(Methods.Unsteer, { sessionId, id }));
+        return res?.removed === true;
+    }
     /**
      * Update runtime configuration on the server.
      */

package/dist/protocol/redact.d.ts

@@ -0,0 +1,50 @@
+/** Produce a short preview (`sk-…abcd`) so UIs can render presence without revealing the secret. */
+export declare function makeApiKeyPreview(apiKey: string | undefined | null): string | undefined;
+/**
+ * Return true when a dotted setting key path points at a secret field.
+ * Used to decide whether `config_get`'s response should redact the value.
+ */
+export declare function isSecretKeyPath(key: string): boolean;
+/**
+ * Redact a single value returned by config_get.
+ *
+ * Two-stage rule:
+ *   1. If the caller-supplied key path itself looks secret
+ *      ("llm.apiKey", "headers.authorization", …) → collapse to "[redacted]".
+ *   2. Otherwise, if the value is an object/array (e.g. config_get("llm") or
+ *      config_get("providers")), walk it with the shared secret redactor
+ *      from logging/sanitize-messages so nested apiKey / token / Bearer
+ *      fields don't slip through verbatim. Primitives pass unchanged.
+ *
+ * Pre-fix this only inspected the top-level key string, so
+ * config_get("providers") returned an array of provider objects with raw
+ * apiKey values intact. That defeated the purpose of the boundary.
+ */
+export declare function maskSecretValue<T>(key: string, value: T): T | "[redacted]";
+/**
+ * Shape of the LLM block returned to clients. We deliberately omit `apiKey`
+ * and surface presence/preview instead. Callers that need the raw key already
+ * have it server-side; clients should never see it.
+ */
+export interface RedactedLlmConfig {
+    provider?: string;
+    model?: string;
+    baseUrl?: string;
+    maxTokens?: number;
+    /** True when an apiKey is configured. */
+    hasApiKey: boolean;
+    /** Short preview when an apiKey is configured; omitted otherwise. */
+    apiKeyPreview?: string;
+}
+/**
+ * Rewrite the LLM section of a config snapshot for transport. We only forward
+ * fields the client legitimately needs to render status; secrets become
+ * derived flags.
+ */
+export declare function redactLlmConfig(llm: {
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    maxTokens?: number;
+}): RedactedLlmConfig;

package/dist/protocol/redact.js

@@ -0,0 +1,71 @@
+import { redactSecrets } from "../logging/sanitize-messages.js";
+/**
+ * Redaction helpers for protocol query responses.
+ *
+ * The protocol exposes config snapshots to any connected client. Raw API keys,
+ * provider credentials, and authorization headers must never leave this
+ * boundary verbatim — the client can use derived fields (`hasApiKey`,
+ * `apiKeyPreview`) to render provider/model status without holding the secret.
+ *
+ * Two entry points:
+ *   - redactConfigForResponse: rewrites the LLM section of the config-query
+ *     payload, removing `apiKey` and adding derived presence/preview fields.
+ *   - maskSecretValue: scrubs a single (key, value) pair returned by
+ *     config_get, where the client picks the key — including `llm.apiKey`.
+ */
+/** Match dotted/camel/snake variants of obviously secret keys. */
+const SECRET_KEY_RE = /(^|[._-])(api[_-]?key|authorization|x[_-]api[_-]key|bearer[_-]?token|access[_-]?token|refresh[_-]?token|secret|password|client[_-]?secret)($|[._-])/i;
+/** Produce a short preview (`sk-…abcd`) so UIs can render presence without revealing the secret. */
+export function makeApiKeyPreview(apiKey) {
+    if (typeof apiKey !== "string" || apiKey.length === 0)
+        return undefined;
+    if (apiKey.length <= 8)
+        return "…";
+    return `${apiKey.slice(0, 3)}…${apiKey.slice(-4)}`;
+}
+/**
+ * Return true when a dotted setting key path points at a secret field.
+ * Used to decide whether `config_get`'s response should redact the value.
+ */
+export function isSecretKeyPath(key) {
+    return SECRET_KEY_RE.test(key);
+}
+/**
+ * Redact a single value returned by config_get.
+ *
+ * Two-stage rule:
+ *   1. If the caller-supplied key path itself looks secret
+ *      ("llm.apiKey", "headers.authorization", …) → collapse to "[redacted]".
+ *   2. Otherwise, if the value is an object/array (e.g. config_get("llm") or
+ *      config_get("providers")), walk it with the shared secret redactor
+ *      from logging/sanitize-messages so nested apiKey / token / Bearer
+ *      fields don't slip through verbatim. Primitives pass unchanged.
+ *
+ * Pre-fix this only inspected the top-level key string, so
+ * config_get("providers") returned an array of provider objects with raw
+ * apiKey values intact. That defeated the purpose of the boundary.
+ */
+export function maskSecretValue(key, value) {
+    if (isSecretKeyPath(key))
+        return "[redacted]";
+    if (value && typeof value === "object") {
+        return redactSecrets(value);
+    }
+    return value;
+}
+/**
+ * Rewrite the LLM section of a config snapshot for transport. We only forward
+ * fields the client legitimately needs to render status; secrets become
+ * derived flags.
+ */
+export function redactLlmConfig(llm) {
+    const preview = makeApiKeyPreview(llm.apiKey);
+    return {
+        provider: llm.provider,
+        model: llm.model,
+        baseUrl: llm.baseUrl,
+        maxTokens: llm.maxTokens,
+        hasApiKey: typeof llm.apiKey === "string" && llm.apiKey.length > 0,
+        ...(preview ? { apiKeyPreview: preview } : {}),
+    };
+}

package/dist/protocol/server.d.ts

@@ -15,6 +15,7 @@
  */
 import type { Transport } from "./transport.js";
 import type { Engine } from "../engine/engine.js";
+import type { ValidatedSettings } from "../settings/schema.js";
 import type { ChatSessionManager } from "./chat-session-manager.js";
 export interface AgentServerOptions {
     /**
@@ -29,11 +30,52 @@ export interface AgentServerOptions {
      */
     engine?: Engine;
     transport: Transport;
+    /**
+     * Reads fresh settings from disk for config hot-reload (layer 2). MUST be
+     * the SAME closure the engineFactory uses for new sessions (e.g.
+     * agent-server-stdio's `freshSettings`) so a reloaded running session and a
+     * newly-created session converge on identical disk config — no divergence.
+     * When absent, `configure({ reloadSettings })` returns an explicit error.
+     */
+    settingsReader?: () => ValidatedSettings;
+    /**
+     * Disk-only active-goal reader, used by agent/goalGet when the session is NOT
+     * live in chatManager. In worker (chatManager) mode there is no legacyEngine
+     * to fall back to, and a reopened-after-restart session isn't a live
+     * ChatSession yet (one is only created on agent/run), so chatManager.get()
+     * misses — without this the handler returned goal:null even though state.json
+     * still held the goal, and the UI's goal block never re-surfaced ("goal 还在
+     * 但页面不显示"). Wire it to SessionManager.readActiveGoal. Optional: legacy
+     * mode already reads disk via the engine, and tests that don't exercise the
+     * reopened-session path can omit it.
+     */
+    readActiveGoalFromDisk?: (sessionId: string) => import("../engine/goal.js").GoalConfig | undefined;
 }
 export declare class AgentServer {
     private readonly chatManager;
     private readonly legacyEngine;
+    private globalQueryEngine;
     private transport;
+    /** Fresh-disk settings reader for config hot-reload; null when not wired. */
+    private readonly settingsReader;
+    /** Disk-only active-goal reader for agent/goalGet on a non-live session. */
+    private readonly readActiveGoalFromDisk;
+    /**
+     * Monotonic config-reload version, bumped per reloadSettings request so each
+     * Engine.refreshRuntimeConfig can drop out-of-order (stale) deliveries (Q5).
+     */
+    private configVersion;
+    /**
+     * JSON of the last disk-default patch broadcast to ALL live sessions (#6).
+     * When a new reloadSettings request produces a byte-identical patch we SKIP
+     * the entire forEachSession broadcast — every session's refreshRuntimeConfig
+     * would otherwise unconditionally reloadHooks() (invalidate + full disk
+     * re-read + hook teardown/re-register) per call, and the personalization UI
+     * auto-saves on a 600ms debounce, so identical re-saves caused K× hook churn
+     * per keystroke-pause. A genuine change still differs in JSON → propagates.
+     * null until the first broadcast.
+     */
+    private lastBroadcastPatch;
     private running;
     private abortController;
     /** Pending approval requests: requestId → resolve function (legacy path) */
@@ -50,16 +92,89 @@ export declare class AgentServer {
      */
     private bgAgentBusUnsubscribe;
     constructor(options: AgentServerOptions);
+    /**
+     * Wake an IDLE chatManager session that has pending background-completion
+     * notifications, by enqueueing one turn whose task is the drained
+     * notification(s). The model then sees the completion and continues; the
+     * session's persisted goal (if any) is judged on that turn.
+     *
+     * Guards:
+     * - chatManager path only (the legacy single-engine / headless path drives
+     *   its own loop and has no idle-session-resume concept).
+     * - Session must exist AND be idle. If it's busy, we do nothing: the in-flight
+     *   run's end-of-turn `drainAll` already collects every pending notification,
+     *   so a second run would be redundant — and `enqueueTurn` while busy would
+     *   queue a spurious extra turn.
+     * - We `drainAll` exactly here and feed the items into the woken turn. This
+     *   also merges a burst of near-simultaneous completions into one wakeup:
+     *   the first drains all currently-pending items; subsequent bus events for
+     *   the same session find it busy (or find an empty queue) and no-op.
+     *
+     * INVARIANT (the burst-merge correctness depends on it): the merge only
+     * holds because (a) the bus fans out to subscribers SYNCHRONOUSLY, and (b)
+     * `enqueueTurn` sets the session's `active` (→ isBusy()===true) SYNCHRONOUSLY
+     * before its first await. So when bus events #2..N arrive — still on the same
+     * synchronous fan-out as #1 — they already see the session as busy and no-op.
+     * If either path is ever made async (e.g. an await is added inside
+     * enqueueTurn before `active` is set, or the bus starts deferring delivery),
+     * this degrades into N concurrent wakeups for N completions. Keep both
+     * synchronous, or replace this comment's assumption with an explicit
+     * "wakeup in flight" guard flag.
+     */
+    private maybeWakeIdleSession;
     private handleRequest;
     private handleRun;
     private handleRunMulti;
     private handleRunLegacy;
     private handleApprove;
     private handleCancel;
+    /**
+     * Extend a running goal's turn/budget ceilings mid-run (TODO 3.1). Routed to
+     * a specific session (multi-session path). Returns the resulting effective
+     * limits, or an error if no session / no active run.
+     */
+    private handleGoalExtend;
+    /**
+     * Clear a session's persisted active goal (CC /goal clear). Routes to the
+     * named session, falling back to the legacy single engine (mirrors
+     * handleGoalExtend / handleCancel's dual path). Returns { ok, cleared }.
+     */
+    private handleGoalClear;
+    /**
+     * Read a session's persisted active goal so the host can re-surface the goal
+     * block + Cancel button on session load. A persistent goal lives only in
+     * state.activeGoal and is never replayed from the transcript, so a reloaded
+     * (or disk-rebuilt) session has no other way to learn it. Prefers a live
+     * chatManager session, else falls through to a disk read (readActiveGoalFromDisk
+     * in worker mode, or the legacy engine's disk read in single-engine mode) — the
+     * bug case is an aborted/reloaded session that is NOT live. Returns { ok, goal } where goal
+     * is the objective string, or null when there's no goal / unknown session.
+     * Never errors on "no goal" — null is the normal "nothing to show" answer.
+     */
+    private handleGoalGet;
+    /**
+     * Query/control a session's background shells for the desktop UI panel (TODO
+     * 3.2). Reads the singleton BackgroundShellManager directly (shells outlive
+     * the run that spawned them, so we don't need a live ChatSession). Actions:
+     *   - (default) list  → the session's shells
+     *   - output          → full retained output of one shell
+     *   - kill            → terminate one shell's process group
+     * All scoped by sessionId (manager enforces ownership on output/kill).
+     */
+    private handleBackgroundShells;
+    /**
+     * BackgroundWork — unified, list-only view of a session's background work
+     * across all three registries (shells + sub-agents + jobs) for the desktop
+     * background panel. Per-shell output/kill still flow through BackgroundShells
+     * (by shellId); this just answers "what's running in the background right now".
+     */
+    private handleBackgroundWork;
     private handleCloseSession;
     private handleConfigure;
     private handleQuery;
     private handleInject;
+    private handleSteer;
+    private handleUnsteer;
     /**
      * Ask the client to approve a tool operation (legacy single-engine path).
      */
@@ -67,14 +182,50 @@ export declare class AgentServer {
     /**
      * Ask the client to answer a question from the agent (legacy single-engine path).
      */
+    /**
+     * Per-session AskUserQuestion for the chatManager path. Mirrors
+     * requestAskUserFromClient but resolves via the SESSION's pendingApprovals
+     * (the chatManager approve handler looks there, keyed by sessionId+requestId)
+     * and tags the notify with sessionId so the renderer routes the question to
+     * the right chat tab.
+     */
+    private requestAskUserForSession;
+    /**
+     * Build a BrowserBridge whose every method routes a browser action to the
+     * client over the session's pendingApprovals channel (same as askUser). The
+     * client (Electron main) drives the webview via CDP and replies with a JSON
+     * result string we parse back into the typed result. On timeout / malformed
+     * reply we degrade to a safe error result rather than throwing.
+     */
+    private makeBrowserBridge;
+    private requestBrowserActionForSession;
+    /**
+     * Ask the client (Electron main) to inject a cookie credential into the
+     * built-in browser. Same pendingApprovals channel as browser actions; main
+     * calls restoreCookiesToBrowser and replies with a JSON result string we
+     * parse into { ok, count?, error? }. Degrades to ok:false on timeout/malformed.
+     */
+    private requestCredentialInjectForSession;
     private requestAskUserFromClient;
     private notify;
     /**
-     * Get any available engine — used for global query ops when chatManager is
-     * present but no legacyEngine was supplied. Borrows the first live session.
+     * Get any available engine — used for global query/configure ops when
+     * chatManager is present but no legacyEngine was supplied. Prefer a live chat
+     * session; before the first user turn, lazily build a detached engine through
+     * the manager's factory so global UI surfaces (/login, model manager, model
+     * selector) can query models/providers without requiring a chat session first.
      */
     private anyEngine;
     close(): void;
     private clearApprovalTimer;
+    /**
+     * Resolve all of a chat session's pending approvals as cancelled and clear
+     * the matching server-side approval timers. Used by handleCancel's
+     * per-session path so a Stop while a tool is awaiting approval doesn't leave
+     * the tool hanging until APPROVAL_TIMEOUT_MS (and leak the timer). Each
+     * requestId in the session map has a same-keyed entry in this.approvalTimers
+     * (see requestAskUserForSession / makeBrowserBridge).
+     */
+    private cancelSessionApprovals;
     private clearAllApprovalTimers;
 }