@bubblebrain-ai/bubble 0.0.59 → 0.0.60

package/dist/tools/edit-apply.js

@@ -21,38 +21,36 @@ function stripBom(content) {
 function normalizeToLF(text) {
     return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
-function unescapeOverEscaped(text) {
-    return text
-        .replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
-        .replace(/\\n/g, "\n")
-        .replace(/\\t/g, "\t")
-        .replace(/\\r/g, "\r")
-        .replace(/\\f/g, "\f")
-        .replace(/\\b/g, "\b")
-        .replace(/\\v/g, "\v")
-        .replace(/\\"/g, '"')
-        .replace(/\\\\/g, "\\");
-}
-function addTextCandidate(candidates, seen, text, mode) {
-    if (text.length === 0 || seen.has(text))
-        return;
-    seen.add(text);
-    candidates.push({ text, mode });
-}
-function generateTextCandidates(oldText) {
-    const candidates = [];
-    const seen = new Set();
-    const trimmed = oldText.trim();
-    const unescaped = normalizeToLF(unescapeOverEscaped(oldText));
-    const unescapedTrimmed = normalizeToLF(unescapeOverEscaped(trimmed));
-    addTextCandidate(candidates, seen, oldText, "exact");
-    addTextCandidate(candidates, seen, trimmed, "trimmed");
-    addTextCandidate(candidates, seen, unescaped, "unescaped");
-    addTextCandidate(candidates, seen, unescapedTrimmed, "unescaped");
-    return candidates;
-}
-function restoreLineEndings(text, lineEnding) {
-    return lineEnding === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+function buildOriginalOffsets(text) {
+    const offsets = [];
+    for (let i = 0; i < text.length; i++) {
+        offsets.push(i);
+        if (text[i] === "\r" && text[i + 1] === "\n")
+            i++;
+    }
+    offsets.push(text.length);
+    return offsets;
+}
+function lineEndingAt(text, offset, fallback) {
+    const after = text.slice(offset).match(/\r\n|\r|\n/);
+    if (after)
+        return after[0];
+    const before = text.slice(0, offset).match(/(\r\n|\r|\n)[^\r\n]*$/);
+    return before ? before[1] : fallback;
+}
+// Splices replacements into the original text so untouched lines keep their own
+// terminators; inserted text uses the terminator of the line being edited.
+function spliceOriginal(text, matches, edits, fallbackEnding) {
+    const offsets = buildOriginalOffsets(text);
+    let out = "";
+    let cursor = 0;
+    for (const match of [...matches].sort((a, b) => a.start - b.start)) {
+        const start = offsets[match.start];
+        const ending = lineEndingAt(text, start, fallbackEnding);
+        out += text.slice(cursor, start) + edits[match.editIndex].newText.replace(/\n/g, ending);
+        cursor = offsets[match.end];
+    }
+    return out + text.slice(cursor);
 }
 function normalizeLineForMatch(line) {
     return line
@@ -63,9 +61,6 @@ function normalizeLineForMatch(line) {
         .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
         .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
 }
-function normalizeLeadingWhitespaceForMatch(line) {
-    return normalizeLineForMatch(line).replace(/^\s+/, " ");
-}
 function findAllOccurrences(content, needle) {
     const indexes = [];
     if (needle.length === 0)
@@ -104,130 +99,6 @@ function normalizedOldNonBlankLines(oldText) {
         .map((line) => normalizeLineForMatch(line.text))
         .filter((line) => line.trim().length > 0);
 }
-function singleNonBlankOldLine(oldText) {
-    const lines = normalizedOldNonBlankLines(oldText);
-    return lines.length === 1 ? lines[0] : undefined;
-}
-function findNormalizedLineMatches(content, oldText) {
-    const contentLines = splitLines(content);
-    const searchable = nonBlankLines(contentLines);
-    const oldLines = normalizedOldNonBlankLines(oldText);
-    if (oldLines.length === 0)
-        return [];
-    const matches = [];
-    for (let i = 0; i <= searchable.length - oldLines.length; i++) {
-        let matched = true;
-        for (let j = 0; j < oldLines.length; j++) {
-            if (searchable[i + j].normalized !== oldLines[j]) {
-                matched = false;
-                break;
-            }
-        }
-        if (matched) {
-            const first = contentLines[searchable[i].lineIndex];
-            const last = contentLines[searchable[i + oldLines.length - 1].lineIndex];
-            matches.push({ start: first.start, end: last.endNoNewline });
-        }
-    }
-    return matches;
-}
-function findSmartLineMatches(content, oldText) {
-    const contentLines = splitLines(content);
-    const oldLines = splitLines(oldText).map((line) => normalizeLeadingWhitespaceForMatch(line.text));
-    if (oldLines.length === 0 || oldLines.every((line) => line.length === 0))
-        return [];
-    const matches = [];
-    for (let i = 0; i <= contentLines.length - oldLines.length; i++) {
-        let matched = true;
-        for (let j = 0; j < oldLines.length; j++) {
-            const actual = normalizeLeadingWhitespaceForMatch(contentLines[i + j].text);
-            if (actual !== oldLines[j]) {
-                matched = false;
-                break;
-            }
-        }
-        if (matched) {
-            const first = contentLines[i];
-            const last = contentLines[i + oldLines.length - 1];
-            matches.push({ start: first.start, end: last.endNoNewline });
-        }
-    }
-    return matches;
-}
-function splitMarkdownTableCells(line) {
-    const normalized = normalizeLineForMatch(line).trim();
-    if (!normalized.startsWith("|") || !normalized.endsWith("|"))
-        return undefined;
-    const parts = [];
-    let current = "";
-    let escaped = false;
-    for (const char of normalized) {
-        if (escaped) {
-            current += char;
-            escaped = false;
-            continue;
-        }
-        if (char === "\\") {
-            current += char;
-            escaped = true;
-            continue;
-        }
-        if (char === "|") {
-            parts.push(current);
-            current = "";
-            continue;
-        }
-        current += char;
-    }
-    parts.push(current);
-    if (parts.length < 4 || parts[0] !== "" || parts[parts.length - 1] !== "")
-        return undefined;
-    const cells = parts.slice(1, -1).map((cell) => cell.trim());
-    return cells.length >= 2 ? cells : undefined;
-}
-function sameCells(a, b) {
-    return a.length === b.length && a.every((cell, index) => cell === b[index]);
-}
-function findMarkdownTableMatches(content, oldText) {
-    const oldLine = singleNonBlankOldLine(oldText);
-    if (!oldLine)
-        return [];
-    const oldCells = splitMarkdownTableCells(oldLine);
-    if (!oldCells)
-        return [];
-    const matches = [];
-    for (const line of splitLines(content)) {
-        const cells = splitMarkdownTableCells(line.text);
-        if (cells && sameCells(cells, oldCells)) {
-            matches.push({ start: line.start, end: line.endNoNewline });
-        }
-    }
-    return matches;
-}
-function collapseInlineWhitespace(text) {
-    return normalizeLineForMatch(text).trim().replace(/[ \t]+/g, " ");
-}
-function isDocumentLikePath(path) {
-    return !!path && /\.(?:md|mdx|markdown|txt|rst|adoc)$/i.test(path);
-}
-function findSingleLineWhitespaceMatches(content, oldText, options) {
-    if (!isDocumentLikePath(options?.path))
-        return [];
-    const oldLine = singleNonBlankOldLine(oldText);
-    if (!oldLine)
-        return [];
-    const normalizedOld = collapseInlineWhitespace(oldLine);
-    if (normalizedOld.length === 0)
-        return [];
-    const matches = [];
-    for (const line of splitLines(content)) {
-        const collapsed = collapseInlineWhitespace(line.text);
-        if (collapsed === normalizedOld && line.text !== oldLine) {
-            matches.push({ start: line.start, end: line.endNoNewline });
-        }
-    }
-    return matches;
-}
 function summarizeOldText(oldText) {
     const firstLine = normalizeToLF(oldText).split("\n").find((line) => line.trim().length > 0) ?? oldText;
     return firstLine.length > 80 ? `${firstLine.slice(0, 80)}...` : firstLine;
@@ -326,88 +197,18 @@ function matchEdit(content, edit, index, total, options) {
         ].join("\n"));
     }
     const oldText = normalizeToLF(edit.oldText);
-    const candidates = generateTextCandidates(oldText);
-    for (const candidate of candidates) {
-        const exact = findAllOccurrences(content, candidate.text);
-        if (exact.length === 1) {
-            return { editIndex: index, mode: candidate.mode, start: exact[0], end: exact[0] + candidate.text.length };
-        }
-        if (exact.length > 1) {
-            const recovery = [
-                "",
-                "Extend oldText with more surrounding context (the lines immediately before/after) until it uniquely identifies the intended span.",
-            ].join("\n");
-            const duplicateReason = candidate.mode === "exact"
-                ? `appears ${exact.length} times in file`
-                : `matched ${exact.length} times after ${candidate.mode} matching`;
-            throw new EditApplyError(total === 1
-                ? `Error: oldText ${duplicateReason}. Must be unique: "${summarizeOldText(oldText)}"${recovery}`
-                : `Error: edits[${index}].oldText ${duplicateReason}. Must be unique: "${summarizeOldText(oldText)}"${recovery}`);
-        }
-    }
-    for (const candidate of candidates) {
-        const normalizedLineMatches = findNormalizedLineMatches(content, candidate.text);
-        if (normalizedLineMatches.length === 1) {
-            return {
-                editIndex: index,
-                mode: candidate.mode === "exact" ? "normalized-line" : candidate.mode,
-                start: normalizedLineMatches[0].start,
-                end: normalizedLineMatches[0].end,
-            };
-        }
-        if (normalizedLineMatches.length > 1) {
-            throw new EditApplyError(total === 1
-                ? `Error: oldText matched ${normalizedLineMatches.length} normalized line blocks in file. Provide more surrounding context.`
-                : `Error: edits[${index}].oldText matched ${normalizedLineMatches.length} normalized line blocks in file. Provide more surrounding context.`);
-        }
-    }
-    for (const candidate of candidates) {
-        const markdownTableMatches = findMarkdownTableMatches(content, candidate.text);
-        if (markdownTableMatches.length === 1) {
-            return {
-                editIndex: index,
-                mode: "markdown-table",
-                start: markdownTableMatches[0].start,
-                end: markdownTableMatches[0].end,
-            };
-        }
-        if (markdownTableMatches.length > 1) {
-            throw new EditApplyError(total === 1
-                ? `Error: oldText matched ${markdownTableMatches.length} markdown table rows in file. Provide more surrounding context.`
-                : `Error: edits[${index}].oldText matched ${markdownTableMatches.length} markdown table rows in file. Provide more surrounding context.`);
-        }
-    }
-    for (const candidate of candidates) {
-        const whitespaceMatches = findSingleLineWhitespaceMatches(content, candidate.text, options);
-        if (whitespaceMatches.length === 1) {
-            return {
-                editIndex: index,
-                mode: "single-line-whitespace",
-                start: whitespaceMatches[0].start,
-                end: whitespaceMatches[0].end,
-            };
-        }
-        if (whitespaceMatches.length > 1) {
-            throw new EditApplyError(total === 1
-                ? `Error: oldText matched ${whitespaceMatches.length} whitespace-normalized lines in file. Provide more surrounding context.`
-                : `Error: edits[${index}].oldText matched ${whitespaceMatches.length} whitespace-normalized lines in file. Provide more surrounding context.`);
-        }
+    const occurrences = findAllOccurrences(content, oldText);
+    if (occurrences.length === 1) {
+        return { editIndex: index, start: occurrences[0], end: occurrences[0] + oldText.length };
     }
-    for (const candidate of candidates) {
-        const smartLineMatches = findSmartLineMatches(content, candidate.text);
-        if (smartLineMatches.length === 1) {
-            return {
-                editIndex: index,
-                mode: "smart-line",
-                start: smartLineMatches[0].start,
-                end: smartLineMatches[0].end,
-            };
-        }
-        if (smartLineMatches.length > 1) {
-            throw new EditApplyError(total === 1
-                ? `Error: oldText matched ${smartLineMatches.length} indentation-normalized line blocks in file. Provide more surrounding context.`
-                : `Error: edits[${index}].oldText matched ${smartLineMatches.length} indentation-normalized line blocks in file. Provide more surrounding context.`);
-        }
+    if (occurrences.length > 1) {
+        const recovery = [
+            "",
+            "Extend oldText with more surrounding context (the lines immediately before/after) until it uniquely identifies the intended span.",
+        ].join("\n");
+        throw new EditApplyError(total === 1
+            ? `Error: oldText appears ${occurrences.length} times in file. Must be unique: "${summarizeOldText(oldText)}"${recovery}`
+            : `Error: edits[${index}].oldText appears ${occurrences.length} times in file. Must be unique: "${summarizeOldText(oldText)}"${recovery}`);
     }
     const hint = findBestLineHint(content, oldText);
     const hintSuffix = hint ? `\n${formatBestLineHint(content, hint, options)}` : "";
@@ -439,9 +240,10 @@ export function applyEditsToContent(rawContent, edits, options) {
     const { bom, text } = stripBom(rawContent);
     const lineEnding = detectLineEnding(text);
     const normalizedOriginal = normalizeToLF(text);
+    const dropCopiedBom = (value) => (bom ? stripBom(value).text : value);
     const normalizedEdits = edits.map((edit) => ({
-        oldText: normalizeToLF(edit.oldText),
-        newText: normalizeToLF(edit.newText),
+        oldText: normalizeToLF(dropCopiedBom(edit.oldText)),
+        newText: normalizeToLF(dropCopiedBom(edit.newText)),
     }));
     const matches = normalizedEdits.map((edit, index) => matchEdit(normalizedOriginal, edit, index, normalizedEdits.length, options));
     assertNoOverlaps(matches);
@@ -462,7 +264,7 @@ export function applyEditsToContent(rawContent, edits, options) {
         ].join("\n"));
     }
     return {
-        content: bom + restoreLineEndings(normalizedNext, lineEnding),
+        content: bom + spliceOriginal(text, matches, normalizedEdits, lineEnding),
         normalizedOriginal,
         normalizedNext,
         bom,
@@ -470,9 +272,3 @@ export function applyEditsToContent(rawContent, edits, options) {
         matches,
     };
 }
-export function formatEditMatchNotes(matches) {
-    const normalizedCount = matches.filter((match) => match.mode !== "exact").length;
-    if (normalizedCount === 0)
-        return "";
-    return `\n\nNote: ${normalizedCount} edit${normalizedCount === 1 ? "" : "s"} applied using normalized line matching for whitespace/formatting differences.`;
-}

package/dist/tools/edit.js

@@ -9,7 +9,7 @@ import { createTwoFilesPatch } from "diff";
 import { gateToolAction } from "../approval/tool-helper.js";
 import { countUnifiedDiffChanges } from "../diff-stats.js";
 import { formatDiagnosticBlocks } from "../lsp/index.js";
-import { applyEditsToContent, EditApplyError, formatEditMatchNotes } from "./edit-apply.js";
+import { applyEditsToContent, EditApplyError } from "./edit-apply.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { isWithinWorkspace } from "./file-state.js";
 import { resolveToolPath } from "./path-utils.js";
@@ -65,7 +65,7 @@ export function createEditTool(cwd, approval, lsp, fileState, checkpoints) {
         name: "edit",
         effect: "write_direct",
         requiresApproval: true,
-        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 overlap or one replacement is nested inside another, merge them into one edit. Do not include large unchanged regions just to connect distant changes.",
+        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 overlap or one replacement is nested inside another, merge them into one edit. Do not include large unchanged regions just to connect distant changes. Matching is exact; a UTF-8 BOM and CRLF line endings are handled automatically and preserved, so write oldText/newText with plain \\n line breaks.",
         promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
         promptGuidelines: [
             "Use edit for precise changes; each edits[].oldText must be copied verbatim from a fresh read of the current exact target block and must identify a unique target. Do not reconstruct oldText from memory, stale reads, or similar code elsewhere.",
@@ -173,7 +173,7 @@ export function createEditTool(cwd, approval, lsp, fileState, checkpoints) {
                 await checkpoints?.()?.captureBefore(filePath, original);
                 await writeFile(filePath, applied.content, "utf-8");
                 await fileState?.observe(filePath, "edit", applied.content).catch(() => undefined);
-                let output = `Edited ${filePath}${formatEditMatchNotes(applied.matches)}\n\nDiff:\n${diff}`;
+                let output = `Edited ${filePath}\n\nDiff:\n${diff}`;
                 if (lsp) {
                     try {
                         await lsp.touchFile(filePath, "document");

package/dist/tools/grep.js

@@ -113,6 +113,18 @@ function executeBoundedGrep(options) {
         });
         const decoder = new StringDecoder("utf8");
         const matches = [];
+        // The root check alone is not enough: ripgrep searches inside an explicit
+        // hidden root, so `path: ~/.aws` would reach ~/.aws/credentials. Every
+        // matched file gets the same check the read tool applies (cached per file).
+        const sensitiveByPath = new Map();
+        const isSensitiveMatch = (absolutePath) => {
+            let sensitive = sensitiveByPath.get(absolutePath);
+            if (sensitive === undefined) {
+                sensitive = isSensitivePath(absolutePath);
+                sensitiveByPath.set(absolutePath, sensitive);
+            }
+            return sensitive;
+        };
         let stdoutBuffer = "";
         let stdoutBytes = 0;
         let stderrBytes = 0;
@@ -142,6 +154,13 @@ function executeBoundedGrep(options) {
                 if (event.type !== "match")
                     return;
                 const rawPath = decodeRgField(event.data?.path);
+                // A path that is not valid UTF-8 cannot be checked (or read back by
+                // the model), so its matches are dropped rather than shown unchecked.
+                if (event.data?.path && !rawPath)
+                    return;
+                const absolutePath = rawPath ? resolvePath(options.cwd, rawPath) : undefined;
+                if (absolutePath && isSensitiveMatch(absolutePath))
+                    return;
                 const lineNumber = event.data?.line_number;
                 const rawText = decodeRgField(event.data?.lines, "[non-UTF-8 match bytes omitted]") ?? "";
                 const displayPath = rawPath || "<non-UTF-8 path>";
@@ -149,7 +168,7 @@ function executeBoundedGrep(options) {
                 const rendered = truncateCodePoints(`${displayPath}:${typeof lineNumber === "number" ? lineNumber : "?"}: ${normalizedText}`, MAX_RENDERED_LINE_CODE_POINTS);
                 matches.push({
                     rendered,
-                    ...(rawPath ? { absolutePath: resolvePath(options.cwd, rawPath) } : {}),
+                    ...(absolutePath ? { absolutePath } : {}),
                 });
                 // We stop at N rather than pretending we proved there are N+1 matches.
                 // The notice says "limit reached / may be incomplete", which is honest

package/dist/tools/skill.d.ts

@@ -3,3 +3,5 @@ import type { SkillRegistry } from "../skills/registry.js";
 import type { ToolRegistryEntry } from "../types.js";
 export declare function formatLoadedSkill(skill: SkillRecord): string;
 export declare function createSkillTool(registry: SkillRegistry): ToolRegistryEntry;
+/** Up to three known names closest to a mistyped one (substring first, then edit distance). */
+export declare function closestSkillNames(name: string, names: string[]): string[];

package/dist/tools/skill.js

@@ -22,7 +22,7 @@ export function createSkillTool(registry) {
         name: "skill",
         readOnly: true,
         effect: "read",
-        description: "Load a named skill on demand. Use this when a task clearly matches one of the available skills.",
+        description: "Load a skill by its exact name, as listed in the Skills section of the system prompt. Returns the skill's instructions; follow them for the task.",
         parameters: {
             type: "object",
             properties: {
@@ -38,8 +38,11 @@ export function createSkillTool(registry) {
             }
             const skill = registry.get(name);
             if (!skill) {
+                const close = closestSkillNames(name, registry.summaries().map((s) => s.name));
                 return {
-                    content: `Error: Unknown skill "${name}". Use skill_search to find available skills, then retry with the exact skill name.`,
+                    content: `Error: Unknown skill "${name}".` +
+                        (close.length ? ` Did you mean: ${close.join(", ")}?` : "") +
+                        " Use the exact name from the Skills section.",
                     isError: true,
                 };
             }
@@ -47,3 +50,32 @@ export function createSkillTool(registry) {
         },
     };
 }
+/** Up to three known names closest to a mistyped one (substring first, then edit distance). */
+export function closestSkillNames(name, names) {
+    const target = name.toLowerCase();
+    const scored = names.map((candidate) => {
+        const lower = candidate.toLowerCase();
+        // Substring matches only for real fragments; a 1–2 letter typo would match everything.
+        const contains = target.length >= 3 && (lower.includes(target) || target.includes(lower));
+        return { candidate, score: contains ? 0 : editDistance(target, lower) };
+    });
+    const limit = Math.max(2, Math.floor(target.length / 3));
+    return scored
+        .filter((s) => s.score <= limit)
+        .sort((a, b) => a.score - b.score || a.candidate.localeCompare(b.candidate))
+        .slice(0, 3)
+        .map((s) => s.candidate);
+}
+function editDistance(a, b) {
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let prev = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cur = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+            prev = cur;
+        }
+    }
+    return row[b.length];
+}

package/dist/tui/app.js

@@ -33,6 +33,7 @@ import { SkillsPanelComponent } from "./components/skills-panel.js";
 import { SessionPickerComponent } from "./components/session-picker.js";
 import { ComposerImagePreviewComponent, ImageViewerComponent } from "./components/image-preview.js";
 import { registry as slashRegistry } from "../slash-commands/index.js";
+import { syncSystemPrompt } from "../slash-commands/commands.js";
 import { collectUsageStatsBundle } from "../stats/usage.js";
 import { ComposerController, } from "./controller/composer-controller.js";
 import { OverlayRequestController } from "./controller/overlay-controller.js";
@@ -208,6 +209,7 @@ export class PiTuiApp {
             groups: this.options.controller.getSubagentGroups?.() ?? [],
             workflows: this.options.controller.getWorkflows?.() ?? [],
             tasks: this.options.controller.getBackgroundTasks?.() ?? [],
+            turnStartedAt: this.options.controller.getTurnStartedAt?.(),
         }), () => this.tui.terminal.rows, {
             // Pane navigation only changes local presentation state. Reprojecting
             // the live trace/Markdown here is both unnecessary and expensive.
@@ -853,8 +855,12 @@ export class PiTuiApp {
             getTerminalRows: () => this.tui.terminal.rows,
             onClose: () => handle?.hide(),
             onRender: () => this.renderSnapshot(),
+            getCatalogChars: () => this.options.agent.getSkillCatalogChars?.(),
             onSkillsChanged: () => {
                 this.options.agent.setSkillSummaries(skillRegistry.summaries());
+                // The Skills catalog lives in the system prompt; rebuild it so the next turn sees the change.
+                const ctx = this.buildSlashContext();
+                syncSystemPrompt(ctx, ctx.agent.model ?? "");
                 this.editor.refreshAutocomplete();
                 this.renderSnapshot();
             },

package/dist/tui/components/skills-panel.d.ts

@@ -6,6 +6,8 @@ export interface SkillsPanelComponentOptions {
     onClose(): void;
     onRender(): void;
     onSkillsChanged(): void;
+    /** Catalog budget in characters (the agent's setting); undefined uses the default. */
+    getCatalogChars?(): number | undefined;
     theme?: Theme;
 }
 /** Grok-style centered Skill browser/manager opened by /skills. */
@@ -37,6 +39,8 @@ export declare class SkillsPanelComponent implements Component, Focusable {
     handleMouse(event: TuiMouseEvent): boolean;
     invalidate(): void;
     private frameLine;
+    /** How much of the always-present catalog the enabled skills use, so users know when to prune. */
+    private catalogSummary;
     private renderSearch;
     private renderFooter;
     private buildRows;

package/dist/tui/components/skills-panel.js

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { dirname } from "node:path";
 import chalk from "chalk";
 import { Input, decodeKittyPrintable, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@bubblebrain-ai/pi-tui";
+import { buildSkillCatalog } from "../../skills/format.js";
 import { parseTerminalMouseWheel } from "../model/terminal-mouse.js";
 import { darkTheme } from "../model/theme.js";
 import { themeBackground, themeDim, themeForeground } from "../model/theme-style.js";
@@ -116,7 +117,7 @@ export class SkillsPanelComponent {
         const top = themeForeground(theme.border, `┌${"─".repeat(topDashCount)}`) + ` ${close} ` + themeForeground(theme.border, "┐");
         const bottom = themeForeground(theme.border, `└${horizontal}┘`);
         const separator = themeForeground(theme.border, `├${horizontal}┤`);
-        const tab = this.frameLine(`  ${chalk.bold(themeForeground(theme.inputText, themeBackground(theme.traceHoverBg, " Skills ")))}`, innerWidth);
+        const tab = this.frameLine(`  ${chalk.bold(themeForeground(theme.inputText, themeBackground(theme.traceHoverBg, " Skills ")))}  ${themeForeground(theme.muted, this.catalogSummary())}`, innerWidth);
         const search = this.frameLine(this.renderSearch(innerWidth), innerWidth);
         const footerRows = this.searchActive ? 0 : 2;
         this.bodyRows = Math.max(1, frameHeight - 5 - footerRows);
@@ -284,6 +285,19 @@ export class SkillsPanelComponent {
         const theme = this.options.theme ?? darkTheme;
         return `${themeForeground(theme.border, "│")}${themeBackground(theme.backgroundPanel, fit(content, width))}${themeForeground(theme.border, "│")}`;
     }
+    /** How much of the always-present catalog the enabled skills use, so users know when to prune. */
+    catalogSummary() {
+        const catalog = buildSkillCatalog(this.registry.summaries(), { budgetChars: this.options.getCatalogChars?.() });
+        if (catalog.budgetChars === 0)
+            return "catalog off · skill_search only";
+        const duplicates = this.registry.getDiagnostics().filter((d) => d.message.startsWith("Duplicate skill name")).length;
+        return [
+            `catalog ${catalog.chars.toLocaleString("en-US")}/${catalog.budgetChars.toLocaleString("en-US")} chars`,
+            `${catalog.listed} listed`,
+            catalog.unlisted ? `${catalog.unlisted} not listed` : "",
+            duplicates ? `${duplicates} duplicate${duplicates === 1 ? "" : "s"} ignored` : "",
+        ].filter(Boolean).join(" · ");
+    }
     renderSearch(innerWidth) {
         const theme = this.options.theme ?? darkTheme;
         const filter = filterLabel(this.filter);

package/dist/tui/components/tasks-pane.d.ts

@@ -7,6 +7,8 @@ export interface TasksPaneSnapshot {
     groups: SubagentGroup[];
     workflows: WorkflowRunSnapshot[];
     tasks: BackgroundTaskInfo[];
+    /** Start of the current agent run; undefined keeps finished work hidden. */
+    turnStartedAt?: number;
 }
 export interface WorkflowPaneItem {
     kind: "workflow";
@@ -51,10 +53,25 @@ export declare class TasksPaneComponent implements Component {
     focused: boolean;
     private open;
     private manuallyClosed;
+    /**
+     * History is a view the user opts into for one look, never a mode: it is
+     * dropped whenever the pane closes and when a new round of activity starts.
+     * Otherwise one Ctrl+G after a finished turn left every earlier subagent
+     * listed above the composer for the rest of the session, next to a header
+     * that counts only the running ones.
+     */
     private showHistory;
     private selectedId?;
+    /**
+     * Whether the user picked the selection (keys or click). The pane always
+     * needs one, so it defaults to the first row — but a default nobody chose
+     * must not steer the window: a task that was once the only row stayed
+     * "selected" and scrolled later subagents out of an untouched pane.
+     */
+    private selectionIsUsers;
     private hoveredId?;
     private lastActiveCount;
+    private lastTurnStartedAt;
     private lastRows;
     private allRows;
     private frame;
@@ -67,11 +84,32 @@ export declare class TasksPaneComponent implements Component {
     isOpen(): boolean;
     isAvailable(): boolean;
     activeCount(): number;
+    /** Rows the default view lists: running work plus what this turn launched. */
+    defaultViewCount(): number;
+    visibleCount(): number;
+    /**
+     * Finished rows the pane lists next to the running ones, by outcome. Counted
+     * in the pane's current view, history included when it is showing, so the
+     * header never reports fewer rows than the list holds.
+     */
+    settledCounts(): {
+        done: number;
+        failed: number;
+        stopped: number;
+    };
     totalCount(): number;
     activityGlyph(): string;
     theme(): Theme;
     toggle(forceFocus?: boolean): void;
     close(): void;
+    /**
+     * Advance open/history state from the latest snapshot. Both the status bar
+     * and the pane call this before rendering: the bar is laid out first, so a
+     * transition made only inside the pane's render would leave the bar one
+     * frame behind — forever, when nothing is animating to trigger a redraw.
+     * Idempotent per snapshot (it compares against the last values it saw).
+     */
+    syncState(): void;
     render(width: number): string[];
     private renderItem;
     handleInput(data: string): void;