@bubblebrain-ai/bubble 0.0.46 → 0.0.48

package/dist/sdk/index.js

@@ -0,0 +1,400 @@
+/**
+ * Bubble SDK — the programmatic embedding surface for external hosts.
+ *
+ * Two layers:
+ *  1. `BubbleSdk` — a high-level facade that owns config/provider resolution and
+ *     assembles a full agent turn (tools, approvals, questions, plan mode, MCP,
+ *     skills, hooks, session persistence) behind a single `runTurn()` async
+ *     iterator of `AgentEvent`s. This is what a host like an Electron app should
+ *     consume: wire the three interaction callbacks (approval / question / plan)
+ *     to its own UI and map the event stream to its own message format.
+ *  2. Curated re-exports of the underlying building blocks, for hosts that need
+ *     to assemble a custom loop the facade doesn't cover.
+ *
+ * Runs under plain Node (>=20); nothing here touches the TUI layer.
+ */
+import os from "node:os";
+import { rmSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { Agent } from "../agent.js";
+import { SessionManager } from "../session.js";
+import { PermissionAwareApprovalController } from "../approval/controller.js";
+import { BashAllowlist } from "../approval/session-cache.js";
+import { createAllTools, buildToolPromptOptions } from "../tools/index.js";
+import { buildSystemPrompt } from "../system-prompt.js";
+import { FileStateTracker } from "../tools/file-state.js";
+import { BudgetLedger } from "../agent/budget-ledger.js";
+import { UserConfig } from "../config.js";
+import { ProviderRegistry, encodeModel, decodeModel, displayModel } from "../provider-registry.js";
+import { createProviderInstance } from "../provider.js";
+import { getDefaultThinkingLevel } from "../variant/variant-resolver.js";
+import { QuestionController } from "../question/controller.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 { loadMcpConfig } from "../mcp/config.js";
+import { ExternalHookController } from "../hooks/controller.js";
+import { buildMemoryPrompt } from "../memory/store.js";
+import { calculateUsageCost } from "../model-pricing.js";
+import { purgeUnsafeMemorySources } from "../memory/session-policy.js";
+import { recordMemoryCitations } from "../memory/usage.js";
+// ── Facade ─────────────────────────────────────────────────────────────────
+export class BubbleSdk {
+    userConfig = new UserConfig();
+    registry = new ProviderRegistry(this.userConfig);
+    defaultCwd;
+    mcpEnabled;
+    cwdBySession = new Map();
+    bashAllowlists = new Map();
+    activeTurns = new Map();
+    mcpToolsByCwd = new Map();
+    /** id -> {cwd,file} rebuilt from disk so sessions survive host restarts. */
+    sessionIndex = new Map();
+    constructor(options = {}) {
+        this.defaultCwd = options.defaultCwd || process.env.BUBBLE_CWD || os.homedir();
+        this.mcpEnabled = options.mcp !== false;
+    }
+    // ── Sessions ─────────────────────────────────────────────────────────────
+    listSessions() {
+        const sessions = SessionManager.listAllSessions();
+        this.sessionIndex = new Map(sessions.map((s) => [s.name, { cwd: s.cwd ?? s.cwdLabel ?? this.defaultCwd, file: s.file }]));
+        return sessions;
+    }
+    createSession(options = {}) {
+        const cwd = options.cwd || this.defaultCwd;
+        const id = options.id || `sdk-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+        SessionManager.create(cwd, sessionFileName(id));
+        this.cwdBySession.set(id, cwd);
+        return { id, cwd };
+    }
+    getHistory(sessionId) {
+        return this.resolveSession(sessionId)?.manager.getMessages() ?? [];
+    }
+    deleteSession(sessionId) {
+        const resolved = this.resolveSession(sessionId);
+        if (resolved)
+            rmSync(resolved.manager.getSessionFile(), { force: true });
+        this.cwdBySession.delete(sessionId);
+        this.bashAllowlists.delete(sessionId);
+        this.sessionIndex.delete(sessionId);
+    }
+    /** Abort the in-flight turn of a session, if any. */
+    stop(sessionId) {
+        this.activeTurns.get(sessionId)?.abort();
+    }
+    // ── Discovery (composer pickers) ─────────────────────────────────────────
+    listSkills(cwd) {
+        const registry = new SkillRegistry({
+            cwd: cwd || this.defaultCwd,
+            skillPaths: this.userConfig.getSkillPaths(),
+        });
+        return registry.summaries();
+    }
+    /** Configured providers + default model, for a host's model picker. */
+    getModelConfig() {
+        const configured = this.registry.getConfigured().filter((p) => p.enabled);
+        return {
+            defaultProviderId: this.registry.getDefault()?.id ?? "",
+            defaultModel: this.userConfig.getDefaultModel() ?? "",
+            providers: configured.map((p) => ({ id: p.id, baseURL: p.baseURL, hasApiKey: Boolean(p.apiKey) })),
+        };
+    }
+    // ── The turn ─────────────────────────────────────────────────────────────
+    async *runTurn(sessionId, options) {
+        const resolved = this.resolveSession(sessionId);
+        if (!resolved)
+            throw new Error(`Unknown session: ${sessionId}`);
+        const { manager: session, cwd } = resolved;
+        const mode = options.mode ?? "default";
+        const abort = new AbortController();
+        if (options.signal) {
+            if (options.signal.aborted)
+                abort.abort();
+            else
+                options.signal.addEventListener("abort", () => abort.abort(), { once: true });
+        }
+        this.activeTurns.set(sessionId, abort);
+        let agentRef;
+        const hookController = new ExternalHookController({ cwd, sessionId });
+        // 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) => {
+            const decide = () => resolve({ action: "reject", feedback: "Turn aborted" });
+            if (abort.signal.aborted)
+                decide();
+            else
+                abort.signal.addEventListener("abort", decide, { once: true });
+        });
+        const approvalController = new PermissionAwareApprovalController({
+            getMode: () => agentRef?.mode ?? mode,
+            handlerRef: {
+                current: (req) => options.onApproval
+                    ? Promise.race([options.onApproval(req), abortedDecision])
+                    : Promise.resolve({
+                        action: "reject",
+                        feedback: "Host provided no approval handler",
+                    }),
+            },
+            bashAllowlist: this.bashAllowlistFor(sessionId),
+            cwd,
+            externalHooks: hookController,
+        });
+        const fileStateTracker = new FileStateTracker(cwd);
+        const planController = {
+            getMode: () => agentRef?.mode ?? mode,
+            requestApproval: async (plan) => {
+                const approved = options.onPlanApproval ? await options.onPlanApproval(plan) : false;
+                if (approved) {
+                    agentRef?.setMode("default");
+                    return { action: "approve", plan };
+                }
+                return { action: "reject", reason: "Plan rejected by host" };
+            },
+            setMode: (m) => agentRef?.setMode(m),
+        };
+        const questionController = new QuestionController();
+        const unsubscribeQuestions = questionController.subscribe((event) => {
+            if (event.type !== "asked")
+                return;
+            const request = event.request;
+            if (!options.onQuestion) {
+                questionController.reject(request.id);
+                return;
+            }
+            options.onQuestion(request).then((answers) => answers ? questionController.reply(request.id, answers) : questionController.reject(request.id), () => questionController.reject(request.id));
+        });
+        abort.signal.addEventListener("abort", () => questionController.rejectAll(), { once: true });
+        try {
+            const skillRegistry = new SkillRegistry({ cwd, skillPaths: this.userConfig.getSkillPaths() });
+            const tools = createAllTools(cwd, skillRegistry, {
+                approvalController,
+                fileStateTracker,
+                planController,
+                todoStore: {
+                    getTodos: () => agentRef?.getTodos() ?? [],
+                    setTodos: (todos) => agentRef?.setTodos(todos),
+                },
+                questionController,
+                goalStore: new GoalStore(),
+                checkpoints: () => session.getCheckpoints(),
+            });
+            tools.push(...(await this.mcpToolsFor(cwd)));
+            const promptCacheKey = session.getOrCreatePromptCacheKey();
+            session.updateMetadata({ cwd }); // recoverable by cwd after host restart
+            const { provider, providerId, model } = this.resolveProvider(promptCacheKey, options.model);
+            const thinkingLevel = options.thinkingLevel ??
+                this.userConfig.getDefaultThinkingLevel() ??
+                getDefaultThinkingLevel(providerId, decodeModel(model).modelId);
+            // Same ordering as the TUI: the provenance gate must run before memories
+            // enter the system prompt.
+            purgeUnsafeMemorySources(cwd);
+            const memoryPrompt = buildMemoryPrompt(cwd);
+            const builtSystemPrompt = buildSystemPrompt({
+                agentName: "Bubble",
+                configuredProvider: providerId || "none",
+                configuredModel: model ? displayModel(model) : "none",
+                configuredModelId: model || "none",
+                thinkingLevel,
+                mode,
+                workingDir: cwd,
+                ...buildToolPromptOptions(tools.filter((t) => !t.deferred)),
+                memoryPrompt,
+            });
+            const systemPrompt = options.appendSystemPrompt
+                ? `${builtSystemPrompt}\n\n${options.appendSystemPrompt.trim()}`
+                : builtSystemPrompt;
+            const agent = new Agent({
+                provider,
+                providerId,
+                model,
+                sessionID: session.getSessionFile(),
+                tools,
+                systemPrompt,
+                temperature: 0.2,
+                thinkingLevel,
+                mode,
+                todos: session.getTodos(),
+                budgetLedger: new BudgetLedger(),
+                fileStateTracker,
+                skills: skillRegistry.summaries(),
+                memoryPrompt,
+                externalHooks: hookController,
+                onMessageAppend: (message) => {
+                    if (message.role === "system" || message.role === "meta")
+                        return;
+                    session.appendMessage(message);
+                    if (message.role === "assistant")
+                        recordMemoryCitations(cwd, message.content);
+                },
+                onCompactionApplied: (summary) => {
+                    session.applyLLMCompaction(summary);
+                },
+                onTodosUpdate: (todos) => session.appendTodosSnapshot(todos),
+                onModeUpdate: (m) => session.appendMarker("mode_switch", m),
+            });
+            agentRef = agent;
+            const history = session.getMessages();
+            if (history.length > 0) {
+                agent.messages = [{ role: "system", content: systemPrompt }, ...history];
+            }
+            options.onStart?.({
+                providerId,
+                model,
+                thinkingLevel,
+                mode,
+                tools: tools.map((t) => t.name),
+                skills: skillRegistry.summaries().map((s) => s.name),
+            });
+            // Match the TUI: a leading "/<skill-name> <task>" becomes an explicit
+            // load-this-skill instruction, so invocation never depends on the model
+            // recognizing the slash syntax on its own.
+            const prompt = rewriteSkillInvocationPrompt(options.prompt, skillRegistry);
+            const bareModelId = decodeModel(model).modelId;
+            for await (const event of agent.run(prompt, cwd, { abortSignal: abort.signal })) {
+                yield attachTurnCost(event, providerId, bareModelId);
+                if (abort.signal.aborted)
+                    break;
+            }
+        }
+        finally {
+            // Also reached via generator.return() when the host stops consuming
+            // early: aborting here unblocks any tool still awaiting an approval.
+            abort.abort();
+            unsubscribeQuestions();
+            questionController.rejectAll();
+            if (this.activeTurns.get(sessionId) === abort)
+                this.activeTurns.delete(sessionId);
+        }
+    }
+    // ── Internals ────────────────────────────────────────────────────────────
+    bashAllowlistFor(sessionId) {
+        let allowlist = this.bashAllowlists.get(sessionId);
+        if (!allowlist) {
+            allowlist = new BashAllowlist();
+            this.bashAllowlists.set(sessionId, allowlist);
+        }
+        return allowlist;
+    }
+    /** MCP servers are started lazily, once per cwd (McpManager has no stop). */
+    mcpToolsFor(cwd) {
+        if (!this.mcpEnabled)
+            return Promise.resolve([]);
+        let cached = this.mcpToolsByCwd.get(cwd);
+        if (!cached) {
+            cached = (async () => {
+                const loaded = loadMcpConfig({ cwd });
+                if (loaded.servers.length === 0)
+                    return [];
+                const manager = new McpManager({ servers: loaded.servers });
+                await manager.start();
+                return manager.getToolEntries();
+            })().catch(() => []);
+            this.mcpToolsByCwd.set(cwd, cached);
+        }
+        return cached;
+    }
+    resolveSession(sessionId) {
+        const memCwd = this.cwdBySession.get(sessionId);
+        if (memCwd) {
+            // create() only resolves the path and loads iff the file exists, so this
+            // covers both fresh (lazily persisted, not yet on disk) and resumed sessions.
+            return { manager: SessionManager.create(memCwd, sessionFileName(sessionId)), cwd: memCwd };
+        }
+        if (this.sessionIndex.size === 0)
+            this.listSessions();
+        const entry = this.sessionIndex.get(sessionId);
+        if (!entry)
+            return undefined;
+        this.cwdBySession.set(sessionId, entry.cwd);
+        return { manager: new SessionManager(entry.file), cwd: entry.cwd };
+    }
+    resolveProvider(promptCacheKey, explicitModel) {
+        const configuredModel = explicitModel || this.userConfig.getDefaultModel();
+        const defaultProvider = this.registry.getDefault();
+        const fallbackProviderId = defaultProvider?.id ?? "";
+        const normalized = configuredModel
+            ? configuredModel.includes(":")
+                ? configuredModel
+                : fallbackProviderId
+                    ? encodeModel(fallbackProviderId, configuredModel)
+                    : ""
+            : "";
+        const { providerId: effId, modelId: effModelId } = normalized
+            ? decodeModel(normalized)
+            : { providerId: undefined, modelId: "" };
+        const activeProviderId = effId || fallbackProviderId;
+        const target = this.registry.getConfigured().find((p) => p.id === activeProviderId) || defaultProvider;
+        if (!target?.apiKey) {
+            throw new Error("No provider with an API key configured — run the Bubble CLI once to set one up");
+        }
+        const activeModel = effModelId ? encodeModel(activeProviderId, effModelId) : "";
+        const provider = createProviderInstance({
+            providerId: activeProviderId,
+            apiKey: target.apiKey,
+            baseURL: target.baseURL,
+            promptCacheKey,
+            protocol: target.protocol,
+            headers: target.headers,
+        });
+        return { provider, providerId: activeProviderId, model: activeModel };
+    }
+}
+function sessionFileName(sessionId) {
+    return sessionId.endsWith(".jsonl") ? sessionId : `${sessionId}.jsonl`;
+}
+/**
+ * Attach a `cost` field to turn_end events that carry usage, priced via the
+ * static pricing table. Pricing is an accounting concern, so it rides along
+ * here in the SDK rather than in the agent core. Multi-step turns emit several
+ * turn_end events; each cost covers only that step's usage, so hosts sum them.
+ * Events for unpriced models (or without usage) pass through untouched.
+ */
+export function attachTurnCost(event, providerId, modelId) {
+    if (event.type !== "turn_end" || !event.usage)
+        return event;
+    const cost = calculateUsageCost(providerId, modelId, event.usage);
+    return cost ? { ...event, cost } : event;
+}
+/**
+ * If the prompt (or its first text part) is a "/<skill-name> <task>" skill
+ * invocation, rewrite it into the same explicit execution prompt the TUI
+ * sends. Non-matching prompts pass through untouched.
+ */
+export function rewriteSkillInvocationPrompt(prompt, registry) {
+    if (typeof prompt === "string") {
+        return parseSkillInvocation(prompt, registry)?.actualPrompt ?? prompt;
+    }
+    const index = prompt.findIndex((part) => part.type === "text");
+    if (index === -1)
+        return prompt;
+    const part = prompt[index];
+    const rewritten = parseSkillInvocation(part.text, registry)?.actualPrompt;
+    if (!rewritten)
+        return prompt;
+    const next = prompt.slice();
+    next[index] = { ...part, text: rewritten };
+    return next;
+}
+// ── Building blocks (escape hatch for custom hosts) ────────────────────────
+export { Agent, AgentAbortError } from "../agent.js";
+export { SessionManager, getSessionsDir, } from "../session.js";
+export { PermissionAwareApprovalController } from "../approval/controller.js";
+export { BashAllowlist } from "../approval/session-cache.js";
+export { createAllTools, buildToolPromptOptions } from "../tools/index.js";
+export { buildSystemPrompt } from "../system-prompt.js";
+export { FileStateTracker } from "../tools/file-state.js";
+export { BudgetLedger } from "../agent/budget-ledger.js";
+export { UserConfig } from "../config.js";
+export { ProviderRegistry, encodeModel, decodeModel, displayModel, } from "../provider-registry.js";
+export { createProviderInstance } from "../provider.js";
+export { getDefaultThinkingLevel } from "../variant/variant-resolver.js";
+export { QuestionController, QuestionRejectedError, } from "../question/controller.js";
+export { SkillRegistry } from "../skills/registry.js";
+export { parseSkillInvocation } from "../skills/invocation.js";
+export { GoalStore } from "../goal/store.js";
+export { McpManager } from "../mcp/manager.js";
+export { loadMcpConfig } from "../mcp/config.js";
+export { ExternalHookController } from "../hooks/controller.js";
+export { calculateUsageCost, getModelPricing, } from "../model-pricing.js";
+export { registry as slashCommandRegistry } from "../slash-commands/index.js";

package/dist/session.js

@@ -4,6 +4,7 @@
 import { randomUUID } from "node:crypto";
 import { mkdirSync, appendFileSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { isInternalBlockOnlyContent } from "./agent/internal-reminder-sanitizer.js";
 import { getBubbleHome } from "./bubble-home.js";
 import { CheckpointStore } from "./checkpoints.js";
 import { buildCompactedEntries, compactSessionEntries, planOldMessages, planSessionCompaction, } from "./context/compact.js";
@@ -237,6 +238,10 @@ export class SessionManager {
             const entry = entries[i];
             if (entry.type !== "user_message")
                 continue;
+            // Harness-injected turns (goal kicks, task wakes) are internal blocks —
+            // not rewind anchors, and their markup must never render in the picker.
+            if (isInternalBlockOnlyContent(entry.message.content))
+                continue;
             const text = messageText(entry.message);
             turns.push({
                 id: entry.id,
@@ -354,8 +359,11 @@ function firstUserEntryAfterLatestClear(entries) {
     const startIndex = latestClearIndex(entries) + 1;
     for (let i = startIndex; i < entries.length; i++) {
         const entry = entries[i];
-        if (entry.type === "user_message")
+        // Skip harness-injected internal blocks (goal kicks, task wakes): they
+        // must not become the /resume preview or the deterministic title.
+        if (entry.type === "user_message" && !isInternalBlockOnlyContent(entry.message.content)) {
             return entry;
+        }
     }
     return undefined;
 }

package/dist/slash-commands/commands.js

@@ -987,7 +987,7 @@ const builtinSlashCommandEntries = [
     },
     {
         name: "mcp",
-        description: "Manage MCP servers. Usage: /mcp [list|reconnect <name>]",
+        description: "Manage MCP servers. Usage: /mcp [list|tools <name>|reconnect <name>]",
         async handler(args, ctx) {
             const tokens = args.trim().split(/\s+/).filter(Boolean);
             const sub = tokens[0] ?? "list";
@@ -1009,46 +1009,60 @@ const builtinSlashCommandEntries = [
                 }
                 return `${name}: ${state.status.kind}`;
             }
+            if (sub === "tools") {
+                const name = tokens[1];
+                if (!name)
+                    return "Usage: /mcp tools <server-name>";
+                const state = ctx.mcpManager.getStates().find((s) => s.name === name);
+                if (!state)
+                    return `Unknown MCP server: ${name}`;
+                if (state.status.kind !== "connected") {
+                    return `${name} is not connected — no tools to list. Try /mcp reconnect ${name}.`;
+                }
+                const lines = [`Tools from ${name} (${state.status.tools.length}):`, ""];
+                for (const tool of state.status.tools) {
+                    lines.push(`- \`${tool.name}\`${tool.description ? ` — ${tool.description.replace(/\s+/g, " ").slice(0, 100)}` : ""}`);
+                }
+                return lines.join("\n");
+            }
             if (sub !== "list" && sub !== "") {
-                return `Unknown /mcp subcommand "${sub}". Use /mcp list or /mcp reconnect <name>.`;
+                return `Unknown /mcp subcommand "${sub}". Use /mcp list, /mcp tools <name>, or /mcp reconnect <name>.`;
             }
             const states = ctx.mcpManager.getStates();
             if (states.length === 0) {
                 return "No MCP servers configured. Add entries under `mcpServers` in ~/.bubble/settings.json or <cwd>/.bubble/settings.json.";
             }
