@bubblebrain-ai/bubble 0.0.11 → 0.0.13

package/dist/agent/input-controller.d.ts

@@ -0,0 +1,11 @@
+import type { AgentInputController, AgentRunInput } from "../types.js";
+export declare class AgentRunInputQueue implements AgentInputController {
+    private readonly idPrefix;
+    private pending;
+    private nextInputId;
+    constructor(idPrefix?: string);
+    enqueue(content: string): AgentRunInput;
+    drainPendingInputs(): AgentRunInput[];
+    pendingInputCount(): number;
+    clear(): AgentRunInput[];
+}

package/dist/agent/input-controller.js

@@ -0,0 +1,30 @@
+export class AgentRunInputQueue {
+    idPrefix;
+    pending = [];
+    nextInputId = 0;
+    constructor(idPrefix = "input") {
+        this.idPrefix = idPrefix;
+    }
+    enqueue(content) {
+        const input = {
+            id: `${this.idPrefix}-${++this.nextInputId}`,
+            content,
+            submittedAt: Date.now(),
+        };
+        this.pending.push(input);
+        return input;
+    }
+    drainPendingInputs() {
+        if (this.pending.length === 0)
+            return [];
+        const inputs = this.pending;
+        this.pending = [];
+        return inputs;
+    }
+    pendingInputCount() {
+        return this.pending.length;
+    }
+    clear() {
+        return this.drainPendingInputs();
+    }
+}

package/dist/agent.d.ts

@@ -3,7 +3,7 @@
  * It maintains message state, calls the LLM, executes tools, and auto-continues.
  */
 import { type ContextUsageSnapshot } from "./context/usage.js";
-import type { AgentEvent, ContentPart, PermissionMode, Message, Provider, ThinkingLevel, Todo, ToolResult, ToolRegistryEntry, ToolUpdate } from "./types.js";
+import type { AgentEvent, AgentInputController, ContentPart, PermissionMode, Message, Provider, ThinkingLevel, Todo, ToolResult, ToolRegistryEntry, ToolUpdate } from "./types.js";
 import { type TurnHooks } from "./orchestrator/hooks.js";
 import { type AgentCategoriesConfig, type ResolvedSubagentRoute } from "./agent/categories.js";
 import { BudgetLedger } from "./agent/budget-ledger.js";
@@ -46,6 +46,10 @@ export interface AgentOptions {
     agentCategories?: AgentCategoriesConfig;
     providerFactory?: (route: ResolvedSubagentRoute) => Provider | Promise<Provider>;
 }
