@bubblebrain-ai/bubble 0.0.11 → 0.0.12

package/dist/agent.js

@@ -1061,7 +1061,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 +1256,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";
@@ -61,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) {
@@ -216,6 +225,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 +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)
@@ -289,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);
             }
@@ -318,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,

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

@@ -9,6 +9,8 @@ export interface SessionSummary {
     name: string;
     cwd?: string;
     cwdLabel: string;
+    title: string;
+    preview: string;
     firstUserMessage: string;
     messageCount: number;
     mtime: number;
@@ -28,7 +30,10 @@ export declare class SessionManager {
     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;