@bubblebrain-ai/bubble 0.0.58 → 0.0.60

package/dist/sdk/index.js

@@ -21,8 +21,11 @@ import { AgentRunInputQueue } from "../agent/input-controller.js";
 import { SessionTurnCoordinator, } from "./session-turn-coordinator.js";
 import { ReplayEventLog } from "./replay-event-log.js";
 import { SessionManager } from "../session.js";
+import { isPermissionModeReminder } from "../prompt/reminders.js";
 import { PermissionAwareApprovalController } from "../approval/controller.js";
 import { BashAllowlist } from "../approval/session-cache.js";
+import { SettingsManager } from "../permissions/settings.js";
+import { isRepoConfigTrusted, mergedRepoCapabilities, readRepoSettings, trustRepoConfig, } from "../permissions/trust.js";
 import { createAllTools, buildToolPromptOptions } from "../tools/index.js";
 import { buildSystemPrompt } from "../system-prompt.js";
 import { FileStateTracker } from "../tools/file-state.js";
@@ -36,7 +39,7 @@ import { assertProviderModelAllowed } from "../provider-model-policy.js";
 import { SkillRegistry } from "../skills/registry.js";
 import { parseSkillInvocation } from "../skills/invocation.js";
 import { GoalStore } from "../goal/store.js";
-import { McpManager } from "../mcp/manager.js";
+import { McpManager, gateMcpTools } from "../mcp/manager.js";
 import { loadMcpConfig } from "../mcp/config.js";
 import { ExternalHookController } from "../hooks/controller.js";
 import { buildMemoryPrompt } from "../memory/store.js";