+export interface AgentRunOptions {
+    abortSignal?: AbortSignal;
+    inputController?: AgentInputController;
+}
 export declare class Agent {
     messages: Message[];
     private provider;
@@ -116,9 +120,7 @@ export declare class Agent {
     /** Internal: snapshot counter that bumps on every setTodos. Used by run loop to detect mutations. */
     get todosVersion(): number;
     setSystemPrompt(prompt: string): void;
-    run(userInput: string | ContentPart[], cwd: string, options?: {
-        abortSignal?: AbortSignal;
-    }): AsyncIterable<AgentEvent>;
+    run(userInput: string | ContentPart[], cwd: string, options?: AgentRunOptions): AsyncIterable<AgentEvent>;
     private recoverFromOverflow;
     compactResidentHistory(): void;
     private maybeCompactWithLLM;

package/dist/agent.js

@@ -236,6 +236,7 @@ export class Agent {
     }
     async *run(userInput, cwd, options = {}) {
         const abortSignal = composeAbortSignals([options.abortSignal, this.budgetLedger?.signal]);
+        const inputController = options.inputController;
         throwIfAborted(abortSignal);
         const hookBus = new HookBus();
         for (const hooks of createDefaultHooks()) {
@@ -249,6 +250,39 @@ export class Agent {
         const queueReminder = (reminder) => {
             reminderQueue.push(reminder);
         };
+        const pendingInputCount = () => inputController?.pendingInputCount() ?? 0;
+        const applyPendingInputs = () => {
+            const pendingInputs = inputController?.drainPendingInputs() ?? [];
+            if (pendingInputs.length === 0)
+                return [];
+            for (const input of pendingInputs) {
+                this.appendMessage({ role: "user", content: input.content });
+            }
+            return [
+                ...pendingInputs.map((input) => ({
+                    type: "input_applied",
+                    id: input.id,
+                    content: input.content,
+                    target: "current_turn",
+                })),
+                { type: "input_pending_changed", pending: pendingInputCount() },
+            ];
+        };
+        const rejectPendingInputs = (reason) => {
+            const pendingInputs = inputController?.drainPendingInputs() ?? [];
+            if (pendingInputs.length === 0)
+                return [];
+            return [
+                ...pendingInputs.map((input) => ({
+                    type: "input_rejected",
+                    id: input.id,
+                    content: input.content,
+                    reason,
+                    target: "next_turn",
+                })),
+                { type: "input_pending_changed", pending: pendingInputCount() },
+            ];
+        };
         const flushGovernorReminders = () => {
             for (const reminder of reminderQueue.splice(0, reminderQueue.length)) {
                 this.injectSystemReminder(reminder);
@@ -275,6 +309,8 @@ export class Agent {
             flushGovernorReminders();
             for (const update of this.drainSubagentToolUpdates())
                 yield update;
+            for (const event of applyPendingInputs())
+                yield event;
             yield { type: "turn_start" };
             step += 1;
             hookState.turnCount = step;
@@ -604,6 +640,8 @@ export class Agent {
                 delete hookState.forceContinuationReason;
                 continue;
             }
+            for (const event of rejectPendingInputs("no_continuation"))
+                yield event;
             break;
         }
         for (const update of this.drainSubagentToolUpdates())
@@ -1061,7 +1099,6 @@ export class Agent {
             mode: "plan",
             workingDir: cwd,
             tools: childToolNames,
-            skills: childToolNames.includes("skill") ? this.skillSummaries : undefined,
             memoryPrompt: childToolNames.some((name) => name === "memory_search" || name === "memory_read_summary")
                 ? this.memoryPrompt
                 : undefined,
@@ -1257,7 +1294,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, lsp, web_search, web_fetch, spawn_agent, wait_agent, send_input, close_agent, skill, todo_write, tool_search, question, exit_plan_mode). ` +
+                    `In plan mode you may only use read-only tools (read, glob, grep, lsp, web_search, web_fetch, spawn_agent, wait_agent, send_input, close_agent, skill_search, skill, todo_write, 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,
             };

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

@@ -23,6 +23,7 @@ import { createAllTools } from "../../tools/index.js";
 import { displayModel, encodeModel, decodeModel } from "../../provider-registry.js";
 import { buildMemoryPrompt, recordMemoryCitations } from "../../memory/index.js";
 import { getDefaultThinkingLevel } from "../../provider-transform.js";
+import { createSessionTitleUpdater } from "../../session-title.js";
 import { applyCardBudget } from "../card/budget.js";
 import { renderCard } from "../card/renderer.js";
 import { createInitialRunState } from "../card/run-state-types.js";
@@ -78,7 +79,8 @@ export class RunDriver {
             // the question tool to the agent.
         });
         tools.push(...this.opts.deps.mcpManager.getToolEntries());
-        const { provider, providerId, model } = await this.resolveProvider(session);
+        const promptCacheKey = session.manager.getOrCreatePromptCacheKey();
+        const { provider, providerId, model } = await this.resolveProvider(session, promptCacheKey);
         const skills = this.opts.deps.skillRegistry.summaries();
         const memoryPrompt = buildMemoryPrompt(session.cwd);
         const thinkingLevel = this.opts.deps.userConfig.getDefaultThinkingLevel()
@@ -93,10 +95,10 @@ export class RunDriver {
             mode: initialMode,
             workingDir: session.cwd,
             tools: tools.map((t) => t.name),
-            skills,
             memoryPrompt,
         });
         const budgetLedger = new BudgetLedger();
+        let sessionTitleUpdater;
         const agent = new Agent({
             provider,
             providerId,
@@ -112,6 +114,7 @@ export class RunDriver {
                 if (message.role === "system" || message.role === "meta")
                     return;
                 session.manager.appendMessage(message);
+                sessionTitleUpdater?.handlePersistedMessage(message);
                 if (message.role === "assistant") {
                     recordMemoryCitations(session.cwd, message.content);
                 }
@@ -133,11 +136,15 @@ export class RunDriver {
             memoryPrompt,
             fileStateTracker,
             agentCategories: this.opts.deps.userConfig.getAgentCategories(),
-            providerFactory: this.opts.deps.createProviderForRoute,
+            providerFactory: (route) => this.opts.deps.createProviderForRoute(route, promptCacheKey),
+        });
+        sessionTitleUpdater = createSessionTitleUpdater({
+            sessionManager: session.manager,
+            complete: (messages, completeOptions) => agent.complete(messages, completeOptions),
         });
         agentRef = agent;
         agentForPlan = agent;
-        session.manager.setMetadata({
+        session.manager.updateMetadata({
             ...(agent.model ? { model: agent.model } : {}),
             cwd: session.cwd,
             thinkingLevel: agent.thinking,
@@ -245,7 +252,7 @@ export class RunDriver {
             this.opts.approvalUI.cancelForChat(req.chatId, "Run ended");
         }
     }
-    async resolveProvider(session) {
+    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
@@ -272,7 +279,7 @@ export class RunDriver {
         const activeModel = effectiveModelId
             ? encodeModel(activeProviderId, effectiveModelId)
             : "";
-        const provider = this.opts.deps.createProvider(activeProviderId, target.apiKey, target.baseURL);
+        const provider = this.opts.deps.createProvider(activeProviderId, target.apiKey, target.baseURL, promptCacheKey);
         return { provider, providerId: activeProviderId, model: activeModel };
     }
 }

package/dist/feishu/agent-host/runtime-deps.d.ts

@@ -23,11 +23,11 @@ export interface FeishuRuntimeDeps {
     /** Live MCP tool source; tools list includes MCP entries. */
     mcpManager: McpManager;
     /** Factory used by main provider + subagent routes. */
-    createProvider: (providerId: string, apiKey: string, baseURL: string) => Provider;
+    createProvider: (providerId: string, apiKey: string, baseURL: string, promptCacheKey?: string) => Provider;
     createProviderForRoute: (route: {
         providerId: string;
         model: string;
-    }) => Promise<Provider>;
+    }, promptCacheKey?: string) => Promise<Provider>;
     /** Resolved owner open_id (from config.app.ownerOpenId). */
     ownerOpenId: string;
 }

package/dist/feishu/router/commands.js

@@ -192,7 +192,7 @@ register({
             const lines = ["最近 session：", ""];
             for (const s of recent) {
                 const stamp = new Date(s.mtime).toISOString().slice(0, 19).replace("T", " ");
-                lines.push(`- \`${s.name}\` · ${stamp} · ${s.messageCount} msgs · ${s.firstUserMessage.slice(0, 50)}`);
+                lines.push(`- \`${s.name}\` · ${stamp} · ${s.messageCount} msgs · ${s.title.slice(0, 50)}`);
             }
             lines.push("");
             lines.push("用 `/resume <name>` 恢复。");
@@ -239,6 +239,7 @@ register({
         }
         const opened = ctx.sessionBinder.openOrBootstrap(input.scopeKey, entry.cwd, entry.permissionMode);
         opened.manager.appendMarker("conversation_clear", String(Date.now()));
+        opened.manager.clearTitleMetadata();
         await ctx.channel.send(input.chatId, { text: "🧹 已插入清除标记。下次发消息从空上下文开始。" });
     },
 });

package/dist/feishu/scope/session-binder.js

@@ -37,7 +37,7 @@ export class SessionBinder {
         // Persist metadata immediately so the on-disk file exists from this point
         // on — otherwise openOrBootstrap() on the next call would see the pointer
         // but no file and re-bootstrap, losing the pointer.
-        manager.setMetadata({ cwd });
+        manager.updateMetadata({ cwd });
         const entry = {
             sessionFile: manager.getSessionFile(),
             cwd,

package/dist/feishu/serve.js

@@ -91,13 +91,13 @@ export async function serveFeishu(opts = {}) {
     if (mcpLoaded.servers.length > 0) {
         await mcpManager.start();
     }
-    const createProvider = (providerId, apiKey, baseURL) => createProviderInstance({ providerId, apiKey, baseURL });
-    const createProviderForRoute = async (route) => {
+    const createProvider = (providerId, apiKey, baseURL, promptCacheKey) => createProviderInstance({ providerId, apiKey, baseURL, promptCacheKey });
+    const createProviderForRoute = async (route, promptCacheKey) => {
         const target = providerRegistry.getConfigured().find((p) => p.id === route.providerId);
         if (!target?.apiKey) {
             throw new Error(`Subagent route requires provider "${route.providerId}", not configured.`);
         }
-        return createProvider(route.providerId, target.apiKey, target.baseURL);
+        return createProvider(route.providerId, target.apiKey, target.baseURL, promptCacheKey);
     };
     const deps = {
         settingsManager,

package/dist/main.js

@@ -11,6 +11,7 @@ import { createProviderInstance, createUnavailableProvider } from "./provider.js
 import { getDefaultThinkingLevel } from "./provider-transform.js";
 import { ProviderRegistry, displayModel, encodeModel, decodeModel } from "./provider-registry.js";
 import { SessionManager } from "./session.js";
+import { createSessionTitleUpdater } from "./session-title.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { SkillRegistry } from "./skills/registry.js";
 import { createAllTools } from "./tools/index.js";
@@ -24,6 +25,8 @@ import { McpManager } from "./mcp/manager.js";
 import { QuestionController } from "./question/index.js";
 import { buildMemoryPrompt, formatMemoryStartupResult, recordMemoryCitations, runMemoryPhase2, runMemoryStartupPipeline, startMemoryStartupTask, } from "./memory/index.js";
 import { basename } from "node:path";
+import { normalizeSingleLine, truncateVisual } from "./text-display.js";
+import { BUBBLE_WORDMARK } from "./tui/wordmark.js";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
@@ -61,15 +64,23 @@ async function main() {
     }
     const defaultProvider = registry.getDefault();
     const unavailableProviderMessage = "No provider configured. Use /login for ChatGPT or /provider --add <id> before sending a prompt.";
+    let sessionPromptCacheKey;
     const provider = defaultProvider
         ? createProviderInstance({
             providerId: defaultProvider.id,
             apiKey: defaultProvider.apiKey,
             baseURL: defaultProvider.baseURL,
             thinkingLevel: args.thinkingLevel,
+            promptCacheKey: sessionPromptCacheKey,
         })
         : createUnavailableProvider(unavailableProviderMessage);
-    const createProvider = (providerId, apiKey, baseURL) => createProviderInstance({ providerId, apiKey, baseURL, thinkingLevel: args.thinkingLevel });
+    const createProvider = (providerId, apiKey, baseURL) => createProviderInstance({
+        providerId,
+        apiKey,
+        baseURL,
+        thinkingLevel: args.thinkingLevel,
+        promptCacheKey: sessionPromptCacheKey,
+    });
     const createProviderForRoute = async (route) => {
         const providerId = route.providerId;
         if (!providerId) {
@@ -174,7 +185,7 @@ async function main() {
     // - --resume (no name): show interactive picker
     let sessionManager;
     let resumedExistingSession = false;
-    // Resolved before any Ink render so picker and main TUI share the same value
+    // Resolved before any TUI render so picker and main TUI share the same value
     // and we only run OSC 11 once.
     let preResolvedTheme;
     if (args.resume && !args.sessionName) {
@@ -186,13 +197,13 @@ async function main() {
         else {
             const themeConfig = userConfig.getTheme();
             if (themeConfig.mode === "auto") {
-                const { detectTerminalTheme } = await import("./tui-ink/detect-theme.js");
+                const { detectTerminalTheme } = await import("./tui/detect-theme.js");
                 preResolvedTheme = await detectTerminalTheme();
             }
             else {
                 preResolvedTheme = themeConfig.mode;
             }
-            const { runSessionPicker } = await import("./tui-ink/run-session-picker.js");
+            const { runSessionPicker } = await import("./tui-opentui/run-session-picker.js");
             const picked = await runSessionPicker({
                 currentCwd: args.cwd,
                 currentSessions,
@@ -216,6 +227,7 @@ async function main() {
             : SessionManager.createFresh(args.cwd);
         resumedExistingSession = false;
     }
+    sessionPromptCacheKey = sessionManager.getOrCreatePromptCacheKey();
     // Model resolution:
     // 1. Session metadata  2. User-configured default model  3. CLI flag
     // No implicit built-in model fallback.
@@ -262,10 +274,10 @@ async function main() {
         mode: initialMode,
         workingDir: args.cwd,
         tools: tools.map((tool) => tool.name),
-        skills: skillSummaries,
         memoryPrompt,
     });
     const budgetLedger = new BudgetLedger();
+    let sessionTitleUpdater;
     const agent = new Agent({
         provider: activeProvider
             ? createProvider(activeProviderId, activeProvider.apiKey, activeProvider.baseURL)
@@ -289,6 +301,7 @@ async function main() {
             if (message.role === "meta")
                 return;
             sessionManager.appendMessage(message);
+            sessionTitleUpdater?.handlePersistedMessage(message);
             if (message.role === "assistant") {
                 recordMemoryCitations(args.cwd, message.content);
             }
@@ -318,7 +331,13 @@ async function main() {
     });
     agentRef = agent;
     if (sessionManager) {
-        sessionManager.setMetadata({
+        sessionTitleUpdater = createSessionTitleUpdater({
+            sessionManager,
+            complete: (messages, completeOptions) => agent.complete(messages, completeOptions),
+        });
+    }
+    if (sessionManager) {
+        sessionManager.updateMetadata({
             ...(agent.model ? { model: agent.model } : {}),
             cwd: args.cwd,
             thinkingLevel: agent.thinking,
@@ -405,9 +424,9 @@ async function main() {
             detectedTheme = preResolvedTheme;
         }
         else if (themeConfig.mode === "auto") {
-            // Probe before either TUI runtime owns stdin. OSC 11 needs raw mode, and
-            // runtime renderers can consume the reply before startup code sees it.
-            const { detectTerminalTheme } = await import("./tui-ink/detect-theme.js");
+            // Probe before OpenTUI owns stdin. OSC 11 needs raw mode, and the
+            // runtime renderer can consume the reply before startup code sees it.
+            const { detectTerminalTheme } = await import("./tui/detect-theme.js");
             detectedTheme = await detectTerminalTheme();
         }
         else {
@@ -430,7 +449,7 @@ async function main() {
             runMemorySummary,
             runMemoryRefresh,
         };
-        const { runTui } = await import("./tui-ink/run.js");
+        const { runTui } = await import("./tui/run.js");
         await runTui(agent, args, {
             ...commonOptions,
             themeMode: themeConfig.mode,
@@ -439,14 +458,61 @@ async function main() {
             onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
         });
         if (sessionManager) {
-            const sessionName = basename(sessionManager.getSessionFile());
-            console.log(chalk.dim(`To resume: bubble --resume   (or --resume --session ${sessionName})`));
+            printOpenTuiExitSummary(sessionManager, {
+                resumed: resumedExistingSession,
+                theme: detectedTheme,
+            });
         }
     }
     finally {
         await shutdownRuntime();
     }
 }
+function printOpenTuiExitSummary(sessionManager, options) {
+    if (!process.stdout.isTTY)
+        return;
+    const sessionName = basename(sessionManager.getSessionFile());
+    const sessionId = sessionName.replace(/\.jsonl$/, "");
+    const title = truncateVisual(normalizeSingleLine(sessionManager.getMetadata().title ?? ""), 64);
+    const sessionLabel = title || `${options.resumed ? "Session" : "New session"} - ${sessionId}`;
+    const continueCommand = `bubble --resume --session ${sessionName}`;
+    const colors = options.theme === "light"
+        ? {
+            markMuted: chalk.hex("#8C8C8C"),
+            markStrong: chalk.hex("#1C1C1C"),
+            markBrand: chalk.hex("#8B4A00"),
+            label: chalk.hex("#6F7377"),
+            value: chalk.hex("#171717").bold,
+        }
+        : {
+            markMuted: chalk.hex("#9CA3AF"),
+            markStrong: chalk.hex("#F4F4F5"),
+            markBrand: chalk.hex("#F5A742"),
+            label: chalk.hex("#808080"),
+            value: chalk.hex("#EEEEEE").bold,
+        };
+    const label = (value) => colors.label(value.padEnd(10));
+    const logoColor = (tone) => {
+        switch (tone) {
+            case "brand": return colors.markBrand;
+            case "ink": return colors.markStrong;
+            case "stone": return colors.markMuted;
+            case "soft": return colors.label;
+            case "caption": return colors.label;
+        }
+    };
+    for (const line of BUBBLE_WORDMARK) {
+        if (line.segments) {
+            console.log(line.segments.map((segment) => logoColor(segment.tone)(segment.text)).join(""));
+        }
+        else {
+            console.log(logoColor(line.tone ?? "caption")(line.text ?? ""));
+        }
+    }
+    console.log();
+    console.log(`${label("Session")}${colors.value(sessionLabel)}`);
+    console.log(`${label("Continue")}${colors.value(continueCommand)}`);
+}
 async function readPipedStdin() {
     if (process.stdin.isTTY)
         return undefined;

package/dist/prompt/compose.js

@@ -8,7 +8,6 @@ import { buildGptProviderPrompt } from "./provider-prompts/gpt.js";
 import { buildKimiProviderPrompt } from "./provider-prompts/kimi.js";
 import { buildEnvironmentPrompt, defaultToolNames } from "./environment.js";
 import { buildRuntimePrompt } from "./runtime.js";
-import { buildSkillsPrompt } from "./skills.js";
 export function composeSystemPrompt(options = {}) {
     const agentName = options.agentName ?? "Bubble";
     const providerPrompt = buildProviderPrompt(agentName, options.configuredProvider, options.configuredModelId, options.configuredModel);
@@ -26,14 +25,12 @@ export function composeSystemPrompt(options = {}) {
         mode: options.mode,
         guidelines: buildGuidelines(options.tools ?? defaultToolNames, options.guidelines ?? []),
     });
-    const skillsPrompt = buildSkillsPrompt(options.skills ?? []);
     return [
         providerPrompt,
         environmentPrompt,
         runtimePrompt,
         options.agentProfilePrompt,
         options.memoryPrompt,
-        skillsPrompt,
     ].filter(Boolean).join("\n\n");
 }
 function buildProviderPrompt(agentName, providerId, modelId, modelName) {
@@ -80,6 +77,9 @@ function buildGuidelines(tools, extraGuidelines) {
     if (tools.includes("question")) {
         add("When the user is explicitly discussing, brainstorming, or shaping an approach instead of asking for immediate execution, use the question tool for targeted clarification or preference choices when it would materially improve the discussion; do not use it for generic permission-to-proceed questions");
     }
+    if (tools.includes("skill_search") && tools.includes("skill")) {
+        add("Skills may provide specialized workflows. When a task appears to match a specialized workflow, call skill_search to find relevant skills, then call skill with the exact name to load the selected skill before applying it");
+    }
     if (tools.includes("todo_write")) {
         add("Use todo_write to plan any task that needs three or more concrete steps before you start. Mark each item completed as soon as it is done; do not batch updates");
     }

package/dist/prompt/environment.js

@@ -14,6 +14,7 @@ export const defaultToolSnippets = {
     send_input: "Send follow-up input to an existing subagent thread",
     close_agent: "Close or cancel a spawned subagent thread",
     question: "Ask the user structured questions when clarification or preference choices would materially improve the work",
+    skill_search: "Search available skills by name, description, tags, and source",
     skill: "Load a named skill with specialized instructions and bundled resources",
     todo_write: "Plan and track multi-step work. Mark each task completed as soon as it is done — do not batch.",
 };
@@ -32,6 +33,7 @@ export const defaultToolNames = [
     "send_input",
     "close_agent",
     "question",
+    "skill_search",
     "skill",
     "todo_write",
 ];

package/dist/prompt/reminders.js

@@ -20,7 +20,7 @@ const PLAN_MODE_ENTER = `
 Plan mode is now ACTIVE.
 
 Rules while in plan mode:
-- Only read-only tools are allowed, including read, glob, grep, lsp, web_search, web_fetch, spawn_agent, wait_agent, send_input, close_agent, skill, todo_write, tool_search, question, and exit_plan_mode.
+- Only read-only tools are allowed, including read, glob, grep, lsp, web_search, web_fetch, spawn_agent, wait_agent, send_input, close_agent, skill_search, skill, todo_write, tool_search, question, and exit_plan_mode.
 - Writes, edits, and shell commands WILL be rejected by the harness; do not try them.
 - Do not edit files or claim implementation is complete while plan mode is active.
 - Investigate the codebase, then use the question tool to clarify important ambiguities, tradeoffs, requirements, or preference choices that would materially change the plan.

package/dist/provider-openai-codex.d.ts

@@ -1,4 +1,4 @@
-import type { Provider, ReasoningEffort, ThinkingLevel } from "./types.js";
+import type { Provider, ReasoningEffort, ThinkingLevel, TokenUsage } from "./types.js";
 export interface CodexModelDescriptor {
     id: string;
     displayName?: string;
@@ -17,7 +17,14 @@ export declare function createOpenAICodexProvider(options: {
     apiKey: string;
     baseURL: string;
     thinkingLevel?: ThinkingLevel;
+    promptCacheKey?: string;
 }): Provider;
+export declare function normalizeOpenAICodexUsage(usage: any): TokenUsage;
+export declare function buildOpenAICodexPromptCacheKey(input: {
+    seed?: string;
+    providerId?: string;
+    model: string;
+}): string | undefined;
 export declare function fetchOpenAICodexModels(options: {
     baseURL: string;
     accessToken: string;

package/dist/provider-openai-codex.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { listBuiltinModels } from "./model-catalog.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
@@ -53,6 +54,8 @@ export function createOpenAICodexProvider(options) {
                 tools: chatOptions.tools,
                 reasoningEffort: requestConfig.reasoningEffort,
                 sessionId,
+                providerId: options.providerId,
+                promptCacheKey: options.promptCacheKey,
             })),
         });
         if (!response.ok) {
@@ -164,14 +167,7 @@ export function createOpenAICodexProvider(options) {
                 if (usage) {
                     yield {
                         type: "usage",
-                        usage: {
-                            promptTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
-                            completionTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0,
-                            reasoningTokens: typeof usage.output_tokens_details?.reasoning_tokens === "number"
-                                ? usage.output_tokens_details.reasoning_tokens
-                                : undefined,
-                            totalTokens: typeof usage.total_tokens === "number" ? usage.total_tokens : undefined,
-                        },
+                        usage: normalizeOpenAICodexUsage(usage),
                     };
                 }
                 continue;
@@ -195,6 +191,30 @@ export function createOpenAICodexProvider(options) {
     }
     return { streamChat, complete };
 }
+export function normalizeOpenAICodexUsage(usage) {
+    const promptTokens = typeof usage?.input_tokens === "number" ? usage.input_tokens : 0;
+    const cachedTokens = typeof usage?.input_tokens_details?.cached_tokens === "number"
+        ? usage.input_tokens_details.cached_tokens
+        : undefined;
+    return {
+        promptTokens,
+        completionTokens: typeof usage?.output_tokens === "number" ? usage.output_tokens : 0,
+        promptCacheHitTokens: cachedTokens,
+        promptCacheMissTokens: cachedTokens !== undefined ? Math.max(0, promptTokens - cachedTokens) : undefined,
+        reasoningTokens: typeof usage?.output_tokens_details?.reasoning_tokens === "number"
+            ? usage.output_tokens_details.reasoning_tokens
+            : undefined,
+        totalTokens: typeof usage?.total_tokens === "number" ? usage.total_tokens : undefined,
+    };
+}
+export function buildOpenAICodexPromptCacheKey(input) {
+    const seed = input.seed?.trim();
+    if (!seed)
+        return undefined;
+    return createHash("sha256")
+        .update(`bubble:${input.providerId || "openai-codex"}:${input.model}:${seed}`)
+        .digest("hex");
+}
 export async function fetchOpenAICodexModels(options) {
     const accountId = extractChatGptAccountId(options.accessToken);
     if (!accountId) {
@@ -228,7 +248,11 @@ function buildRequestBody(messages, options) {
         instructions: instructions || undefined,
         input,
         include: ["reasoning.encrypted_content"],
-        prompt_cache_key: options.sessionId,
+        prompt_cache_key: buildOpenAICodexPromptCacheKey({
+            seed: options.promptCacheKey ?? options.sessionId,
+            providerId: options.providerId,
+            model: options.model,
+        }),
         tool_choice: "auto",
         parallel_tool_calls: true,
         text: { verbosity: "medium" },

package/dist/provider.d.ts

@@ -21,6 +21,8 @@ export interface ProviderInstanceOptions {
     baseURL: string;
     /** Requested thinking level */
     thinkingLevel?: ThinkingLevel;
+    /** Stable per-session seed for provider prompt caches. */
+    promptCacheKey?: string;
 }
 export declare function createUnavailableProvider(message: string): Provider;
 export declare function createProviderInstance(options: ProviderInstanceOptions): Provider;