+            // Rendered as markdown in the TUI: each server is its own paragraph,
+            // failures are bold + uppercase so they stand apart from healthy rows,
+            // and tool lists stay collapsed behind /mcp tools <name>.
             const lines = ["MCP servers:"];
             for (const state of states) {
-                const transport = state.config.type;
-                const scope = state.scope;
+                const meta = `${state.scope}/${state.config.type}`;
+                lines.push("");
                 if (state.status.kind === "connected") {
-                    const info = state.status.serverInfo ? ` ${state.status.serverInfo.name}@${state.status.serverInfo.version}` : "";
+                    const info = state.status.serverInfo ? ` · ${state.status.serverInfo.name}@${state.status.serverInfo.version}` : "";
                     const tn = state.status.tools.length;
                     const pn = state.status.prompts.length;
                     const counts = [`${tn} tool${tn === 1 ? "" : "s"}`];
                     if (pn > 0)
                         counts.push(`${pn} prompt${pn === 1 ? "" : "s"}`);
-                    lines.push(`  ✔ ${state.name} [${scope}/${transport}]${info} — ${counts.join(", ")}`);
-                    for (const tool of state.status.tools) {
-                        lines.push(`      · ${tool.name}${tool.description ? ` — ${tool.description.replace(/\s+/g, " ").slice(0, 80)}` : ""}`);
-                    }
+                    lines.push(`✔ ${state.name} — connected · ${counts.join(" · ")} (${meta}${info})`);
                     if (pn > 0) {
-                        lines.push(`    prompts (invoke as /<name>):`);
-                        for (const p of state.status.prompts) {
-                            const argSig = p.arguments?.length
-                                ? ` <${p.arguments.map((a) => (a.required ? a.name : `${a.name}?`)).join("> <")}>`
-                                : "";
-                            const cmdName = normalizeNameForMCP(p.name);
-                            lines.push(`      · /${cmdName}${argSig}${p.description ? ` — ${p.description.replace(/\s+/g, " ").slice(0, 70)}` : ""}`);
-                        }
+                        const prompts = state.status.prompts.map((p) => `/${normalizeNameForMCP(p.name)}`);
+                        lines.push(`    prompts: ${prompts.join(", ")}`);
                     }
                 }
                 else if (state.status.kind === "failed") {
-                    lines.push(`  ✘ ${state.name} [${scope}/${transport}] — ${state.status.error}`);
+                    lines.push(`**✘ ${state.name} — UNABLE TO CONNECT** (${meta})`);
+                    lines.push(`    ${state.status.error.replace(/\s+/g, " ").slice(0, 200)}`);
+                    lines.push(`    retry: /mcp reconnect ${state.name}`);
                 }
                 else {
-                    lines.push(`  ○ ${state.name} [${scope}/${transport}] — disabled`);
+                    lines.push(`○ ${state.name} — disabled (${meta})`);
                 }
             }
