@bubblebrain-ai/bubble 0.0.10 → 0.0.12

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";
@@ -23,12 +24,26 @@ import { loadMcpConfig } from "./mcp/config.js";
 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";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
         printHelp();
         process.exit(0);
     }
+    if (args.command === "serve") {
+        if (args.serveHost !== "feishu") {
+            console.error(chalk.red("Usage: bubble serve --feishu [--setup | --kill-old | --dry-run]"));
+            process.exit(2);
+        }
+        const { serveFeishu } = await import("./feishu/index.js");
+        await serveFeishu({
+            setup: args.setup,
+            killOld: args.killOld,
+            dryRun: args.dryRun,
+        });
+        return;
+    }
     const userConfig = new UserConfig();
     const registry = new ProviderRegistry(userConfig);
     const skillRegistry = new SkillRegistry({
@@ -47,15 +62,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) {
@@ -156,17 +179,53 @@ async function main() {
     process.once("SIGTERM", () => { void shutdownMcp().then(() => process.exit(143)); });
     // Session management:
     // - default: always start a fresh session
-    // - --resume: explicitly restore the latest or a named session
-    let sessionManager = args.resume
-        ? SessionManager.resume(args.cwd, args.sessionName)
-        : undefined;
-    let resumedExistingSession = !!sessionManager;
+    // - --resume --session <name>: restore the named session
+    // - --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
+    // and we only run OSC 11 once.
+    let preResolvedTheme;
+    if (args.resume && !args.sessionName) {
+        const currentSessions = SessionManager.summarizeSessionsForCwd(args.cwd);
+        const allSessions = SessionManager.listAllSessions();
+        if (currentSessions.length === 0 && allSessions.length === 0) {
+            console.log(chalk.dim("No previous sessions found — starting a fresh one."));
+        }
+        else {
+            const themeConfig = userConfig.getTheme();
+            if (themeConfig.mode === "auto") {
+                const { detectTerminalTheme } = await import("./tui-ink/detect-theme.js");
+                preResolvedTheme = await detectTerminalTheme();
+            }
+            else {
+                preResolvedTheme = themeConfig.mode;
+            }
+            const { runSessionPicker } = await import("./tui-ink/run-session-picker.js");
+            const picked = await runSessionPicker({
+                currentCwd: args.cwd,
+                currentSessions,
+                allSessions,
+                resolvedTheme: preResolvedTheme,
+                themeOverrides: themeConfig.overrides,
+            });
+            if (picked) {
+                sessionManager = new SessionManager(picked);
+                resumedExistingSession = true;
+            }
+        }
+    }
+    else if (args.resume) {
+        sessionManager = SessionManager.resume(args.cwd, args.sessionName);
+        resumedExistingSession = !!sessionManager;
+    }
     if (!sessionManager) {
         sessionManager = args.sessionName && !args.resume
             ? SessionManager.create(args.cwd, args.sessionName)
             : 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.
@@ -213,10 +272,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)
@@ -240,6 +299,7 @@ async function main() {
             if (message.role === "meta")
                 return;
             sessionManager.appendMessage(message);
+            sessionTitleUpdater?.handlePersistedMessage(message);
             if (message.role === "assistant") {
                 recordMemoryCitations(args.cwd, message.content);
             }
@@ -269,7 +329,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,
@@ -350,8 +416,20 @@ async function main() {
             console.log();
             return;
         }
-        const tuiRuntime = process.env.BUBBLE_TUI === "opentui" ? "opentui" : "ink";
         const themeConfig = userConfig.getTheme();
+        let detectedTheme = "dark";
+        if (preResolvedTheme) {
+            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");
+            detectedTheme = await detectTerminalTheme();
+        }
+        else {
+            detectedTheme = themeConfig.mode;
+        }
         const commonOptions = {
             sessionManager,
             createProvider,
@@ -369,29 +447,17 @@ async function main() {
             runMemorySummary,
             runMemoryRefresh,
         };
-        if (tuiRuntime === "opentui") {
-            const { runTui } = await import("./tui/run.js");
-            await runTui(agent, args, {
-                ...commonOptions,
-                theme: themeConfig.overrides,
-            });
-        }
-        else {
-            // Probe the terminal background BEFORE Ink takes over stdin. OSC 11
-            // needs raw mode, and once Ink owns stdin the reply never reaches us.
-            let detectedTheme = "dark";
-            if (themeConfig.mode === "auto") {
-                const { detectTerminalTheme } = await import("./tui-ink/detect-theme.js");
-                detectedTheme = await detectTerminalTheme();
-            }
-            const { runTui } = await import("./tui-ink/run.js");
-            await runTui(agent, args, {
-                ...commonOptions,
-                themeMode: themeConfig.mode,
-                themeOverrides: themeConfig.overrides,
-                detectedTheme,
-                onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
-            });
+        const { runTui } = await import("./tui-ink/run.js");
+        await runTui(agent, args, {
+            ...commonOptions,
+            themeMode: themeConfig.mode,
+            themeOverrides: themeConfig.overrides,
+            detectedTheme,
+            onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
+        });
+        if (sessionManager) {
+            const sessionName = basename(sessionManager.getSessionFile());
+            console.log(chalk.dim(`To resume: bubble --resume   (or --resume --session ${sessionName})`));
         }
     }
     finally {

package/dist/model-catalog.js

@@ -8,6 +8,7 @@ export const BUILTIN_PROVIDERS = [
     { id: "zhipuai-coding-plan", name: "Zhipu AI Coding Plan", baseURL: "https://open.bigmodel.cn/api/coding/paas/v4" },
     { id: "zai", name: "Z.AI", baseURL: "https://api.z.ai/api/paas/v4" },
     { id: "zai-coding-plan", name: "Z.AI Coding Plan", baseURL: "https://api.z.ai/api/coding/paas/v4" },
+    { id: "alibaba", name: "Alibaba DashScope", baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1" },
     { id: "moonshot-cn", name: "Moonshot (国内 platform.moonshot.cn)", baseURL: "https://api.moonshot.cn/v1" },
     { id: "moonshot-intl", name: "Moonshot (海外 platform.moonshot.ai)", baseURL: "https://api.moonshot.ai/v1" },
     { id: "kimi-for-coding", name: "Kimi for Coding", baseURL: "https://api.kimi.com/coding/v1" },
@@ -55,6 +56,8 @@ export const BUILTIN_MODELS = [
     { id: "glm-5-turbo", name: "GLM-5-Turbo", providerId: "zai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
+    { id: "qwen3.6-plus", name: "Qwen3.6 Plus", providerId: "alibaba", reasoningLevels: ["off"], contextWindow: 1048576 },
+    { id: "qwen3.7-max", name: "Qwen3.7 Max", providerId: "alibaba", reasoningLevels: ["off"], contextWindow: 1048576 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "k2.6-code-preview", name: "Kimi K2.6 Code Preview", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },

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;

package/dist/session-title.d.ts

@@ -0,0 +1,16 @@
+import type { SessionManager } from "./session.js";
+import type { ContentPart, Message, ProviderMessage, ThinkingLevel } from "./types.js";
+export interface SessionTitleUpdater {
+    handlePersistedMessage(message: Message): void;
+}
+export declare function createSessionTitleUpdater(options: {
+    sessionManager: SessionManager;
+    complete: (messages: ProviderMessage[], options?: {
+        model?: string;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+        abortSignal?: AbortSignal;
+    }) => Promise<string>;
+}): SessionTitleUpdater;
+export declare function cleanGeneratedTitle(raw: string): string;
+export declare function deterministicTitleFromUserContent(content: string | ContentPart[]): string;

package/dist/session-title.js

@@ -0,0 +1,134 @@
+import { normalizeSingleLine, truncateVisual } from "./text-display.js";
+const LONG_PASTE_CHAR_THRESHOLD = 1000;
+const LONG_PASTE_LINE_THRESHOLD = 20;
+const TITLE_INPUT_MAX_CHARS = 4000;
+const TITLE_MAX_WIDTH = 80;
+const TITLE_SYSTEM_PROMPT = [
+    "You are a title generator. Output ONLY a conversation title.",
+    "",
+    "Rules:",
+    "- Single line only.",
+    "- Use the same language as the user message.",
+    "- Keep it brief and useful for finding this conversation later.",
+    "- Do not answer the user's request.",
+    "- Do not mention tools unless the tool itself is the topic.",
+    "- No explanations, no markdown, no quotes.",
+].join("\n");
+export function createSessionTitleUpdater(options) {
+    let pending;
+    let inFlight = false;
+    const run = async (candidate) => {
+        const raw = await options.complete(buildTitleMessages(candidate.input), {
+            temperature: 0.3,
+            thinkingLevel: "off",
+        });
+        const title = cleanGeneratedTitle(raw);
+        if (!title)
+            return;
+        if (!isCandidateCurrent(options.sessionManager.getEntries(), candidate.userMessageId))
+            return;
+        if (options.sessionManager.getMetadata().title?.trim())
+            return;
+        options.sessionManager.updateMetadata({
+            title,
+            titleSource: "llm",
+            titleUpdatedAt: Date.now(),
+            titleUserMessageId: candidate.userMessageId,
+        });
+    };
+    return {
+        handlePersistedMessage(message) {
+            if (message.role === "user") {
+                if (pending || inFlight)
+                    return;
+                if (options.sessionManager.getMetadata().title?.trim())
+                    return;
+                if (currentUserMessageCount(options.sessionManager.getMessages()) !== 1)
+                    return;
+                const userEntryId = latestUserMessageEntryId(options.sessionManager.getEntries());
+                if (!userEntryId)
+                    return;
+                const input = titleInputFromUserContent(message.content);
+                if (!input)
+                    return;
+                pending = { input, userMessageId: userEntryId };
+                return;
+            }
+            if (message.role !== "assistant" || !pending || inFlight)
+                return;
+            const candidate = pending;
+            pending = undefined;
+            inFlight = true;
+            void run(candidate).catch(() => undefined).finally(() => {
+                inFlight = false;
+            });
+        },
+    };
+}
+export function cleanGeneratedTitle(raw) {
+    const withoutThinking = raw.replace(/<think>[\s\S]*?<\/think>/gi, "");
+    const withoutFences = withoutThinking.replace(/```[a-zA-Z0-9_-]*\s*/g, "").replace(/```/g, "");
+    const line = withoutFences
+        .split(/\r?\n/)
+        .map((item) => item.trim())
+        .find(Boolean);
+    if (!line)
+        return "";
+    const unquoted = line.replace(/^["'“”‘’]+|["'“”‘’]+$/g, "");
+    return truncateVisual(normalizeSingleLine(unquoted), TITLE_MAX_WIDTH);
+}
+export function deterministicTitleFromUserContent(content) {
+    const text = userContentText(content);
+    if (!text)
+        return "User message";
+    const charCount = text.length;
+    const lineCount = text.split(/\r?\n/).length;
+    if (charCount > LONG_PASTE_CHAR_THRESHOLD || lineCount > LONG_PASTE_LINE_THRESHOLD) {
+        return `[Pasted Content ${charCount} chars]`;
+    }
+    return truncateVisual(normalizeSingleLine(text), TITLE_MAX_WIDTH) || "User message";
+}
+function titleInputFromUserContent(content) {
+    const title = deterministicTitleFromUserContent(content);
+    const text = userContentText(content);
+    if (!text)
+        return title;
+    return normalizeSingleLine(text).slice(0, TITLE_INPUT_MAX_CHARS);
+}
+function userContentText(content) {
+    if (typeof content === "string")
+        return content;
+    const text = content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+    if (text.trim())
+        return text;
+    return content.some((part) => part.type === "image_url") ? "Image attachment" : "";
+}
+function buildTitleMessages(input) {
+    return [
+        { role: "system", content: TITLE_SYSTEM_PROMPT },
+        { role: "user", content: `Generate a title for this conversation:\n\n${input}` },
+    ];
+}
+function currentUserMessageCount(messages) {
+    return messages.filter((message) => message.role === "user").length;
+}
+function latestUserMessageEntryId(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.type === "user_message")
+            return entry.id;
+    }
+    return undefined;
+}
+function isCandidateCurrent(entries, userMessageId) {
+    let clearIndex = -1;
+    let userIndex = -1;
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry.type === "marker" && entry.kind === "conversation_clear")
+            clearIndex = i;
+        if (entry.id === userMessageId)
+            userIndex = i;
+    }
+    return userIndex > clearIndex;
+}

package/dist/session-types.d.ts

@@ -4,6 +4,11 @@ export interface SessionMetadata {
     thinkingLevel?: ThinkingLevel;
     reasoningEffort?: ThinkingLevel;
     cwd?: string;
+    title?: string;
+    titleSource?: "llm" | "manual";
+    titleUpdatedAt?: number;
+    titleUserMessageId?: string;
+    promptCacheKey?: string;
 }
 export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch" | "conversation_clear";
 interface BaseSessionLogEntry {

package/dist/session.d.ts

@@ -4,6 +4,17 @@
 import { type CompactOptions, type CompactResult } from "./context/compact.js";
 import type { Message, Todo } from "./types.js";
 import type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
+export interface SessionSummary {
+    file: string;
+    name: string;
+    cwd?: string;
+    cwdLabel: string;
+    title: string;
+    preview: string;
+    firstUserMessage: string;
+    messageCount: number;
+    mtime: number;
+}
 export type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
 export declare class SessionManager {
     private sessionFile;
@@ -13,11 +24,16 @@ export declare class SessionManager {
     static resume(cwd: string, sessionName?: string): SessionManager | undefined;
     static createFresh(cwd: string): SessionManager;
     static listSessions(cwd: string): string[];
+    static summarizeSessionsForCwd(cwd: string): SessionSummary[];
+    static listAllSessions(): SessionSummary[];
     private load;
     private persist;
     private rewrite;
     getMetadata(): SessionMetadata;
+    getOrCreatePromptCacheKey(): string;
     setMetadata(metadata: SessionMetadata): void;
+    updateMetadata(patch: Partial<SessionMetadata>): void;
+    clearTitleMetadata(): void;
     appendMessage(message: Message): void;
     appendCompaction(summary: string): void;
     appendMarker(kind: SessionMarkerKind, value: string): void;