@bubblebrain-ai/bubble 0.0.17 → 0.0.18

package/dist/session-title.js

@@ -1,6 +1,5 @@
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
-const LONG_PASTE_CHAR_THRESHOLD = 1000;
-const LONG_PASTE_LINE_THRESHOLD = 20;
+import { createPastedContentMarker, shouldCollapsePastedContent } from "./tui/paste-placeholder.js";
 const TITLE_INPUT_MAX_CHARS = 4000;
 const TITLE_MAX_WIDTH = 80;
 const TITLE_SYSTEM_PROMPT = [
@@ -81,10 +80,8 @@ 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]`;
+    if (shouldCollapsePastedContent(text)) {
+        return createPastedContentMarker(text);
     }
     return truncateVisual(normalizeSingleLine(text), TITLE_MAX_WIDTH) || "User message";
 }

package/dist/slash-commands/commands.js

@@ -61,6 +61,9 @@ function persistSelectedModel(model, ctx) {
 }
 function syncSystemPrompt(ctx, model) {
     const { providerId, modelId } = decodeModel(model);
+    const toolPromptOptions = typeof ctx.agent.getSystemPromptToolOptions === "function"
+        ? ctx.agent.getSystemPromptToolOptions()
+        : {};
     ctx.agent.setSystemPrompt(buildSystemPrompt({
         agentName: "Bubble",
         configuredProvider: providerId,
@@ -68,6 +71,7 @@ function syncSystemPrompt(ctx, model) {
         configuredModelId: model,
         thinkingLevel: ctx.agent.thinking,
         workingDir: ctx.cwd,
+        ...toolPromptOptions,
         memoryPrompt: buildMemoryPrompt(ctx.cwd),
     }));
 }

package/dist/stats/usage.d.ts

@@ -20,6 +20,7 @@ export interface ModelUsageStats {
     completionTokens: number;
     promptCacheHitTokens: number;
     promptCacheMissTokens: number;
+    cacheCreationTokens: number;
     reasoningTokens: number;
     totalTokens: number;
     cost?: number;

package/dist/stats/usage.js

@@ -187,6 +187,7 @@ function addModelUsage(accumulator, model, message, usage) {
         completionTokens: 0,
         promptCacheHitTokens: 0,
         promptCacheMissTokens: 0,
+        cacheCreationTokens: 0,
         reasoningTokens: 0,
         totalTokens: 0,
     };
@@ -195,6 +196,7 @@ function addModelUsage(accumulator, model, message, usage) {
     existing.completionTokens += usage.completionTokens;
     existing.promptCacheHitTokens += usage.promptCacheHitTokens ?? 0;
     existing.promptCacheMissTokens += usage.promptCacheMissTokens ?? 0;
+    existing.cacheCreationTokens += usage.cacheCreationTokens ?? 0;
     existing.reasoningTokens += usage.reasoningTokens ?? 0;
     existing.totalTokens += tokenTotal(usage);
     if (providerId && modelId) {
@@ -284,6 +286,9 @@ function formatSummaryLines(stats, width) {
     if (favorite) {
         lines.push(`  Favorite model ${truncate(favorite, Math.max(12, width - 17))}`);
     }
+    const cacheSummary = formatCacheSummary(stats.models);
+    if (cacheSummary)
+        lines.push(`  ${cacheSummary}`);
     const trackedCostText = formatTrackedCosts(stats);
     if (trackedCostText)
         lines.push(`  Tracked cost ${trackedCostText}`);
@@ -293,6 +298,17 @@ function formatSummaryLines(stats, width) {
     }
     return lines;
 }
+function formatCacheSummary(models) {
+    const read = models.reduce((sum, model) => sum + model.promptCacheHitTokens, 0);
+    const create = models.reduce((sum, model) => sum + model.cacheCreationTokens, 0);
+    const missWithCreate = models.reduce((sum, model) => sum + model.promptCacheMissTokens, 0);
+    const miss = Math.max(0, missWithCreate - create);
+    const observed = read + create + miss;
+    if (observed === 0)
+        return undefined;
+    const hitRate = Math.round((read / observed) * 100);
+    return `Prompt cache ${formatCompactNumber(read)} read · ${formatCompactNumber(create)} create · ${formatCompactNumber(miss)} miss · ${hitRate}% hit`;
+}
 function aggregateCosts(models) {
     const totals = {};
     for (const model of models) {
@@ -355,15 +371,24 @@ function normalizeUsage(raw) {
     if (!raw || typeof raw !== "object")
         return undefined;
     const value = raw;
-    const promptTokens = numberValue(value.promptTokens) ?? numberValue(value.input_tokens);
+    const rawInputTokens = numberValue(value.input_tokens);
+    const cacheReadTokens = numberValue(value.promptCacheHitTokens) ?? numberValue(value.cache_read_input_tokens);
+    const cacheCreationTokens = numberValue(value.cacheCreationTokens) ?? numberValue(value.cache_creation_input_tokens);
+    const promptTokens = numberValue(value.promptTokens)
+        ?? (rawInputTokens !== undefined
+            ? rawInputTokens + (cacheReadTokens ?? 0) + (cacheCreationTokens ?? 0)
+            : undefined);
     const completionTokens = numberValue(value.completionTokens) ?? numberValue(value.output_tokens);
     if (promptTokens === undefined || completionTokens === undefined)
         return undefined;
     return {
         promptTokens,
         completionTokens,
-        promptCacheHitTokens: numberValue(value.promptCacheHitTokens) ?? numberValue(value.cache_read_input_tokens),
-        promptCacheMissTokens: numberValue(value.promptCacheMissTokens) ?? numberValue(value.cache_creation_input_tokens),
+        promptCacheHitTokens: cacheReadTokens,
+        promptCacheMissTokens: numberValue(value.promptCacheMissTokens)
+            ?? numberValue(value.cache_miss_input_tokens)
+            ?? (rawInputTokens !== undefined ? rawInputTokens + (cacheCreationTokens ?? 0) : undefined),
+        cacheCreationTokens,
         reasoningTokens: numberValue(value.reasoningTokens),
         totalTokens: numberValue(value.totalTokens) ?? numberValue(value.total_tokens),
     };

package/dist/tools/edit.js

@@ -13,12 +13,66 @@ import { applyEditsToContent, EditApplyError, formatEditMatchNotes } from "./edi
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { isWithinWorkspace } from "./file-state.js";
 import { resolveToolPath } from "./path-utils.js";
+function prepareEditArguments(input) {
+    if (!input || typeof input !== "object")
+        return input;
+    const args = { ...input };
+    if (typeof args.file_path === "string" && typeof args.path !== "string") {
+        args.path = args.file_path;
+    }
+    if (typeof args.edits === "string") {
+        try {
+            const parsed = JSON.parse(args.edits);
+            if (Array.isArray(parsed))
+                args.edits = parsed;
+        }
+        catch {
+            // Keep the original value so validation surfaces the problem.
+        }
+    }
+    if (Array.isArray(args.edits)) {
+        args.edits = args.edits.map((edit) => {
+            if (!edit || typeof edit !== "object")
+                return edit;
+            const normalized = { ...edit };
+            if (typeof normalized.oldText !== "string") {
+                normalized.oldText = firstString(edit.old_text, edit.oldString, edit.old_string);
+            }
+            if (typeof normalized.newText !== "string") {
+                normalized.newText = firstString(edit.new_text, edit.newString, edit.new_string);
+            }
+            return normalized;
+        });
+    }
+    if (!Array.isArray(args.edits)) {
+        const oldText = firstString(args.oldText, args.old_text, args.oldString, args.old_string);
+        const newText = firstString(args.newText, args.new_text, args.newString, args.new_string);
+        if (typeof oldText === "string" && typeof newText === "string") {
+            args.edits = [{ oldText, newText }];
+        }
+    }
+    return args;
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
 export function createEditTool(cwd, approval, lsp, fileState) {
     return {
         name: "edit",
         effect: "write_direct",
         requiresApproval: true,
-        description: "Apply targeted string replacements to a file. Prefer exact oldText copied from a recent read. The tool can tolerate common AI formatting mistakes such as extra leading/trailing whitespace, over-escaped sequences, line ending differences, indentation differences, trailing whitespace, Unicode punctuation/space, and blank-line differences when the target is unique.",
+        description: "Edit a single file using targeted text replacements. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
+        promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
+        promptGuidelines: [
+            "Use edit for precise changes; edits[].oldText should be copied from a recent read and must identify a unique target.",
+            "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls.",
+            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+            "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
+        ],
         parameters: {
             type: "object",
             properties: {
@@ -38,7 +92,27 @@ export function createEditTool(cwd, approval, lsp, fileState) {
             },
             required: ["path", "edits"],
         },
+        prepareArguments: prepareEditArguments,
         async execute(args) {
+            if (!Array.isArray(args.edits)) {
+                return {
+                    content: "Error: edit requires edits to be an array of { oldText, newText } replacements.",
+                    isError: true,
+                    status: "blocked",
+                    metadata: { kind: "edit", reason: "invalid_args" },
+                };
+            }
+            for (let index = 0; index < args.edits.length; index++) {
+                const edit = args.edits[index];
+                if (!edit || typeof edit !== "object" || typeof edit.oldText !== "string" || typeof edit.newText !== "string") {
+                    return {
+                        content: `Error: edit requires edits[${index}] to contain string oldText and newText fields.`,
+                        isError: true,
+                        status: "blocked",
+                        metadata: { kind: "edit", reason: "invalid_args", index },
+                    };
+                }
+            }
             const filePath = resolveToolPath(cwd, args.path);
             if (!isWithinWorkspace(cwd, filePath)) {
                 return {

package/dist/tools/glob.js

@@ -2,10 +2,10 @@
  * Glob tool - discover files by path pattern without shell access.
  */
 import { readdir, stat } from "node:fs/promises";
-import { relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import picomatch from "picomatch";
 import { isSensitivePath } from "./sensitive-paths.js";
-import { resolveToolPath } from "./path-utils.js";
+import { expandHomePath, resolveToolPath } from "./path-utils.js";
 const MAX_RESULTS = 100;
 const DEFAULT_IGNORES = new Set([
     ".git",
@@ -32,11 +32,16 @@ export function createGlobTool(cwd) {
             required: ["pattern"],
         },
         async execute(args, ctx) {
-            const root = resolveToolPath(cwd, typeof args.path === "string" && args.path.trim() ? args.path : ".");
-            const pattern = String(args.pattern || "").trim();
-            if (!pattern) {
+            const requestedRoot = resolveToolPath(cwd, typeof args.path === "string" && args.path.trim() ? args.path : ".");
+            const originalPattern = String(args.pattern || "").trim();
+            if (!originalPattern) {
                 return { content: "Error: glob pattern is required", isError: true, status: "command_error" };
             }
+            const normalized = normalizeGlobSearch(requestedRoot, originalPattern);
+            if (normalized.error) {
+                return normalized.error;
+            }
+            const { root, pattern, normalizedPattern } = normalized;
             if (isSensitivePath(root)) {
                 return {
                     content: `Error: Glob blocked for sensitive credential storage: ${root}`,
@@ -45,7 +50,9 @@ export function createGlobTool(cwd) {
                     metadata: {
                         kind: "security",
                         path: root,
-                        pattern,
+                        pattern: normalizedPattern,
+                        originalPattern,
+                        normalizedPattern,
                         reason: "Sensitive credential storage is not searchable from general-purpose tasks.",
                     },
                 };
@@ -74,11 +81,13 @@ export function createGlobTool(cwd) {
                     metadata: {
                         kind: "search",
                         path: root,
-                        pattern,
+                        pattern: normalizedPattern,
+                        originalPattern,
+                        normalizedPattern,
                         matches: 0,
                         truncated: false,
-                        searchSignature: `glob:${root}:${pattern}`,
-                        searchFamily: `glob:${pattern}`,
+                        searchSignature: `glob:${root}:${normalizedPattern}`,
+                        searchFamily: `glob:${normalizedPattern}`,
                         paths: [],
                     },
                 };
@@ -89,17 +98,70 @@ export function createGlobTool(cwd) {
                 metadata: {
                     kind: "search",
                     path: root,
-                    pattern,
+                    pattern: normalizedPattern,
+                    originalPattern,
+                    normalizedPattern,
                     matches: matches.length,
                     truncated: wasTruncated,
-                    searchSignature: `glob:${root}:${pattern}`,
-                    searchFamily: `glob:${pattern}`,
+                    searchSignature: `glob:${root}:${normalizedPattern}`,
+                    searchFamily: `glob:${normalizedPattern}`,
                     paths: absoluteMatches,
                 },
             };
         },
     };
 }
+function normalizeGlobSearch(requestedRoot, originalPattern) {
+    const expandedPattern = expandGlobPatternHome(originalPattern);
+    const scan = picomatch.scan(expandedPattern);
+    const prefix = scan.prefix ?? "";
+    if (!isAbsolute(scan.base)) {
+        if (escapesSearchRoot(scan.base)) {
+            return {
+                error: {
+                    content: `Error: Glob pattern must stay within the search path: ${originalPattern}`,
+                    isError: true,
+                    status: "command_error",
+                    metadata: {
+                        kind: "search",
+                        path: requestedRoot,
+                        pattern: originalPattern,
+                        originalPattern,
+                        normalizedPattern: originalPattern,
+                        reason: "pattern_outside_search_path",
+                    },
+                },
+            };
+        }
+        return { root: requestedRoot, pattern: originalPattern, normalizedPattern: originalPattern };
+    }
+    const absoluteBase = resolve(scan.base);
+    const patternRoot = scan.isGlob ? absoluteBase : dirname(absoluteBase);
+    const patternBody = scan.isGlob ? scan.glob : basename(absoluteBase);
+    const normalizedRoot = isWithinSearchRoot(requestedRoot, patternRoot) ? requestedRoot : patternRoot;
+    const relativeBase = toPosix(relative(normalizedRoot, patternRoot));
+    const normalizedBody = [relativeBase, patternBody].filter(Boolean).join("/");
+    const normalizedPattern = `${prefix}${normalizedBody}`;
+    return {
+        root: normalizedRoot,
+        pattern: normalizedPattern,
+        normalizedPattern,
+    };
+}
+function expandGlobPatternHome(pattern) {
+    if (pattern.startsWith("!")) {
+        return `!${expandHomePath(pattern.slice(1))}`;
+    }
+    return expandHomePath(pattern);
+}
+function escapesSearchRoot(base) {
+    const normalized = toPosix(base);
+    return normalized === ".." || normalized.startsWith("../");
+}
+function isWithinSearchRoot(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
 async function walk(root, dir, matcher, files, truncated, abortSignal) {
     if (abortSignal?.aborted || files.length >= MAX_RESULTS) {
         truncated.value = true;
@@ -115,6 +177,9 @@ async function walk(root, dir, matcher, files, truncated, abortSignal) {
             continue;
         }
         const absolute = resolve(dir, entry.name);
+        if (isSensitivePath(absolute)) {
+            continue;
+        }
         const rel = toPosix(relative(root, absolute));
         if (entry.isDirectory()) {
             await walk(root, absolute, matcher, files, truncated, abortSignal);

package/dist/tools/index.d.ts

@@ -6,7 +6,7 @@ export { createBashTool } from "./bash.js";
 export { createManagedServerTools } from "./server.js";
 export { createWriteTool } from "./write.js";
 export { createEditTool } from "./edit.js";
-export { createApplyPatchTool } from "./apply-patch.js";
+export { buildToolPromptOptions } from "./prompt-metadata.js";
 export { createGlobTool } from "./glob.js";
 export { createGrepTool } from "./grep.js";
 export { createLspTool } from "./lsp.js";

package/dist/tools/index.js

@@ -6,7 +6,7 @@ export { createBashTool } from "./bash.js";
 export { createManagedServerTools } from "./server.js";
 export { createWriteTool } from "./write.js";
 export { createEditTool } from "./edit.js";
-export { createApplyPatchTool } from "./apply-patch.js";
+export { buildToolPromptOptions } from "./prompt-metadata.js";
 export { createGlobTool } from "./glob.js";
 export { createGrepTool } from "./grep.js";
 export { createLspTool } from "./lsp.js";
@@ -23,7 +23,6 @@ export { createMemoryReadSummaryTool, createMemorySearchTool } from "./memory.js
 import { createBashTool } from "./bash.js";
 import { createManagedServerTools } from "./server.js";
 import { createEditTool } from "./edit.js";
-import { createApplyPatchTool } from "./apply-patch.js";
 import { createExitPlanModeTool } from "./exit-plan-mode.js";
 import { createGlobTool } from "./glob.js";
 import { createGrepTool } from "./grep.js";
@@ -51,7 +50,6 @@ export function createAllTools(cwd, skillRegistry, options = {}) {
         ...createManagedServerTools(cwd, approval),
         createWriteTool(cwd, {}, approval, lsp, fileState),
         createEditTool(cwd, approval, lsp, fileState),
-        createApplyPatchTool(cwd, approval, lsp, fileState),
         createGlobTool(cwd),
         createGrepTool(cwd),
         createLspTool(cwd, lsp, approval),

package/dist/tools/prompt-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { SystemPromptOptions } from "../system-prompt.js";
+import type { ToolRegistryEntry } from "../types.js";
+export declare function buildToolPromptOptions(tools: ToolRegistryEntry[]): Pick<SystemPromptOptions, "tools" | "toolSnippets" | "guidelines">;

package/dist/tools/prompt-metadata.js

@@ -0,0 +1,17 @@
+export function buildToolPromptOptions(tools) {
+    const toolSnippets = {};
+    const guidelines = [];
+    for (const tool of tools) {
+        if (tool.promptSnippet) {
+            toolSnippets[tool.name] = tool.promptSnippet;
+        }
+        for (const guideline of tool.promptGuidelines ?? []) {
+            guidelines.push(guideline);
+        }
+    }
+    return {
+        tools: tools.map((tool) => tool.name),
+        toolSnippets,
+        guidelines,
+    };
+}

package/dist/tools/write.js

@@ -9,12 +9,25 @@ import { formatDiagnosticBlocks } from "../lsp/index.js";
 import { isWithinWorkspace } from "./file-state.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToolPath } from "./path-utils.js";
+function prepareWriteArguments(input) {
+    if (!input || typeof input !== "object")
+        return input;
+    const args = { ...input };
+    if (typeof args.file_path === "string" && typeof args.path !== "string") {
+        args.path = args.file_path;
+    }
+    return args;
+}
 export function createWriteTool(cwd, _options = {}, approval, lsp, fileState) {
     return {
         name: "write",
         effect: "write_direct",
         requiresApproval: true,
         description: "Write content to a file. Creates parent directories as needed. If the file already exists, this replaces the full file; use edit for small targeted changes.",
+        promptSnippet: "Create new files or intentionally rewrite complete files",
+        promptGuidelines: [
+            "Use write only for new files, generated files, or intentional complete rewrites. Use edit for targeted changes to existing files.",
+        ],
         parameters: {
             type: "object",
             properties: {
@@ -23,6 +36,7 @@ export function createWriteTool(cwd, _options = {}, approval, lsp, fileState) {
             },
             required: ["path", "content"],
         },
+        prepareArguments: prepareWriteArguments,
         async execute(args) {
             const filePath = resolveToolPath(cwd, args.path);
             if (!isWithinWorkspace(cwd, filePath)) {

package/dist/tui/paste-placeholder.d.ts

@@ -0,0 +1,10 @@
+export declare const LONG_PASTE_CHAR_THRESHOLD = 1000;
+export declare const LONG_PASTE_LINE_THRESHOLD = 20;
+export interface PastedContentReference {
+    marker: string;
+    content: string;
+}
+export declare function countTextLines(text: string): number;
+export declare function shouldCollapsePastedContent(text: string): boolean;
+export declare function createPastedContentMarker(content: string, index?: number): string;
+export declare function expandPastedContentMarkers(displayText: string, references: PastedContentReference[]): string;

package/dist/tui/paste-placeholder.js

@@ -0,0 +1,45 @@
+export const LONG_PASTE_CHAR_THRESHOLD = 1000;
+export const LONG_PASTE_LINE_THRESHOLD = 20;
+export function countTextLines(text) {
+    return text.length === 0 ? 0 : text.split(/\r?\n/).length;
+}
+export function shouldCollapsePastedContent(text) {
+    if (text.length >= LONG_PASTE_CHAR_THRESHOLD)
+        return true;
+    return countTextLines(text) >= LONG_PASTE_LINE_THRESHOLD;
+}
+export function createPastedContentMarker(content, index = 1) {
+    const safeIndex = Math.max(1, Math.floor(index));
+    const lineCount = countTextLines(content);
+    const size = lineCount > 1
+        ? `${lineCount} ${lineCount === 1 ? "line" : "lines"}`
+        : `${content.length} ${content.length === 1 ? "char" : "chars"}`;
+    return `[Pasted text #${safeIndex} +${size}]`;
+}
+export function expandPastedContentMarkers(displayText, references) {
+    if (references.length === 0 || displayText.length === 0)
+        return displayText;
+    let expanded = "";
+    let index = 0;
+    const used = new Set();
+    while (index < displayText.length) {
+        let matched = -1;
+        for (let i = 0; i < references.length; i++) {
+            const ref = references[i];
+            if (!used.has(i) && displayText.startsWith(ref.marker, index)) {
+                matched = i;
+                break;
+            }
+        }
+        if (matched >= 0) {
+            const ref = references[matched];
+            expanded += ref.content;
+            index += ref.marker.length;
+            used.add(matched);
+            continue;
+        }
+        expanded += displayText[index];
+        index += 1;
+    }
+    return expanded;
+}