+            lines.push("");
+            lines.push("Details: /mcp tools <name> · /mcp reconnect <name>");
             return lines.join("\n");
         },
     },

package/dist/tools/exit-plan-mode.js

@@ -11,6 +11,14 @@ export function createExitPlanModeTool(controller) {
         readOnly: true,
         effect: "read",
         requiresApproval: true,
+        // Outside plan mode the tool is not just useless, it is bait: models call
+        // it to "wrap up" an ordinary turn despite the description below saying
+        // not to (same failure seen with update_goal — wording loses to the
+        // trained close-out prior). Gating it out of the provider's function list
+        // removes the affordance; the predicate re-runs every model call, so
+        // entering plan mode surfaces it immediately. The runtime no-op in
+        // agent.ts stays as a backstop for a mode flip mid-turn.
+        enabled: () => controller.getMode() === "plan",
         description: "ONLY call this tool when the harness has told you via a runtime reminder that plan mode is ACTIVE. " +
             "Do NOT call it during ordinary work — in default mode you should just use the regular tools directly. " +
             "In plan mode: after investigating, call this with a concrete step-by-step plan so the user can approve, edit, or reject. " +

package/dist/tui/detect-theme.d.ts

@@ -1,3 +1,4 @@
 export type ResolvedTheme = "light" | "dark";
 export declare function detectTerminalTheme(timeoutMs?: number): Promise<ResolvedTheme>;
+export declare function parseColorFgBg(value: string | undefined): ResolvedTheme | null;
 export declare function themeFromMacOsAppearance(output: string | null | undefined): ResolvedTheme;

package/dist/tui/detect-theme.js

@@ -1,19 +1,25 @@
 import { execFileSync } from "node:child_process";
-export async function detectTerminalTheme(timeoutMs = 150) {
-    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
-    if (fromEnv)
-        return fromEnv;
+export async function detectTerminalTheme(timeoutMs = 300) {
+    // OSC 11 asks the terminal for its actual background color right now — the
+    // only signal that tracks a theme switched after the shell started. The
+    // launch-time signals below are tie-breakers for terminals that don't
+    // answer: COLORFGBG is frozen at shell startup (and propagated stale by
+    // tmux/ssh), and the OS appearance describes the system, not the terminal
+    // profile. Ordering OSC 11 first is what keeps "auto" matching reality.
     if (process.stdout.isTTY && process.stdin.isTTY) {
         const fromOsc = await queryOsc11(timeoutMs);
         if (fromOsc)
             return fromOsc;
     }
+    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
+    if (fromEnv)
+        return fromEnv;
     const fromOs = detectOsAppearanceTheme();
     if (fromOs)
         return fromOs;
     return "dark";
 }
-function parseColorFgBg(value) {
+export function parseColorFgBg(value) {
     if (!value)
         return null;
     const parts = value.split(";");

package/dist/tui-ink/app.d.ts

@@ -15,6 +15,7 @@ import type { QuestionController } from "../question/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ExternalHookController } from "../hooks/controller.js";
 import type { GoalStore } from "../goal/store.js";
+import { isInternalBlockOnlyContent } from "../agent/internal-reminder-sanitizer.js";
 import type { ProcessManager } from "../tasks/manager.js";
 import type { PromotionChannel } from "../tasks/promotion.js";
 import type { ExternalRuntimeManager } from "../external-runtime/types.js";
@@ -70,11 +71,7 @@ export interface ExitSummary {
     /** Wall-clock duration of the session, in milliseconds. */
     wallMs: number;
 }
-/**
- * True when a user message is nothing but harness-injected internal blocks
- * (goal kicks, task wakes) — hidden live, so hidden on reconstruction too.
- */
-export declare function isInternalBlockOnlyContent(content: Message["content"]): boolean;
+export { isInternalBlockOnlyContent };
 export declare function reconstructDisplayMessages(agentMessages: Message[]): DisplayMessage[];
 export declare const INK_LOCAL_SLASH_COMMANDS: readonly [{
     readonly name: "goal";
@@ -84,4 +81,3 @@ export declare const INK_LOCAL_SLASH_COMMANDS: readonly [{
     readonly description: "Run a prompt on a recurring interval (/loop 5m <prompt>|list|stop [id])";
 }];
 export declare function App({ agent, args, sessionManager: initialSessionManager, switchSession, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, goalStore, processManager, tasksAutoResume, promotionChannel, bypassEnabled, updateNotice, updateNoticeRefresh, hookController, externalRuntime, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
-export {};