@@ -49,12 +52,17 @@ export class BubbleSdk {
     registry = new ProviderRegistry(this.userConfig);
     defaultCwd;
     mcpEnabled;
+    sessionEventRetention;
     cwdBySession = new Map();
     bashAllowlists = new Map();
+    sessionGrants = new Map();
     turnCoordinator = new SessionTurnCoordinator();
     turnRuntimes = new Map();
     lastTurnOptions = new Map();
     mcpToolsByCwd = new Map();
+    mcpManagersByCwd = new Map();
+    /** Folders whose trust question was already put to the host. */
+    projectTrustAsked = new Set();
     inputIdNonce = randomUUID().slice(0, 6);
     nextTurnInputPrefix = 0;
     nextDetachedInputId = 0;
@@ -63,6 +71,10 @@ export class BubbleSdk {
     constructor(options = {}) {
         this.defaultCwd = options.defaultCwd || process.env.BUBBLE_CWD || os.homedir();
         this.mcpEnabled = options.mcp !== false;
+        this.sessionEventRetention = options.sessionEventRetention ?? Infinity;
+        if (this.sessionEventRetention !== Infinity && (!Number.isSafeInteger(this.sessionEventRetention) || this.sessionEventRetention < 1)) {
+            throw new Error('sessionEventRetention must be a positive integer');
+        }
     }
     // ── Sessions ─────────────────────────────────────────────────────────────
     listSessions() {
@@ -84,12 +96,13 @@ export class BubbleSdk {
         if (!resolved)
             throw new Error(`Unknown session: ${sessionId}`);
         const ownerKey = resolved.manager.getSessionFile();
-        const eventLog = sessionEventLogFor(ownerKey);
+        const eventLog = sessionEventLogFor(ownerKey, this.sessionEventRetention);
         const closed = new AbortController();
         return {
             id: sessionId,
             cwd: resolved.cwd,
-            events: eventLog.iterate({ signal: closed.signal }),
+            get latestSequence() { return eventLog.length; },
+            get events() { return eventLog.iterate({ signal: closed.signal }); },
             eventsFrom: (afterSequence) => eventLog.iterate({
                 from: Math.max(0, afterSequence),
                 signal: closed.signal,
@@ -105,6 +118,31 @@ export class BubbleSdk {
             return [];
         return this.resolveSession(sessionId)?.manager.getMessages() ?? [];
     }
+    /** Preserve an accepted desktop input cancelled before runTurn was admitted. */
+    recordInterruptedInput(sessionId, prompt) {
+        const owner = this.ownerForSession(sessionId);
+        if (owner && owner !== this)
+            return owner.recordInterruptedInput(sessionId, prompt);
+        if (this.turnCoordinator.isDeleted(sessionId) || this.getSessionRunState(sessionId).active) {
+            throw new Error(`Cannot record interrupted input while session is active or deleted: ${sessionId}`);
+        }
+        const resolved = this.resolveSession(sessionId);
+        if (!resolved)
+            throw new Error(`Unknown session: ${sessionId}`);
+        this.persistInterruptedInput(resolved, prompt);
+    }
+    persistInterruptedInput(resolved, prompt) {
+        const session = resolved.manager;
+        session.getMessages();
+        const revision = session.getRevision();
+        session.updateMetadata({ cwd: resolved.cwd });
+        session.appendMessage({ role: "user", content: prompt }, revision);
+        session.appendMessage({
+            role: "assistant",
+            content: "[Interrupted by user before execution started.]",
+            error: { name: "MessageAbortedError", message: "Turn stopped during initialization.", aborted: true },
+        }, session.getRevision());
+    }
     async deleteSession(sessionId) {
         const owner = this.ownerForSession(sessionId);
         if (owner && owner !== this)
@@ -117,6 +155,7 @@ export class BubbleSdk {
             rmSync(resolved.manager.getSessionFile(), { force: true });
         this.cwdBySession.delete(sessionId);
         this.bashAllowlists.delete(sessionId);
+        this.sessionGrants.delete(sessionId);
         this.lastTurnOptions.delete(sessionId);
         this.sessionIndex.delete(sessionId);
         processSessionLocations.delete(sessionId);
@@ -133,8 +172,21 @@ export class BubbleSdk {
         const current = this.turnCoordinator.getCurrent(sessionId);
         const runtime = current ? this.turnRuntimes.get(current.id) : undefined;
         runtime?.inputController.closePendingInputs();
-        const stopped = this.turnCoordinator.stopCurrent(sessionId);
-        return stopped + (options.cancelQueued ? this.turnCoordinator.clearQueue(sessionId) : 0);
+        // A reserved turn can release its slot synchronously when cancelled.
+        // Clear the queue first so cancellation cannot promote an unwanted input.
+        const queued = options.cancelQueued ? this.turnCoordinator.clearQueue(sessionId) : 0;
+        return queued + this.turnCoordinator.stopCurrent(sessionId);
+    }
+    /** Stop and wait for persistence, cleanup, and terminal event publication. */
+    async stopAndWait(sessionId, options = {}) {
+        const owner = this.ownerForSession(sessionId);
+        if (owner && owner !== this)
+            return owner.stopAndWait(sessionId, options);
+        const current = this.turnCoordinator.getCurrent(sessionId);
+        const stopping = this.runtimesForSession(sessionId).filter(runtime => options.cancelQueued || runtime.reservation.id === current?.id);
+        const stopped = this.stop(sessionId, options);
+        await Promise.all(stopping.map(runtime => runtime.finished));
+        return stopped;
     }
     /** Cancel queued turns without interrupting the turn that owns the session slot. */
     clearQueue(sessionId) {
@@ -191,14 +243,36 @@ export class BubbleSdk {
         return this.enqueueTurn(sessionId, options);
     }
     // ── Discovery (composer pickers) ─────────────────────────────────────────
-    listSkills(cwd) {
+    listSkills(cwd, skillPaths = []) {
         const registry = new SkillRegistry({
             cwd: cwd || this.defaultCwd,
-            skillPaths: this.userConfig.getSkillPaths(),
+            skillPaths: [...this.userConfig.getSkillPaths(), ...skillPaths],
             disabledSkills: this.userConfig.getDisabledSkills(),
         });
         return registry.summaries();
     }
+    /**
+     * Ask the host once per folder (onProjectTrust) before this turn loads the
+     * repository's allow rules, MCP servers and LSP servers. Trusting restarts
+     * the folder's MCP servers so newly trusted ones are available right away.
+     */
+    async resolveProjectTrust(cwd, options, signal) {
+        if (!options.onProjectTrust || this.projectTrustAsked.has(cwd))
+            return;
+        // Read once: what gets trusted is exactly what the host was shown.
+        const raw = readRepoSettings(cwd);
+        if (isRepoConfigTrusted(cwd, raw))
+            return;
+        this.projectTrustAsked.add(cwd);
+        const trusted = await awaitWithAbort(options.onProjectTrust({ cwd, pending: mergedRepoCapabilities(raw) }), signal);
+        if (!trusted)
+            return;
+        trustRepoConfig(cwd, raw);
+        const manager = this.mcpManagersByCwd.get(cwd);
+        this.mcpManagersByCwd.delete(cwd);
+        this.mcpToolsByCwd.delete(cwd);
+        await (await manager?.catch(() => null))?.shutdown().catch(() => undefined);
+    }
     /** Configured providers + default model, for a host's model picker. */
     getModelConfig() {
         const configured = this.registry.getConfigured().filter((p) => p.enabled);
@@ -248,24 +322,54 @@ export class BubbleSdk {
             outcomes: new Map(),
             options,
             events: new ReplayEventLog(),
+            started: reservation.phase !== "queued",
+            inputRecorded: false,
+            finished: Promise.resolve(),
         };
         this.lastTurnOptions.set(sessionId, inheritableTurnOptions(options));
         this.turnRuntimes.set(reservation.id, runtime);
-        void this.pumpTurn(runtime, resolved);
+        runtime.finished = this.pumpTurn(runtime, resolved);
         return runtime;
     }
     async pumpTurn(runtime, resolved) {
         let failure;
+        let completedEvent;
         try {
             for await (const event of this.runReservedTurn(runtime, runtime.options, resolved)) {
                 runtime.events.append(event);
-                this.publishSessionEvent(runtime, event);
+                // Publish success after the pump's finally releases its slot.
+                // A host can then distinguish idle from an automatically queued steer.
+                if (event.type === "agent_end")
+                    completedEvent = event;
+                else
+                    this.publishSessionEvent(runtime, event);
             }
         }
         catch (error) {
             failure = error;
+            // Setup can fail before runReservedTurn installs its own cleanup.
+            for (const event of this.rejectOutstandingSteers(runtime, runtime.reservation.signal.aborted ? "turn_cancelled" : "turn_failed")) {
+                runtime.events.append(event);
+                this.publishSessionEvent(runtime, event);
+            }
+            // Desktop users already submitted this input. Even if setup was
+            // interrupted before Agent.run appended it, keep it for a later resume.
+            // Cancelled queued inputs never owned the turn and must stay discarded.
+            if (runtime.options.preserveInterruptedInput && runtime.started && !runtime.inputRecorded
+                && runtime.reservation.signal.aborted && !this.turnCoordinator.isDeleted(runtime.sessionId)) {
+                try {
+                    this.persistInterruptedInput(resolved, runtime.options.prompt);
+                }
+                catch (persistError) {
+                    failure = persistError;
+                }
+            }
         }
         finally {
+            runtime.inputController.closePendingInputs();
+            // Release only after the interrupted input is durable. Keep the runtime
+            // discoverable until the terminal event is published for stopAndWait.
+            runtime.reservation.finish();
             if (failure !== undefined) {
                 // The session-level log never closes per turn, so replay subscribers
                 // need an explicit terminal record — otherwise a failed turn is
@@ -277,6 +381,9 @@ export class BubbleSdk {
                     message: failure instanceof Error ? failure.message : String(failure),
                 });
             }
+            else {
+                this.publishSessionEvent(runtime, completedEvent ?? { type: "agent_end" }, { kind: "completed" });
+            }
             runtime.events.close(failure);
             if (this.turnRuntimes.get(runtime.reservation.id) === runtime) {
                 this.turnRuntimes.delete(runtime.reservation.id);
@@ -290,10 +397,18 @@ export class BubbleSdk {
         const { sessionId, reservation, inputController } = runtime;
         const { manager: session, cwd } = resolved;
         const mode = options.mode ?? "default";
+        const planExitMode = options.planExitMode === "bypassPermissions" ? "bypassPermissions" : "default";
         const abortSignal = reservation.signal;
+        await reservation.waitForStart();
+        runtime.started = true;
         let agentRef;
         let streamCompleted = false;
         const hookController = new ExternalHookController({ cwd, sessionId });
+        await this.resolveProjectTrust(cwd, options, abortSignal);
+        // Same allow/deny rules as the TUI (user, project and local settings;
+        // repository allow rules only once trusted). Deny rules bind even under
+        // bypassPermissions.
+        const ruleSet = new SettingsManager(cwd).getMerged().ruleSet;
         // Settles as reject the moment the turn aborts, so a tool blocked on a
         // host approval (or question) can never hang the abort path.
         const abortedDecision = new Promise((resolve) => {
@@ -314,7 +429,10 @@ export class BubbleSdk {
                     }),
             },
             bashAllowlist: this.bashAllowlistFor(sessionId),
+            sessionGrants: this.sessionGrantsFor(sessionId),
             cwd,
+            // Read once per turn: edits to settings files apply from the next turn.
+            getRuleSet: () => ruleSet,
             externalHooks: hookController,
         });
         const fileStateTracker = new FileStateTracker(cwd);
@@ -324,13 +442,13 @@ export class BubbleSdk {
                 const approved = options.onPlanApproval
                     ? await awaitWithAbort(options.onPlanApproval(plan), abortSignal)
                     : false;
-                if (approved) {
-                    agentRef?.setMode("default");
-                    return { action: "approve", plan };
-                }
-                return { action: "reject", reason: "Plan rejected by host" };
+                // exit_plan_mode applies getExitMode() itself on approval.
+                return approved
+                    ? { action: "approve", plan }
+                    : { action: "reject", reason: "Plan rejected by host" };
             },
             setMode: (m) => agentRef?.setMode(m),
+            getExitMode: () => planExitMode,
         };
         const questionController = new QuestionController();
         const unsubscribeQuestions = questionController.subscribe((event) => {
@@ -345,10 +463,9 @@ export class BubbleSdk {
         });
         abortSignal.addEventListener("abort", () => questionController.rejectAll(), { once: true });
         try {
-            await reservation.waitForStart();
             const skillRegistry = new SkillRegistry({
                 cwd,
-                skillPaths: this.userConfig.getSkillPaths(),
+                skillPaths: [...this.userConfig.getSkillPaths(), ...(options.skillPaths ?? [])],
                 disabledSkills: this.userConfig.getDisabledSkills(),
             });
             const tools = createAllTools(cwd, skillRegistry, {
@@ -359,7 +476,23 @@ export class BubbleSdk {
                 goalStore: new GoalStore(),
                 checkpoints: () => session.getCheckpoints(),
             });
-            tools.push(...(await awaitWithAbort(this.mcpToolsFor(cwd), abortSignal)));
+            tools.push(...gateMcpTools(await awaitWithAbort(this.mcpToolsFor(cwd), abortSignal), approvalController));
+            const hostTools = options.hostTools ?? [];
+            const registered = new Set(tools.map(tool => tool.name));
+            for (const tool of hostTools) {
+                if (registered.has(tool.name))
+                    throw new Error(`Duplicate host tool: ${tool.name}`);
+                registered.add(tool.name);
+                const guarded = {
+                    ...tool,
+                    execute: async (args, ctx) => {
+                        throwAbortSignal(abortSignal);
+                        return tool.execute(args, { ...ctx, abortSignal });
+                    },
+                    cloneForChild: () => ({ ...tool, enabled: () => false, execute: async () => ({ content: "Host capability is not available to this child.", isError: true }) }),
+                };
+                tools.push(...(tool.readOnly ? [guarded] : gateMcpTools([guarded], approvalController)));
+            }
             throwAbortSignal(abortSignal);
             const promptCacheKey = session.getOrCreatePromptCacheKey();
             if (!this.turnCoordinator.isDeleted(sessionId)) {
@@ -375,6 +508,8 @@ export class BubbleSdk {
             const memoryPrompt = buildMemoryPrompt(cwd);
             const builtSystemPrompt = buildSystemPrompt({
                 agentName: "Bubble",
+                skills: skillRegistry.summaries(),
+                skillCatalogChars: this.userConfig.getSkillCatalogChars(),
                 configuredProvider: providerId || "none",
                 configuredModel: model ? displayModel(model) : "none",
                 configuredModelId: model || "none",
@@ -387,6 +522,39 @@ export class BubbleSdk {
             const systemPrompt = options.appendSystemPrompt
                 ? `${builtSystemPrompt}\n\n${options.appendSystemPrompt.trim()}`
                 : builtSystemPrompt;
+            // Host-driven mode changes (picker, /plan, leaving plan) go into the log
+            // as markers, so the rebuilt history states the mode where it changed —
+            // after any older tool result that claimed a different mode.
+            if (latestRecordedMode(session) !== mode && !this.turnCoordinator.isDeleted(sessionId)) {
+                session.appendMarker("mode_switch", mode);
+            }
+            const history = session.getMessages();
+            let contextRevision = session.getRevision();
+            // The constructor's leading context minus its mode reminder: the history
+            // carries the mode timeline itself (session-log toMessages).
+            let leadingContext = [];
+            // A fence rejection means the durable log diverged from this turn's
+            // resident snapshot (a foreign append or clear landed mid-flight). Refuse
+            // the write, then roll the resident transcript back to the file's truth so
+            // the rejected message does not linger and later writes are not wedged
+            // behind the stale revision.
+            const persistFenced = (write) => {
+                try {
+                    write();
+                }
+                catch (error) {
+                    // Any refused write (fence rejection, busy lock, I/O) leaves the agent's
+                    // already-pushed message unpersisted. getMessages() refreshes, so read
+                    // the history first and adopt the revision of that same snapshot.
+                    try {
+                        const reloaded = session.getMessages();
+                        contextRevision = session.getRevision();
+                        agent.messages = [...leadingContext, ...reloaded];
+                    }
+                    catch { /* surface the original write failure */ }
+                    throw error;
+                }
+            };
             const agent = new Agent({
                 provider,
                 providerId,
@@ -400,6 +568,7 @@ export class BubbleSdk {
                 budgetLedger: new BudgetLedger(),
                 fileStateTracker,
                 skills: skillRegistry.summaries(),
+                skillCatalogChars: this.userConfig.getSkillCatalogChars(),
                 memoryPrompt,
                 externalHooks: hookController,
                 // Cross-provider subagent routes (spawn_agent with "provider:model")
@@ -413,29 +582,47 @@ export class BubbleSdk {
                         return;
                     if (this.turnCoordinator.isDeleted(sessionId))
                         return;
-                    session.appendMessage(message);
+                    if (message.role === "user")
+                        runtime.inputRecorded = true;
+                    persistFenced(() => {
+                        session.appendMessage(message, contextRevision);
+                        contextRevision = session.getRevision();
+                    });
                     if (message.role === "assistant")
                         recordMemoryCitations(cwd, message.content);
                 },
                 onProviderError: (error) => {
                     if (this.turnCoordinator.isDeleted(sessionId))
                         return;
-                    session.appendProviderError(error);
+                    persistFenced(() => session.appendProviderError(error, contextRevision));
                 },
-                onCompactionApplied: (summary) => {
+                getContextRevision: () => contextRevision,
+                onContextCheckpoint: (checkpoint) => {
                     if (this.turnCoordinator.isDeleted(sessionId))
-                        return;
-                    session.applyLLMCompaction(summary);
+                        throw new Error("Session deleted before context commit");
+                    persistFenced(() => {
+                        session.commitContextCheckpoint(checkpoint, contextRevision);
+                        contextRevision = session.getRevision();
+                    });
                 },
                 onModeUpdate: (m) => {
-                    if (!this.turnCoordinator.isDeleted(sessionId))
-                        session.appendMarker("mode_switch", m);
+                    if (!this.turnCoordinator.isDeleted(sessionId)) {
+                        persistFenced(() => {
+                            session.appendMarker("mode_switch", m, contextRevision);
+                            contextRevision = session.getRevision();
+                        });
+                    }
                 },
             });
             agentRef = agent;
-            const history = session.getMessages();
+            leadingContext = agent.messages.filter((message) => !(message.role === "meta" && isPermissionModeReminder(message.content)));
             if (history.length > 0) {
-                agent.messages = [{ role: "system", content: systemPrompt }, ...history];
+                // Leading context (system prompt + deferred-tools reminder, never
+                // persisted) stays ahead of the history, at the same position every
+                // turn, so the provider's prefix cache covers the previous turn. The
+                // mode reminder comes from the history's own mode markers instead, so
+                // it is ordered after anything older that mentioned a mode.
+                agent.messages = [...leadingContext, ...history];
             }
             reservation.markActive();
             options.onStart?.({
@@ -473,9 +660,6 @@ export class BubbleSdk {
             this.rejectOutstandingSteers(runtime, streamCompleted ? "no_continuation" : abortSignal.aborted ? "turn_cancelled" : "turn_failed", streamCompleted ? resolved : undefined);
             unsubscribeQuestions();
             questionController.rejectAll();
-            reservation.finish();
-            if (this.turnRuntimes.get(reservation.id) === runtime)
-                this.turnRuntimes.delete(reservation.id);
         }
     }
     // ── Internals ────────────────────────────────────────────────────────────
@@ -578,7 +762,7 @@ export class BubbleSdk {
         }
     }
     publishSessionEvent(runtime, event, terminal) {
-        const log = sessionEventLogFor(runtime.ownerKey);
+        const log = sessionEventLogFor(runtime.ownerKey, this.sessionEventRetention);
         log.append({
             sequence: log.length + 1,
             sessionId: runtime.sessionId,
@@ -599,6 +783,14 @@ export class BubbleSdk {
         }
         return allowlist;
     }
+    sessionGrantsFor(sessionId) {
+        let grants = this.sessionGrants.get(sessionId);
+        if (!grants) {
+            grants = new Set();
+            this.sessionGrants.set(sessionId, grants);
+        }
+        return grants;
+    }
     /**
      * Default cross-provider subagent factory over this SDK instance's own
      * registry — the same semantics as the TUI's createProviderForRoute. The
@@ -612,10 +804,10 @@ export class BubbleSdk {
             }
             // getConfigured() reads config.json from disk every call, so keys
             // added after SDK construction are picked up without a reload call.
-            if (this.registry.supportsOAuth(providerId) && this.registry.getAuthStorage().has(providerId)) {
+            const target = this.registry.getConfigured().find((item) => item.id === providerId);
+            if (target?.authType === "oauth") {
                 await this.registry.prepareProvider(providerId);
             }
-            const target = this.registry.getConfigured().find((item) => item.id === providerId);
             if (!target?.enabled || !target.apiKey) {
                 throw new Error(`Subagent route requires provider "${providerId}", but it is not configured or has no active credentials.`);
             }
@@ -630,20 +822,25 @@ export class BubbleSdk {
             });
         };
     }
-    /** MCP servers are started lazily, once per cwd (McpManager has no stop). */
+    /**
+     * MCP servers are started lazily, once per cwd, and restarted only when the
+     * repository's settings get trusted (resolveProjectTrust).
+     */
     mcpToolsFor(cwd) {
         if (!this.mcpEnabled)
             return Promise.resolve([]);
         let cached = this.mcpToolsByCwd.get(cwd);
         if (!cached) {
-            cached = (async () => {
+            const managerPromise = (async () => {
                 const loaded = loadMcpConfig({ cwd });
                 if (loaded.servers.length === 0)
-                    return [];
+                    return null;
                 const manager = new McpManager({ servers: loaded.servers });
                 await manager.start();
-                return manager.getToolEntries();
-            })().catch(() => []);
+                return manager;
+            })().catch(() => null);
+            this.mcpManagersByCwd.set(cwd, managerPromise);
+            cached = managerPromise.then((manager) => manager?.getToolEntries() ?? []);
             this.mcpToolsByCwd.set(cwd, cached);
         }
         return cached;
@@ -706,6 +903,10 @@ export class BubbleSdk {
             promptCacheKey,
             protocol: target.protocol,
             headers: target.headers,
+            // Main SDK turns need the same per-request OAuth renewal as the TUI
+            // and child provider factory, including calls after a long-running tool.
+            openAICodexAuth: this.registry.createOpenAICodexAuthAdapter(activeProviderId),
+            grokAuth: this.registry.createGrokAuthAdapter(activeProviderId),
         });
         return { provider, providerId: activeProviderId, model: activeModel };
     }
@@ -730,10 +931,10 @@ function releaseProcessOwner(ownerKey, sdk) {
     if (processSessionOwners.get(ownerKey) === sdk)
         processSessionOwners.delete(ownerKey);
 }
-function sessionEventLogFor(ownerKey) {
+function sessionEventLogFor(ownerKey, retention = Infinity) {
     let log = sessionEventLogs.get(ownerKey);
     if (!log) {
-        log = new ReplayEventLog();
+        log = new ReplayEventLog(retention);
         sessionEventLogs.set(ownerKey, log);
     }
     return log;
@@ -767,6 +968,18 @@ function throwAbortSignal(signal) {
         throw signal.reason;
     throw new AgentAbortError(typeof signal.reason === "string" ? signal.reason : "SDK turn cancelled.");
 }
+/** The mode the session log last recorded ("default" before any switch). */
+function latestRecordedMode(session) {
+    const entries = session.getEntries();
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (entry.type === "marker" && entry.kind === "mode_switch"
+            && (entry.value === "default" || entry.value === "plan" || entry.value === "bypassPermissions")) {
+            return entry.value;
+        }
+    }
+    return "default";
+}
 function awaitWithAbort(promise, signal) {
     if (signal.aborted) {
         try {

package/dist/sdk/replay-event-log.d.ts

@@ -3,11 +3,17 @@
  * consumer, and consumers can attach again with their last seen sequence.
  */
 export declare class ReplayEventLog<T> {
+    private readonly retention;
     private readonly entries;
+    private nextIndex;
+    private firstIndex;
+    private readonly readers;
     private signal;
     private closed;
     private failure;
+    constructor(retention?: number);
     get length(): number;
+    get retainedCount(): number;
     append(value: T): void;
     close(error?: unknown): void;
     iterate(options?: {
@@ -15,5 +21,6 @@ export declare class ReplayEventLog<T> {
         signal?: AbortSignal;
     }): AsyncGenerator<T>;
     private readFrom;
+    private prune;
     private wake;
 }