package/dist/tui/run.js

@@ -480,6 +480,7 @@ function OpenTuiApp(props) {
         completionTokens: 0,
         promptCacheHitTokens: 0,
         promptCacheMissTokens: 0,
+        cacheCreationTokens: 0,
         reasoningTokens: 0,
         turns: 0,
     });
@@ -602,6 +603,7 @@ function OpenTuiApp(props) {
     let sidebarGaugeText;
     let sidebarGaugeLabelText;
     let sidebarUsageText;
+    let sidebarCacheText;
     let sidebarReasoningText;
     let sidebarCostText;
     let sidebarLspSummaryText;
@@ -956,6 +958,7 @@ function OpenTuiApp(props) {
         setSidebarText(sidebarUsageText, context.turns > 0
             ? `${formatCompactNumber(context.promptTokens)} in · ${formatCompactNumber(context.completionTokens)} out`
             : "usage pending");
+        setSidebarText(sidebarCacheText, context.cacheText);
         setSidebarText(sidebarReasoningText, context.reasoningTokens > 0
             ? `${formatCompactNumber(context.reasoningTokens)} reasoning`
             : "");
@@ -5341,6 +5344,7 @@ function OpenTuiApp(props) {
                             promptCacheHitTokens: current.promptCacheHitTokens + (event.usage.promptCacheHitTokens ?? 0),
                             promptCacheMissTokens: current.promptCacheMissTokens + (event.usage.promptCacheMissTokens
                                 ?? (event.usage.promptCacheHitTokens === undefined ? event.usage.promptTokens : 0)),
+                            cacheCreationTokens: current.cacheCreationTokens + (event.usage.cacheCreationTokens ?? 0),
                             reasoningTokens: current.reasoningTokens + (event.usage.reasoningTokens ?? 0),
                             turns: current.turns + 1,
                         }));
@@ -6368,6 +6372,13 @@ function OpenTuiApp(props) {
                             : "usage pending";
                     },
                 }),
+                h("text", {
+                    fg: theme.textMuted,
+                    ref: (ref) => {
+                        sidebarCacheText = ref;
+                        ref.content = context.cacheText;
+                    },
+                }),
                 h("text", {
                     fg: theme.textMuted,
                     ref: (ref) => {
@@ -6573,16 +6584,28 @@ function OpenTuiApp(props) {
             completionTokens: usage.completionTokens,
             promptCacheHitTokens: usage.promptCacheHitTokens,
             promptCacheMissTokens: usage.promptCacheMissTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
             reasoningTokens: usage.reasoningTokens,
             totalTokens: usage.promptTokens + usage.completionTokens,
         };
         const cost = providerId && modelId ? calculateUsageCost(providerId, modelId, tokenUsage) : undefined;
+        const cacheReadTokens = usage.promptCacheHitTokens;
+        const cacheCreateTokens = usage.cacheCreationTokens;
+        const cacheMissTokens = Math.max(0, usage.promptCacheMissTokens - cacheCreateTokens);
+        const cacheObservedTokens = cacheReadTokens + cacheCreateTokens + cacheMissTokens;
+        const cacheHitRate = cacheObservedTokens > 0
+            ? Math.round((cacheReadTokens / cacheObservedTokens) * 100)
+            : 0;
+        const cacheText = cacheObservedTokens > 0
+            ? `cache ${formatCompactNumber(cacheReadTokens)} read · ${formatCompactNumber(cacheCreateTokens)} create · ${formatCompactNumber(cacheMissTokens)} miss · ${cacheHitRate}% hit`
+            : "";
         return {
             tokens: contextTokens,
             percent: contextPercent,
             remainingTokens,
             promptTokens: usage.promptTokens,
             completionTokens: usage.completionTokens,
+            cacheText,
             reasoningTokens: usage.reasoningTokens,
             turns: usage.turns,
             costText: cost ? `${formatCurrency(cost.cost, cost.currency)} spent${cost.estimated ? " est." : ""}` : "cost unavailable",

package/dist/tui-ink/app.js

@@ -501,6 +501,7 @@ export function App({ agent, args, sessionManager, createProvider, registry, ski
             thinkingLevel: overrides?.thinkingLevel ?? agent.thinking,
             mode: overrides?.mode ?? agent.mode,
             workingDir: args.cwd,
+            ...agent.getSystemPromptToolOptions(),
         }));
     }, [agent, args.cwd, safeRegistry, safeSkillRegistry]);
     useInput((input, key) => {
@@ -614,6 +615,7 @@ export function App({ agent, args, sessionManager, createProvider, registry, ski
                 configuredModelId: model,
                 thinkingLevel: agent.thinking,
                 workingDir: args.cwd,
+                ...agent.getSystemPromptToolOptions(),
             }));
             userConfig.pushRecentModel(model);
             setThinkingLevel(agent.thinking);

package/dist/tui-ink/input-box.d.ts

@@ -1,5 +1,6 @@
 import type { SkillRegistry } from "../skills/registry.js";
 import { type ImageAttachment } from "./image-paste.js";
+export { createPastedContentMarker, expandPastedContentMarkers, shouldCollapsePastedContent, type PastedContentReference, } from "../tui/paste-placeholder.js";
 export interface SubmitPayload {
     /** Fully-expanded text sent to the agent. */
     text: string;
@@ -19,10 +20,6 @@ interface InputBoxProps {
     terminalColumns: number;
     cwd: string;
 }
-export interface PastedContentReference {
-    marker: string;
-    content: string;
-}
 export declare function needsCursorRowCompensation(nextOutputHeight: number, viewportRows: number, previousOutputHeight: number | null): boolean;
 export declare function resolveCursorRowCompensation(input: {
     sameRenderedFrame: boolean;
@@ -58,8 +55,4 @@ export declare function insertNewlineAtCursor(text: string, cursor: number): {
     text: string;
     cursor: number;
 };
-export declare function shouldCollapsePastedContent(text: string): boolean;
-export declare function createPastedContentMarker(content: string): string;
-export declare function expandPastedContentMarkers(displayText: string, references: PastedContentReference[]): string;
 export declare function InputBox({ onSubmit, onPasteNotice, disabled, cursorResetEpoch, draftText, draftEpoch, onDraftApplied, skillRegistry, terminalColumns, cwd, }: InputBoxProps): import("react/jsx-runtime").JSX.Element;
-export {};