@bubblebrain-ai/bubble 0.0.7 → 0.0.9

package/dist/provider-openai-codex.js

@@ -2,7 +2,10 @@ import { listBuiltinModels } from "./model-catalog.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const OPENAI_BETA_RESPONSES = "responses=experimental";
-const CODEX_CLIENT_VERSION = "0.121.0";
+// OpenAI gates new codex models server-side by client_version (each model carries a
+// `minimal_client_version`). Track a recent real Codex CLI release; override via env
+// when OpenAI lifts the gate again before we cut a new release.
+const CODEX_CLIENT_VERSION = process.env.BUBBLE_CODEX_CLIENT_VERSION?.trim() || "0.150.0";
 const MODEL_DISCOVERY_PATHS = [
     `/codex/models?client_version=${CODEX_CLIENT_VERSION}`,
     "/models",
@@ -205,9 +208,9 @@ export async function fetchOpenAICodexModels(options) {
         if (!response?.ok)
             continue;
         const payload = await response.json().catch(() => undefined);
-        const ids = extractModelIds(payload);
-        if (ids.length > 0) {
-            return sortCodexModelIds(ids);
+        const descriptors = extractCodexModelDescriptors(payload);
+        if (descriptors.length > 0) {
+            return sortCodexModelDescriptors(descriptors);
         }
     }
     return [];
@@ -361,18 +364,54 @@ function resolveRelativeUrl(baseURL, path) {
     const normalized = (baseURL.trim() || DEFAULT_CODEX_BASE_URL).replace(/\/+$/, "");
     return `${normalized}${path}`;
 }
-function extractModelIds(payload) {
-    const ids = [];
+const REASONING_EFFORTS = [
+    "off", "minimal", "low", "medium", "high", "xhigh", "max",
+];
+function extractCodexModelDescriptors(payload) {
+    const out = [];
     const seen = new Set();
-    const maybeAdd = (value) => {
-        if (typeof value !== "string")
-            return;
-        if (!/^gpt-|^codex-/i.test(value))
-            return;
-        if (seen.has(value))
-            return;
-        seen.add(value);
-        ids.push(value);
+    const isCodexId = (value) => typeof value === "string" && /^gpt-|^codex-/i.test(value);
+    const pickId = (record) => {
+        for (const key of ["slug", "id", "model_slug", "model"]) {
+            const v = record[key];
+            if (isCodexId(v))
+                return v;
+        }
+        return undefined;
+    };
+    const buildDescriptor = (record, id) => {
+        const desc = { id };
+        const displayName = record.display_name;
+        if (typeof displayName === "string" && displayName)
+            desc.displayName = displayName;
+        const ctx = record.context_window;
+        if (typeof ctx === "number" && ctx > 0)
+            desc.contextWindow = ctx;
+        const visibility = record.visibility;
+        if (typeof visibility === "string")
+            desc.visibility = visibility;
+        const minVer = record.minimal_client_version;
+        if (typeof minVer === "string")
+            desc.minimalClientVersion = minVer;
+        const levels = record.supported_reasoning_levels;
+        if (Array.isArray(levels)) {
+            const efforts = new Set(["off"]);
+            for (const level of levels) {
+                const effort = level?.effort;
+                if (typeof effort === "string" && REASONING_EFFORTS.includes(effort)) {
+                    efforts.add(effort);
+                }
+            }
+            desc.reasoningLevels = REASONING_EFFORTS.filter((e) => efforts.has(e));
+        }
+        const truncPolicy = record.truncation_policy;
+        if (truncPolicy && truncPolicy.mode === "tokens") {
+            const limit = truncPolicy.limit;
+            if (typeof limit === "number" && limit > 0) {
+                desc.toolOutputTokenLimit = limit;
+            }
+        }
+        return desc;
     };
     const visit = (value) => {
         if (Array.isArray(value)) {
@@ -380,32 +419,42 @@ function extractModelIds(payload) {
                 visit(item);
             return;
         }
-        if (!value || typeof value !== "object") {
-            maybeAdd(value);
+        if (!value || typeof value !== "object")
             return;
-        }
         const record = value;
-        maybeAdd(record.id);
-        maybeAdd(record.slug);
-        maybeAdd(record.model);
-        maybeAdd(record.model_slug);
+        const id = pickId(record);
+        if (id && !seen.has(id)) {
+            seen.add(id);
+            out.push(buildDescriptor(record, id));
+        }
         for (const child of Object.values(record)) {
-            if (child !== record.id && child !== record.slug && child !== record.model && child !== record.model_slug) {
+            if (child && typeof child === "object")
                 visit(child);
-            }
         }
     };
     visit(payload);
-    return ids;
+    return out;
+}
+// Extracts the family version from a codex slug (e.g. "gpt-5.5-codex" → 5005).
+// Used so models from a newer family float to the top even before the static
+// catalog knows about them.
+function parseCodexFamilyRank(id) {
+    const match = id.match(/(\d+)\.(\d+)/);
+    if (!match)
+        return 0;
+    return parseInt(match[1], 10) * 1000 + parseInt(match[2], 10);
 }
-function sortCodexModelIds(ids) {
-    const preferredModels = getOpenAICodexFallbackModels();
-    const preferred = new Map(preferredModels.map((id, index) => [id, index]));
-    return [...ids].sort((left, right) => {
-        const leftRank = preferred.get(left) ?? Number.MAX_SAFE_INTEGER;
-        const rightRank = preferred.get(right) ?? Number.MAX_SAFE_INTEGER;
+export function sortCodexModelDescriptors(descriptors) {
+    const preferred = new Map(getOpenAICodexFallbackModels().map((id, index) => [id, index]));
+    return [...descriptors].sort((left, right) => {
+        const leftFamily = parseCodexFamilyRank(left.id);
+        const rightFamily = parseCodexFamilyRank(right.id);
+        if (leftFamily !== rightFamily)
+            return rightFamily - leftFamily;
+        const leftRank = preferred.get(left.id) ?? Number.MAX_SAFE_INTEGER;
+        const rightRank = preferred.get(right.id) ?? Number.MAX_SAFE_INTEGER;
         if (leftRank !== rightRank)
             return leftRank - rightRank;
-        return left.localeCompare(right);
+        return left.id.localeCompare(right.id);
     });
 }

package/dist/provider-registry.js

@@ -4,7 +4,7 @@
  * Supports OpenAI-compatible providers with dynamic or static model lists.
  * Reads provider configuration from models.json first, then falls back to config.json.
  */
-import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, getBuiltinProvider, listBuiltinModels, } from "./model-catalog.js";
+import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, getBuiltinModel, getBuiltinProvider, listBuiltinModels, registerDynamicModelMetadata, } from "./model-catalog.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
 import { fetchOpenAICodexModels } from "./provider-openai-codex.js";
@@ -194,12 +194,28 @@ export class ProviderRegistry {
         }
         if (provider.id === "openai" && provider.authType === "oauth" && provider.apiKey) {
             try {
-                const models = await fetchOpenAICodexModels({
+                const descriptors = await fetchOpenAICodexModels({
                     baseURL: provider.baseURL,
                     accessToken: provider.apiKey,
                 });
-                if (models.length > 0) {
-                    return models.map((id) => ({ id, name: id, providerId: provider.id }));
+                const visible = descriptors.filter((d) => d.visibility !== "hide");
+                if (visible.length > 0) {
+                    for (const d of visible) {
+                        const catalogEntry = getBuiltinModel("openai-codex", d.id);
+                        registerDynamicModelMetadata({
+                            id: d.id,
+                            name: d.displayName || catalogEntry?.name || d.id,
+                            providerId: "openai-codex",
+                            reasoningLevels: d.reasoningLevels ?? catalogEntry?.reasoningLevels ?? ["off"],
+                            contextWindow: d.contextWindow ?? catalogEntry?.contextWindow,
+                            toolOutputTokenLimit: d.toolOutputTokenLimit ?? catalogEntry?.toolOutputTokenLimit,
+                        });
+                    }
+                    return visible.map((d) => ({
+                        id: d.id,
+                        name: d.displayName || d.id,
+                        providerId: provider.id,
+                    }));
                 }
             }
             catch {
@@ -232,8 +248,8 @@ export function decodeModel(value) {
 }
 /** Strip provider prefix for concise display. */
 export function displayModel(model) {
-    const { modelId } = decodeModel(model);
-    return modelId;
+    const { providerId, modelId } = decodeModel(model);
+    return providerId ? getBuiltinModel(providerId, modelId)?.name ?? modelId : modelId;
 }
 /** Normalize user input to provider:model format when possible. */
 export function normalizeModel(model, defaultProvider = "openai") {

package/dist/provider-transform.d.ts

@@ -3,7 +3,9 @@ export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingL
 export interface ProviderRequestConfig {
     effectiveThinkingLevel: ThinkingLevel;
     reasoningEffort?: ThinkingLevel;
-    reasoningContentEcho?: "tool_calls" | "all";
+    reasoningContentEcho?: "tool_calls" | "all" | "none";
+    parallelToolCalls?: boolean;
+    maxTokens?: number;
     extraBody?: Record<string, unknown>;
     omitTemperature?: boolean;
 }

package/dist/provider-transform.js

@@ -3,6 +3,13 @@ export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingL
 const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
 const KIMI_K25_FAMILY = new Set(["kimi-k2.5", "k2.6-code-preview", "kimi-k2.6"]);
 const KIMI_THINKING_FAMILY = new Set(["kimi-k2-thinking", "kimi-k2-thinking-turbo"]);
+const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
+function isFireworksKimi(providerId, modelId) {
+    const model = modelId.toLowerCase();
+    return providerId === "fireworks" && (model.includes("kimi")
+        || model.includes("k2p6")
+        || model === "k2.6");
+}
 export function resolveProviderRequestConfig(providerId, modelId, requestedLevel) {
     const supportedLevels = getAvailableThinkingLevels(providerId, modelId);
     const effectiveThinkingLevel = normalizeThinkingLevel(requestedLevel, supportedLevels);
@@ -11,6 +18,14 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
     if (providerId === "openai-codex") {
         return { effectiveThinkingLevel };
     }
+    if (isFireworksKimi(providerId, modelId)) {
+        return {
+            effectiveThinkingLevel,
+            reasoningContentEcho: "none",
+            parallelToolCalls: false,
+            maxTokens: KIMI_K26_DEFAULT_MAX_TOKENS,
+        };
+    }
     if (providerId === "deepseek" && (modelId === "deepseek-v4-flash" || modelId === "deepseek-v4-pro")) {
         return {
             effectiveThinkingLevel,

package/dist/provider.d.ts

@@ -4,10 +4,13 @@
  * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
  */
 import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel } from "./types.js";
-type ReasoningContentEcho = "tool_calls" | "all";
+type ReasoningContentEcho = "tool_calls" | "all" | "none";
 export type ToolArgsMergeMode = "delta" | "snapshot";
 export interface TranslateOpenAIStreamOptions {
     toolArgsMergeMode?: ToolArgsMergeMode;
+    reasoningMergeMode?: ToolArgsMergeMode;
+    debugProviderId?: string;
+    debugModelId?: string;
 }
 export declare function toChatCompletionsMessage(message: ProviderMessage, options?: {
     reasoningContentEcho?: ReasoningContentEcho;

package/dist/provider.js

@@ -8,6 +8,7 @@ import { appendFileSync } from "node:fs";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
+import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
 // Diagnostic logger for tool-args byte-loss investigation. Activate with
 //   BUBBLE_DEBUG_TOOL_ARGS=/path/to/log.jsonl   (any writable path)
 // Each line is a JSON record describing a transition. When debugging is off,
@@ -101,6 +102,12 @@ export function createProviderInstance(options) {
         if (requestConfig.extraBody) {
             Object.assign(body, requestConfig.extraBody);
         }
+        if (tools && tools.length > 0 && requestConfig.parallelToolCalls !== undefined) {
+            body.parallel_tool_calls = requestConfig.parallelToolCalls;
+        }
+        if (requestConfig.maxTokens !== undefined) {
+            body.max_tokens = requestConfig.maxTokens;
+        }
         if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
             body.reasoning = { enabled: true };
         }
@@ -109,6 +116,9 @@ export function createProviderInstance(options) {
         }));
         yield* translateOpenAIStream(stream, {
             toolArgsMergeMode: resolveToolArgsMergeMode(options.providerId || "", options.baseURL),
+            reasoningMergeMode: resolveReasoningMergeMode(options.providerId || "", options.baseURL),
+            debugProviderId: options.providerId || "",
+            debugModelId: chatOptions.model,
         });
         yield { type: "done" };
     }
@@ -126,6 +136,9 @@ export function createProviderInstance(options) {
         if (requestConfig.extraBody) {
             Object.assign(body, requestConfig.extraBody);
         }
+        if (requestConfig.maxTokens !== undefined) {
+            body.max_tokens = requestConfig.maxTokens;
+        }
         if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
             body.reasoning = { enabled: true };
         }
@@ -188,6 +201,13 @@ function resolveToolArgsMergeMode(providerId, baseURL) {
         return "snapshot";
     return "delta";
 }
+function resolveReasoningMergeMode(providerId, baseURL) {
+    const id = providerId.toLowerCase();
+    const url = baseURL.toLowerCase();
+    if (id === "fireworks" || url.includes("fireworks.ai"))
+        return "snapshot";
+    return "delta";
+}
 function extractBalancedJson(s, start) {
     if (s[start] !== "{")
         return null;
@@ -232,6 +252,9 @@ export async function* translateOpenAIStream(stream, options = {}) {
     const toolCalls = new Map();
     const textFilter = createProviderProtocolArtifactFilter();
     const toolArgsMergeMode = options.toolArgsMergeMode ?? "delta";
+    const reasoningMergeMode = options.reasoningMergeMode ?? "delta";
+    let reasoningBuffer = "";
+    let rawChunkSeq = 0;
     // DeepSeek (and some inference re-hosts) sometimes deliver reasoning twice:
     // once via a dedicated `reasoning_content` / `thinking` field, and again
     // embedded as `<think>...</think>` inside `delta.content`. Track whether we
@@ -277,8 +300,21 @@ export async function* translateOpenAIStream(stream, options = {}) {
         }
     }
     for await (const chunk of stream) {
+        rawChunkSeq += 1;
         const delta = chunk.choices?.[0]?.delta;
         const usage = chunk.usage;
+        const finishReason = chunk.choices?.[0]?.finish_reason;
+        debugReasoningStream({
+            stage: "provider_raw",
+            providerId: options.debugProviderId,
+            modelId: options.debugModelId,
+            chunkSeq: rawChunkSeq,
+            finishReason,
+            content: summarizeDebugText(delta?.content),
+            reasoning: summarizeDebugText(delta?.reasoning),
+            thinking: summarizeDebugText(delta?.thinking),
+            reasoningContent: summarizeDebugText(delta?.reasoning_content),
+        });
         if (usage) {
             yield {
                 type: "usage",
@@ -294,16 +330,53 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 },
             };
         }
-        const reasoning = delta?.reasoning ?? delta?.thinking ?? delta?.reasoning_content;
+        const reasoningField = delta?.reasoning !== undefined
+            ? "reasoning"
+            : delta?.thinking !== undefined
+                ? "thinking"
+                : delta?.reasoning_content !== undefined
+                    ? "reasoning_content"
+                    : undefined;
+        const reasoning = reasoningField ? delta[reasoningField] : undefined;
         if (reasoning) {
             hasDedicatedReasoningChannel = true;
-            yield { type: "reasoning_delta", content: reasoning };
+            const merged = mergeStreamingText(reasoningBuffer, reasoning, reasoningMergeMode);
+            reasoningBuffer = merged.args;
+            debugReasoningStream({
+                stage: "provider_emit",
+                providerId: options.debugProviderId,
+                modelId: options.debugModelId,
+                chunkSeq: rawChunkSeq,
+                source: reasoningField,
+                mergeMode: reasoningMergeMode,
+                suppressed: !merged.delta,
+                emitted: summarizeDebugText(merged.delta),
+                buffer: summarizeDebugText(reasoningBuffer),
+            });
+            if (merged.delta) {
+                yield { type: "reasoning_delta", content: merged.delta };
+            }
         }
         if (delta?.content) {
             const thinkMatch = delta.content.match(/<think>([\s\S]*?)<\/think>/);
             if (thinkMatch) {
                 if (thinkMatch[1] && !hasDedicatedReasoningChannel) {
-                    yield { type: "reasoning_delta", content: thinkMatch[1] };
+                    const merged = mergeStreamingText(reasoningBuffer, thinkMatch[1], reasoningMergeMode);
+                    reasoningBuffer = merged.args;
+                    debugReasoningStream({
+                        stage: "provider_emit",
+                        providerId: options.debugProviderId,
+                        modelId: options.debugModelId,
+                        chunkSeq: rawChunkSeq,
+                        source: "content_think",
+                        mergeMode: reasoningMergeMode,
+                        suppressed: !merged.delta,
+                        emitted: summarizeDebugText(merged.delta),
+                        buffer: summarizeDebugText(reasoningBuffer),
+                    });
+                    if (merged.delta) {
+                        yield { type: "reasoning_delta", content: merged.delta };
+                    }
                 }
                 const remaining = delta.content.replace(/<think>[\s\S]*?<\/think>/, "");
                 const cleaned = textFilter.push(remaining);
@@ -348,7 +421,6 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 }
             }
         }
-        const finishReason = chunk.choices?.[0]?.finish_reason;
         if (finishReason === "tool_calls") {
             yield* flushToolCalls();
         }
@@ -386,3 +458,16 @@ function mergeToolArgumentDelta(current, incoming, mode) {
     debugToolArgs({ stage: "merge", branch: mode === "delta" ? "delta-append" : "snapshot-fallback-concat", current, incoming, args: current + incoming, delta: incoming });
     return { args: current + incoming, delta: incoming };
 }
+function mergeStreamingText(current, incoming, mode) {
+    if (!current)
+        return { args: incoming, delta: incoming };
+    if (!incoming)
+        return { args: current, delta: "" };
+    if (mode === "snapshot") {
+        if (incoming === current)
+            return { args: current, delta: "" };
+        if (incoming.startsWith(current))
+            return { args: incoming, delta: incoming.slice(current.length) };
+    }
+    return { args: current + incoming, delta: incoming };
+}

package/dist/reasoning-debug.d.ts

@@ -0,0 +1,7 @@
+export interface DebugTextSummary {
+    length: number;
+    hash: string;
+    preview?: string;
+}
+export declare function summarizeDebugText(value: unknown): DebugTextSummary | undefined;
+export declare function debugReasoningStream(event: Record<string, unknown>): void;

package/dist/reasoning-debug.js

@@ -0,0 +1,30 @@
+import { createHash } from "node:crypto";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+const DEBUG_PATH = process.env.BUBBLE_DEBUG_REASONING_STREAM?.trim();
+const INCLUDE_PREVIEW = process.env.BUBBLE_DEBUG_REASONING_PREVIEW !== "0";
+const PREVIEW_CHARS = 180;
+let sequence = 0;
+export function summarizeDebugText(value) {
+    if (!DEBUG_PATH)
+        return undefined;
+    if (typeof value !== "string" || value.length === 0)
+        return undefined;
+    const hash = createHash("sha256").update(value).digest("hex").slice(0, 16);
+    const summary = { length: value.length, hash };
+    if (INCLUDE_PREVIEW) {
+        summary.preview = value.replace(/\s+/g, " ").slice(0, PREVIEW_CHARS);
+    }
+    return summary;
+}
+export function debugReasoningStream(event) {
+    if (!DEBUG_PATH)
+        return;
+    try {
+        mkdirSync(dirname(DEBUG_PATH), { recursive: true });
+        appendFileSync(DEBUG_PATH, JSON.stringify({ t: Date.now(), seq: ++sequence, ...event }) + "\n", "utf-8");
+    }
+    catch {
+        // Debug logging must never affect an agent run.
+    }
+}

package/dist/session-log.js

@@ -72,6 +72,9 @@ export class SessionLog {
     getTodos() {
         for (let i = this.entries.length - 1; i >= 0; i--) {
             const entry = this.entries[i];
+            if (entry.type === "marker" && entry.kind === "conversation_clear") {
+                return [];
+            }
             if (entry.type === "todos_snapshot") {
                 return entry.todos.map((todo) => ({ ...todo }));
             }
@@ -92,20 +95,28 @@ export class SessionLog {
     toMessages() {
         const messages = [];
         let latestSummaryIndex = -1;
+        let latestClearIndex = -1;
         for (let index = this.entries.length - 1; index >= 0; index--) {
             if (this.entries[index].type === "summary") {
                 latestSummaryIndex = index;
                 break;
             }
         }
-        if (latestSummaryIndex >= 0) {
+        for (let index = this.entries.length - 1; index >= 0; index--) {
+            const entry = this.entries[index];
+            if (entry.type === "marker" && entry.kind === "conversation_clear") {
+                latestClearIndex = index;
+                break;
+            }
+        }
+        if (latestSummaryIndex > latestClearIndex) {
             const summary = this.entries[latestSummaryIndex];
             messages.push({
                 role: "system",
                 content: `Previous conversation summary: ${summary.summary}`,
             });
         }
-        const startIndex = latestSummaryIndex >= 0 ? latestSummaryIndex + 1 : 0;
+        const startIndex = Math.max(latestSummaryIndex > latestClearIndex ? latestSummaryIndex + 1 : 0, latestClearIndex + 1);
         for (let index = startIndex; index < this.entries.length; index++) {
             const entry = this.entries[index];
             switch (entry.type) {

package/dist/session-types.d.ts

@@ -5,7 +5,7 @@ export interface SessionMetadata {
     reasoningEffort?: ThinkingLevel;
     cwd?: string;
 }
-export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch";
+export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch" | "conversation_clear";
 interface BaseSessionLogEntry {
     id: string;
     timestamp: number;

package/dist/slash-commands/commands.js

@@ -1,4 +1,5 @@
 import { UserConfig, maskKey } from "../config.js";
+import { formatContextUsage } from "../context/usage.js";
 import { formatDiagnostics } from "../lsp/index.js";
 import { normalizeNameForMCP } from "../mcp/name.js";
 import { parseRule } from "../permissions/rule.js";
@@ -70,6 +71,29 @@ function syncSystemPrompt(ctx, model) {
         memoryPrompt: buildMemoryPrompt(ctx.cwd),
     }));
 }
+function formatMcpContextStatus(ctx) {
+    const states = ctx.mcpManager?.getStates() ?? [];
+    const lines = ["MCP"];
+    if (!ctx.mcpManager || states.length === 0) {
+        lines.push("- No MCP servers configured for this session.");
+        lines.push("- Context impact: none.");
+        return lines.join("\n");
+    }
+    for (const state of states) {
+        if (state.status.kind === "connected") {
+            lines.push(`- ${state.name} (${state.scope}): connected · ${state.status.tools.length} deferred tool${state.status.tools.length === 1 ? "" : "s"} · ${state.status.prompts.length} prompt${state.status.prompts.length === 1 ? "" : "s"}`);
+            continue;
+        }
+        if (state.status.kind === "failed") {
+            lines.push(`- ${state.name} (${state.scope}): failed · ${state.status.error}`);
+            continue;
+        }
+        lines.push(`- ${state.name} (${state.scope}): ${state.status.kind}`);
+    }
+    lines.push("- Context impact: MCP tool schemas are deferred. The prompt pays only a small deferred-tool reminder until tool_search unlocks a tool; unlocked MCP schemas then count under Tools.");
+    lines.push("- MCP prompts are slash commands; they do not enter context until invoked.");
+    return lines.join("\n");
+}
 function switchToProviderModel(providerId, modelId, ctx, thinkingLevel) {
     const provider = ctx.registry.getConfigured().find((item) => item.id === providerId);
     if (!provider?.apiKey) {
@@ -270,6 +294,13 @@ const builtinSlashCommandEntries = [
             return handleMemoryCommand(args, ctx);
         },
     },
+    {
+        name: "context",
+        description: "Show current context window usage and breakdown",
+        async handler(args, ctx) {
+            return `${formatContextUsage(ctx.agent.getContextUsageSnapshot())}\n\n${formatMcpContextStatus(ctx)}`;
+        },
+    },
     {
         name: "quit",
         description: "Exit the application",
@@ -277,13 +308,40 @@ const builtinSlashCommandEntries = [
             ctx.exit();
         },
     },
+    {
+        name: "theme",
+        description: "Switch the color theme. Usage: /theme [auto|light|dark]",
+        async handler(args, ctx) {
+            if (!ctx.setThemeMode || !ctx.getThemeMode || !ctx.getResolvedTheme) {
+                return "Theme switching is only available inside the TUI.";
+            }
+            const arg = args.trim().toLowerCase();
+            if (!arg) {
+                const order = ["auto", "light", "dark"];
+                const current = ctx.getThemeMode();
+                const next = order[(order.indexOf(current) + 1) % order.length];
+                ctx.setThemeMode(next);
+                const resolved = next === "auto" ? ctx.getResolvedTheme() : next;
+                return `Theme: ${next}${next === "auto" ? ` (resolved to ${resolved})` : ""}`;
+            }
+            if (arg !== "auto" && arg !== "light" && arg !== "dark") {
+                return "Usage: /theme [auto|light|dark]";
+            }
+            ctx.setThemeMode(arg);
+            const resolved = arg === "auto" ? ctx.getResolvedTheme() : arg;
+            return `Theme set to ${arg}${arg === "auto" ? ` (resolved to ${resolved})` : ""}.`;
+        },
+    },
     {
         name: "clear",
         description: "Clear the current conversation history",
         async handler(args, ctx) {
+            ctx.agent.messages = ctx.agent.messages.filter((m) => m.role === "system" || m.role === "meta");
+            ctx.sessionManager?.appendMarker("conversation_clear", "");
+            if (ctx.agent.getTodos().length > 0) {
+                ctx.agent.setTodos([]);
+            }
             ctx.clearMessages();
-            ctx.agent.messages = ctx.agent.messages.filter((m) => m.role === "system");
-            return "Conversation cleared.";
         },
     },
     {

package/dist/slash-commands/types.d.ts

@@ -8,6 +8,7 @@ import type { SettingsManager } from "../permissions/settings.js";
 import type { McpManager } from "../mcp/manager.js";
 import type { LspService } from "../lsp/index.js";
 import type { MemoryScope } from "../memory/index.js";
+import type { ThemeMode } from "../config.js";
 export interface SlashCommandContext {
     agent: Agent;
     addMessage: (role: "user" | "assistant" | "error", content: string) => void;
@@ -27,6 +28,12 @@ export interface SlashCommandContext {
     runMemoryCompaction?: () => Promise<string>;
     runMemorySummary?: (scope?: MemoryScope) => Promise<string>;
     runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
+    /** Get the current theme mode (auto/light/dark) — undefined when running in non-TUI contexts. */
+    getThemeMode?: () => ThemeMode;
+    /** Get the resolved active theme (always light or dark) — undefined when running in non-TUI contexts. */
+    getResolvedTheme?: () => "light" | "dark";
+    /** Persist a new theme mode AND apply it to the running TUI. */
+    setThemeMode?: (mode: ThemeMode) => void;
 }
 /**
  * Return types for a slash command handler: