@bubblebrain-ai/bubble 0.0.51 → 0.0.53

package/dist/{tui-ink → tui/model}/file-mentions.d.ts

@@ -27,3 +27,5 @@ export declare function filterFileSuggestions(files: string[], query: string, li
 export declare function listProjectFiles(cwd: string): Promise<string[]>;
 export declare function invalidateFileListCache(cwd?: string): void;
 export declare function expandAtMentions(text: string, cwd: string): Promise<ExpandResult>;
+/** Composer @-mention context resolution (moved from input-box at cutover). */
+export declare function resolveComposerAtContext(text: string, cursor: number, isSlashContext: boolean, allowWorkspaceMentions?: boolean): AtContext | null;

package/dist/{tui-ink → tui/model}/file-mentions.js

@@ -172,3 +172,7 @@ function guessLanguage(filePath) {
     };
     return map[ext] ?? "";
 }
+/** Composer @-mention context resolution (moved from input-box at cutover). */
+export function resolveComposerAtContext(text, cursor, isSlashContext, allowWorkspaceMentions = true) {
+    return !allowWorkspaceMentions || isSlashContext ? null : findAtContext(text, cursor);
+}

package/dist/tui/model/image-attachment.d.ts

@@ -0,0 +1,15 @@
+/** Image attachment shape shared by composer, provider payload, and history. */
+export interface ImageAttachment {
+    base64: string;
+    mediaType: string;
+    /** Raw byte size of the decoded image (not base64). */
+    bytes: number;
+    /** data:<mediaType>;base64,<...> — ready to send as image_url.url. */
+    dataUrl: string;
+    filename?: string;
+    sourcePath?: string;
+}
+/** Image state retained by a rendered user message after composer submit. */
+export interface DisplayImageAttachment extends ImageAttachment {
+    label: string;
+}

package/dist/tui/model/image-attachment.js

@@ -0,0 +1 @@
+export {};

package/dist/{tui-ink → tui/model}/image-paste.d.ts

@@ -7,7 +7,7 @@
  * TemporaryItems path and the clipboard — the path often gets cleaned up before
  * we can read it, so we fall back to the clipboard.
  */
-import type { ContentPart } from "../types.js";
+import type { ContentPart } from "../../types.js";
 export interface ImageAttachment {
     base64: string;
     mediaType: string;
@@ -53,6 +53,12 @@ export declare function imageLabelForPath(rawPath: string, index: number): strin
 export declare function imageAttachmentReference(att: ImageAttachment, index: number): string;
 export declare function imageAttachmentLabelPattern(): RegExp;
 export declare function buildImageContentParts(promptText: string, attachments: ImageAttachment[]): ContentPart[];
+/**
+ * Convert the composer's inline [Image #N] chips into ordered multimodal
+ * content. The labels remain UI-only, while each image reaches the provider at
+ * the same position the user chose in the draft.
+ */
+export declare function buildImageContentPartsFromDisplayText(displayText: string, promptText: string, attachments: ImageAttachment[], labelStart?: number): ContentPart[];
 export declare function formatImageDisplayInput(promptText: string, attachments: ImageAttachment[], labelStart?: number): string;
 export declare function buildImageContentPartsFromLabels(input: string, attachmentsByLabel: Map<string, ImageAttachment>): {
     actualInput?: ContentPart[];

package/dist/{tui-ink → tui/model}/image-paste.js

@@ -109,6 +109,52 @@ export function buildImageContentParts(promptText, attachments) {
         })),
     ];
 }
+/**
+ * Convert the composer's inline [Image #N] chips into ordered multimodal
+ * content. The labels remain UI-only, while each image reaches the provider at
+ * the same position the user chose in the draft.
+ */
+export function buildImageContentPartsFromDisplayText(displayText, promptText, attachments, labelStart = 1) {
+    const byLabel = new Map(attachments.map((attachment, index) => [`[Image #${labelStart + index}]`, attachment]));
+    const parts = [];
+    const used = new Set();
+    let cursor = 0;
+    while (cursor < displayText.length) {
+        let nextLabel;
+        let nextIndex = -1;
+        for (const label of byLabel.keys()) {
+            if (used.has(label))
+                continue;
+            const index = displayText.indexOf(label, cursor);
+            if (index >= 0 && (nextIndex < 0 || index < nextIndex)) {
+                nextLabel = label;
+                nextIndex = index;
+            }
+        }
+        if (!nextLabel || nextIndex < 0)
+            break;
+        const before = displayText.slice(cursor, nextIndex).trim();
+        if (before)
+            parts.push({ type: "text", text: before });
+        parts.push({ type: "image_url", image_url: { url: byLabel.get(nextLabel).dataUrl } });
+        used.add(nextLabel);
+        cursor = nextIndex + nextLabel.length;
+    }
+    const after = displayText.slice(cursor).trim();
+    if (after)
+        parts.push({ type: "text", text: after });
+    for (const [label, attachment] of byLabel) {
+        if (!used.has(label)) {
+            parts.push({ type: "image_url", image_url: { url: attachment.dataUrl } });
+        }
+    }
+    if (used.size === 0)
+        return buildImageContentParts(promptText, attachments);
+    if (!parts.some((part) => part.type === "text")) {
+        parts.unshift({ type: "text", text: promptText.trim() || defaultImagePrompt(attachments.length) });
+    }
+    return parts;
+}
 export function formatImageDisplayInput(promptText, attachments, labelStart = 1) {
     const text = promptText.trim() || defaultImagePrompt(attachments.length);
     const imageLines = attachments.map((attachment, index) => imageAttachmentReference(attachment, labelStart + index));

package/dist/tui/model/input-history.d.ts

@@ -0,0 +1 @@
+export * from "../../tui/input-history.js";

package/dist/tui/model/input-history.js

@@ -0,0 +1 @@
+export * from "../../tui/input-history.js";

package/dist/{tui-ink → tui/model}/input-queue.d.ts

@@ -1,4 +1,4 @@
-import type { SubmitPayload } from "./input-box.js";
+import type { SubmitPayload } from "./composer-types.js";
 export interface QueuedInput {
     payload: SubmitPayload;
     displayKey?: string;

package/dist/{tui-ink → tui/model}/recent-activity.js

@@ -1,6 +1,6 @@
 import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
 import path from "node:path";
-import { getSessionsDir } from "../session.js";
+import { getSessionsDir } from "../../session.js";
 export function getRecentSessions(cwd, limit = 3) {
     const dir = getSessionsDir(cwd);
     if (!existsSync(dir))

package/dist/{tui-ink → tui/model}/subagent-view.d.ts

@@ -3,22 +3,26 @@
  * Subagents block (message-list.tsx) and the full-screen inspector
  * (subagent-inspector.tsx). Pure functions only — no React.
  */
-import { type SubagentRouteLike } from "../agent/subagent-route-format.js";
+import { type SubagentRouteLike } from "../../agent/subagent-route-format.js";
 import type { Theme } from "./theme.js";
 import type { DisplayMessage, DisplayToolCall } from "./display-history.js";
-import type { ToolResultMetadata } from "../types.js";
+import type { TokenUsage, ToolResultMetadata } from "../../types.js";
 export interface SubagentDisplay {
     subAgentId?: string;
     agentName?: string;
     nickname?: string;
     status?: string;
     category?: string;
+    phase?: string;
     route?: SubagentRouteLike;
     profileSource?: string;
     task?: string;
     summary?: string;
     toolNotes?: string[];
     error?: string;
+    usage?: TokenUsage;
+    createdAt?: number;
+    updatedAt?: number;
 }
 export declare function latestSubagentNote(subagent: SubagentDisplay): string;
 export declare function subagentLabel(subagent: SubagentDisplay): string;
@@ -32,10 +36,21 @@ export declare function sortSubagents(subagents: SubagentDisplay[]): SubagentDis
  * those tools were removed (2026-07-06). */
 export interface SubagentGroup {
     id: string;
+    runId?: string;
     kind: "single" | "team" | "batch" | "workflow";
     label: string;
     members: SubagentDisplay[];
 }
+/**
+ * Projects a newer lifecycle snapshot back onto every existing trace that
+ * already references the same child. spawn_agent settles as soon as the child
+ * is queued, while later tool_update/wait_agent events carry the authoritative
+ * running/final state. Keeping the launch row synchronized prevents it from
+ * remaining permanently "running" beside a completed Tasks Pane entry.
+ */
+export declare function mergeSubagentSnapshotsIntoMessages(messages: DisplayMessage[], incoming: ToolResultMetadata | undefined): DisplayMessage[];
+/** Reconciles persisted launch/wait/list echoes when rebuilding a session. */
+export declare function synchronizeSubagentSnapshots(messages: DisplayMessage[]): DisplayMessage[];
 /**
  * Merges subagent tool metadata, deduping member snapshots by subAgentId so a
  * stream of per-child updates accumulates into one member list instead of each

package/dist/{tui-ink → tui/model}/subagent-view.js

@@ -3,7 +3,7 @@
  * Subagents block (message-list.tsx) and the full-screen inspector
  * (subagent-inspector.tsx). Pure functions only — no React.
  */
-import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+import { formatSubagentRoute } from "../../agent/subagent-route-format.js";
 export function latestSubagentNote(subagent) {
     const note = subagent.error
         || subagent.toolNotes?.filter(Boolean).at(-1)
@@ -75,6 +75,109 @@ function subagentFreshness(member) {
 function memberKey(member) {
     return member.subAgentId || `${member.nickname ?? ""}|${member.task ?? ""}`;
 }
+function toolCallsFromMessage(message) {
+    return [
+        ...(message.toolCalls ?? []),
+        ...(message.parts ?? []).flatMap((part) => part.type === "tools" ? part.toolCalls : []),
+    ];
+}
+function freshestSubagentSnapshots(messages) {
+    const freshest = new Map();
+    for (const message of messages) {
+        for (const tool of toolCallsFromMessage(message)) {
+            if (tool.metadata?.kind !== "subagent" || !Array.isArray(tool.metadata.subagents))
+                continue;
+            for (const raw of tool.metadata.subagents) {
+                if (typeof raw !== "object" || raw === null)
+                    continue;
+                const member = raw;
+                const key = memberKey(member);
+                if (!key)
+                    continue;
+                const current = freshest.get(key);
+                if (!current || subagentFreshness(member) >= subagentFreshness(current)) {
+                    freshest.set(key, current ? { ...current, ...member } : member);
+                }
+            }
+        }
+    }
+    return [...freshest.values()];
+}
+/**
+ * Projects a newer lifecycle snapshot back onto every existing trace that
+ * already references the same child. spawn_agent settles as soon as the child
+ * is queued, while later tool_update/wait_agent events carry the authoritative
+ * running/final state. Keeping the launch row synchronized prevents it from
+ * remaining permanently "running" beside a completed Tasks Pane entry.
+ */
+export function mergeSubagentSnapshotsIntoMessages(messages, incoming) {
+    if (incoming?.kind !== "subagent" || !Array.isArray(incoming.subagents))
+        return messages;
+    const incomingByKey = new Map();
+    for (const raw of incoming.subagents) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const member = raw;
+        const key = memberKey(member);
+        if (key)
+            incomingByKey.set(key, member);
+    }
+    if (incomingByKey.size === 0)
+        return messages;
+    const updateTool = (tool) => {
+        if (tool.metadata?.kind !== "subagent" || !Array.isArray(tool.metadata.subagents))
+            return tool;
+        let changed = false;
+        const subagents = tool.metadata.subagents.map((raw) => {
+            if (typeof raw !== "object" || raw === null)
+                return raw;
+            const current = raw;
+            const next = incomingByKey.get(memberKey(current));
+            if (!next || subagentFreshness(next) < subagentFreshness(current))
+                return raw;
+            changed = true;
+            return { ...current, ...next };
+        });
+        return changed ? { ...tool, metadata: { ...tool.metadata, subagents } } : tool;
+    };
+    let anyChanged = false;
+    const updated = messages.map((message) => {
+        let messageChanged = false;
+        const toolCalls = message.toolCalls?.map((tool) => {
+            const next = updateTool(tool);
+            if (next !== tool)
+                messageChanged = true;
+            return next;
+        });
+        const parts = message.parts?.map((part) => {
+            if (part.type !== "tools")
+                return part;
+            let partChanged = false;
+            const nextTools = part.toolCalls.map((tool) => {
+                const next = updateTool(tool);
+                if (next !== tool)
+                    partChanged = true;
+                return next;
+            });
+            if (!partChanged)
+                return part;
+            messageChanged = true;
+            return { ...part, toolCalls: nextTools };
+        });
+        if (!messageChanged)
+            return message;
+        anyChanged = true;
+        return { ...message, toolCalls, parts };
+    });
+    return anyChanged ? updated : messages;
+}
+/** Reconciles persisted launch/wait/list echoes when rebuilding a session. */
+export function synchronizeSubagentSnapshots(messages) {
+    const snapshots = freshestSubagentSnapshots(messages);
+    return snapshots.length === 0
+        ? messages
+        : mergeSubagentSnapshotsIntoMessages(messages, { kind: "subagent", subagents: snapshots });
+}
 /**
  * Merges subagent tool metadata, deduping member snapshots by subAgentId so a
  * stream of per-child updates accumulates into one member list instead of each
@@ -150,7 +253,20 @@ export function accumulateLiveSubagentUpdate(map, event) {
     // call rather than falling back to one single-agent group per member.
     if (event.name === "run_workflow" && metadata.mode === undefined)
         metadata.mode = "workflow";
-    map.set(event.id, { id: event.id, name: event.name, args: prev?.args ?? {}, metadata });
+    const members = Array.isArray(metadata.subagents)
+        ? metadata.subagents.filter((member) => (typeof member === "object" && member !== null))
+        : [];
+    const statuses = members.map((member) => String(member.status ?? "running"));
+    const stillRunning = statuses.some((status) => status === "queued" || status === "running");
+    const failed = statuses.some((status) => status === "failed" || status === "blocked" || status === "cancelled");
+    map.set(event.id, {
+        id: event.id,
+        name: event.name,
+        args: prev?.args ?? {},
+        metadata,
+        status: stillRunning ? "running" : failed ? "failed" : "completed",
+        isError: failed,
+    });
     return true;
 }
 /**
@@ -206,7 +322,11 @@ export function collectSubagentGroups(messages, streamingTools) {
             if (!groups.has(groupKey)) {
                 const description = typeof tc.args?.description === "string" ? tc.args.description.trim()
                     : typeof tc.args?.title === "string" ? tc.args.title.trim() : "";
-                groups.set(groupKey, { kind: mode, label: description || mode, memberKeys: [], order: order++ });
+                const metadataRunId = typeof tc.metadata?.runId === "string" ? tc.metadata.runId : undefined;
+                const memberRunId = typeof members[0]?.subAgentId === "string"
+                    ? (typeof members[0].runId === "string" ? String(members[0].runId) : undefined)
+                    : undefined;
+                groups.set(groupKey, { kind: mode, label: description || mode, runId: metadataRunId ?? memberRunId, memberKeys: [], order: order++ });
             }
             const group = groups.get(groupKey);
             for (const m of members) {
@@ -226,7 +346,7 @@ export function collectSubagentGroups(messages, streamingTools) {
                     continue;
                 const groupKey = `single:${key}`;
                 memberToGroup.set(key, groupKey);
-                groups.set(groupKey, { kind: "single", label: m.nickname ?? m.task ?? "subagent", memberKeys: [key], order: order++ });
+                groups.set(groupKey, { kind: "single", label: m.nickname ?? m.task ?? "subagent", runId: typeof m.runId === "string" ? String(m.runId) : undefined, memberKeys: [key], order: order++ });
             }
         }
     }
@@ -236,6 +356,7 @@ export function collectSubagentGroups(messages, streamingTools) {
         id,
         kind: g.kind,
         label: g.label,
+        runId: g.runId,
         members: g.memberKeys.map((k) => freshest.get(k)).filter((m) => !!m),
     }))
         // A group can end up empty when a later echo of the same run (e.g. the

package/dist/{tui-ink → tui/model}/submit-dedupe.d.ts

@@ -1,4 +1,4 @@
-import type { SubmitPayload } from "./input-box.js";
+import type { SubmitPayload } from "./composer-types.js";
 export type StartingSubmitDecision = "accept" | "ignore" | "queue";
 export declare function submitPayloadFingerprint(payload: SubmitPayload): string;
 export declare function decideStartingSubmit(activeFingerprint: string | null, payload: SubmitPayload): StartingSubmitDecision;

package/dist/tui/model/theme-style.d.ts

@@ -0,0 +1,10 @@
+/** Apply a configured foreground without letting a malformed override crash rendering. */
+export declare function themeForeground(color: string | undefined, text: string): string;
+/** Apply a configured background without letting a malformed override crash rendering. */
+export declare function themeBackground(color: string | undefined, text: string): string;
+export declare function themeDim(color: string | undefined, text: string): string;
+/** ANSI pair used by the alternate-screen renderer to paint every cell. */
+export declare function themeBackgroundCodes(color: string | undefined): {
+    open: string;
+    close: string;
+} | undefined;

package/dist/tui/model/theme-style.js

@@ -0,0 +1,79 @@
+import chalk from "chalk";
+const NAMED_COLORS = new Set([
+    "black",
+    "red",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "cyan",
+    "white",
+    "gray",
+    "grey",
+]);
+function isHexColor(value) {
+    return /^#[0-9a-f]{6}$/i.test(value) || /^#[0-9a-f]{3}$/i.test(value);
+}
+/** Apply a configured foreground without letting a malformed override crash rendering. */
+export function themeForeground(color, text) {
+    if (!color)
+        return text;
+    if (isHexColor(color))
+        return chalk.hex(color)(text);
+    const normalized = color.toLowerCase();
+    if (NAMED_COLORS.has(normalized))
+        return chalk[normalized](text);
+    return text;
+}
+/** Apply a configured background without letting a malformed override crash rendering. */
+export function themeBackground(color, text) {
+    if (!color)
+        return text;
+    if (isHexColor(color))
+        return chalk.bgHex(color)(text);
+    const normalized = color.toLowerCase();
+    if (!NAMED_COLORS.has(normalized))
+        return text;
+    switch (normalized) {
+        case "black": return chalk.bgBlack(text);
+        case "red": return chalk.bgRed(text);
+        case "green": return chalk.bgGreen(text);
+        case "yellow": return chalk.bgYellow(text);
+        case "blue": return chalk.bgBlue(text);
+        case "magenta": return chalk.bgMagenta(text);
+        case "cyan": return chalk.bgCyan(text);
+        case "white": return chalk.bgWhite(text);
+        case "gray":
+        case "grey": return chalk.bgGray(text);
+    }
+}
+export function themeDim(color, text) {
+    return chalk.dim(themeForeground(color, text));
+}
+/** ANSI pair used by the alternate-screen renderer to paint every cell. */
+export function themeBackgroundCodes(color) {
+    if (!color)
+        return undefined;
+    if (isHexColor(color)) {
+        const expanded = color.length === 4
+            ? color.slice(1).split("").map((part) => part + part).join("")
+            : color.slice(1);
+        const channels = expanded.match(/../g)?.map((part) => Number.parseInt(part, 16));
+        if (!channels || channels.length !== 3)
+            return undefined;
+        return { open: `\x1b[48;2;${channels.join(";")}m`, close: "\x1b[49m" };
+    }
+    const normalized = color.toLowerCase();
+    if (!NAMED_COLORS.has(normalized))
+        return undefined;
+    const code = normalized === "black" ? 40
+        : normalized === "red" ? 41
+            : normalized === "green" ? 42
+                : normalized === "yellow" ? 43
+                    : normalized === "blue" ? 44
+                        : normalized === "magenta" ? 45
+                            : normalized === "cyan" ? 46
+                                : normalized === "white" ? 47
+                                    : 100;
+    return { open: `\x1b[${code}m`, close: "\x1b[49m" };
+}

package/dist/{tui-ink → tui/model}/theme.d.ts

@@ -1,11 +1,5 @@
 /**
- * Color themes for the TUI.
- *
- * Two base palettes are shipped: `darkTheme` for dark terminal backgrounds and
- * `lightTheme` for light ones. The shape is identical so consumers depend on
- * `Theme` rather than either palette directly. Active palette is provided
- * through `ThemeContext` so components re-render automatically when the
- * user switches via `/theme` at runtime.
+ * Renderer-neutral theme tokens shared by the terminal UI surfaces.
  */
 export type ResolvedTheme = "light" | "dark";
 export type ThemeMode = "auto" | ResolvedTheme;
@@ -53,6 +47,9 @@ export interface Theme {
     traceDetail: string;
     traceCommand: string;
     tracePending: string;
+    /** Neutral painted surfaces for pointer-hovered / selected tool traces. */
+    traceHoverBg: string;
+    traceSelectedBg: string;
     userMessageBorder: string;
     userMessageBg: string;
     userMessageText: string;
@@ -64,21 +61,12 @@ export interface Theme {
     diffRemoveFg: string;
 }
 export declare const darkTheme: Theme;
-/**
- * Light palette tuned for paper-neutral surfaces, blue focus/user rails, warm
- * command accent, and semantic tool colors with readable contrast on a light
- * terminal background.
- */
 export declare const lightTheme: Theme;
-/**
- * Decide whether the canvas needs painting. Auto mode always inherits the
- * terminal's own background, and so does a forced theme that matches the
- * detected terminal. A forced theme that mismatches (e.g. `/theme light`
- * inside a dark terminal) paints its canvas, because its foregrounds are
- * tuned for the opposite background and would otherwise be unreadable.
- */
 export declare function canvasBackgroundFor(mode: ThemeMode, resolved: ResolvedTheme, terminalTheme: ResolvedTheme): string | undefined;
-export declare const ThemeProvider: import("react").Provider<Theme>;
-export declare function useTheme(): Theme;
-/** Build the active palette given a resolved mode and optional overrides. */
-export declare function paletteFor(mode: ResolvedTheme, overrides?: Record<string, string>): Theme;
+/** Build a palette from one of the shipped themes plus user overrides. */
+export declare function paletteFor(resolved: ResolvedTheme, overrides?: Record<string, string>): Theme;
+/** Resolve the complete live palette used by an interactive TUI instance. */
+export declare function resolveThemePalette(mode: ThemeMode, terminalTheme: ResolvedTheme, overrides?: Record<string, string>): {
+    resolved: ResolvedTheme;
+    palette: Theme;
+};

package/dist/{tui-ink → tui/model}/theme.js

@@ -1,13 +1,3 @@
-/**
- * Color themes for the TUI.
- *
- * Two base palettes are shipped: `darkTheme` for dark terminal backgrounds and
- * `lightTheme` for light ones. The shape is identical so consumers depend on
- * `Theme` rather than either palette directly. Active palette is provided
- * through `ThemeContext` so components re-render automatically when the
- * user switches via `/theme` at runtime.
- */
-import { createContext, useContext } from "react";
 export const darkTheme = {
     user: "green",
     agent: "blue",
@@ -43,19 +33,16 @@ export const darkTheme = {
     traceDetail: "gray",
     traceCommand: "#59BCE8",
     tracePending: "yellow",
+    traceHoverBg: "#232323",
+    traceSelectedBg: "#2B2B2B",
     userMessageBorder: "#8A7FC6",
-    userMessageBg: "#2a2a34",
+    userMessageBg: "#2A2A2A",
     userMessageText: "#f3f3f7",
     diffAdd: "#1a3d1a",
     diffRemove: "#3d1a1a",
     diffAddFg: "green",
     diffRemoveFg: "red",
 };
-/**
- * Light palette tuned for paper-neutral surfaces, blue focus/user rails, warm
- * command accent, and semantic tool colors with readable contrast on a light
- * terminal background.
- */
 export const lightTheme = {
     user: "#356FD2",
     agent: "#171717",
@@ -91,6 +78,8 @@ export const lightTheme = {
     traceDetail: "#8B9094",
     traceCommand: "#257E8A",
     tracePending: "#8B4A00",
+    traceHoverBg: "#E8E8E5",
+    traceSelectedBg: "#DDDFDB",
     userMessageBorder: "#356FD2",
     userMessageBg: "#F1F3F0",
     userMessageText: "#234B93",
@@ -99,38 +88,34 @@ export const lightTheme = {
     diffAddFg: "#2F7D4A",
     diffRemoveFg: "#B62633",
 };
-/** Canvas colors painted only when a forced theme mismatches the terminal. */
 const paintedCanvas = {
     dark: "#0A0A0A",
     light: "#FCFCFA",
 };
-/**
- * Decide whether the canvas needs painting. Auto mode always inherits the
- * terminal's own background, and so does a forced theme that matches the
- * detected terminal. A forced theme that mismatches (e.g. `/theme light`
- * inside a dark terminal) paints its canvas, because its foregrounds are
- * tuned for the opposite background and would otherwise be unreadable.
- */
 export function canvasBackgroundFor(mode, resolved, terminalTheme) {
     if (mode === "auto" || resolved === terminalTheme)
         return undefined;
     return paintedCanvas[resolved];
 }
-const ThemeContext = createContext(darkTheme);
-export const ThemeProvider = ThemeContext.Provider;
-export function useTheme() {
-    return useContext(ThemeContext);
-}
-/** Build the active palette given a resolved mode and optional overrides. */
-export function paletteFor(mode, overrides) {
-    const base = mode === "light" ? lightTheme : darkTheme;
+/** Build a palette from one of the shipped themes plus user overrides. */
+export function paletteFor(resolved, overrides) {
+    const base = resolved === "light" ? lightTheme : darkTheme;
     if (!overrides)
-        return base;
-    const filtered = {};
+        return { ...base };
+    const palette = { ...base };
     for (const [key, value] of Object.entries(overrides)) {
-        if (typeof value === "string" && key in base) {
-            filtered[key] = value;
-        }
+        if (typeof value !== "string" || !(key in base))
+            continue;
+        palette[key] = value;
+    }
+    return palette;
+}
+/** Resolve the complete live palette used by an interactive TUI instance. */
+export function resolveThemePalette(mode, terminalTheme, overrides) {
+    const resolved = mode === "auto" ? terminalTheme : mode;
+    const palette = paletteFor(resolved, overrides);
+    if (palette.background === undefined) {
+        palette.background = canvasBackgroundFor(mode, resolved, terminalTheme);
     }
-    return { ...base, ...filtered };
+    return { resolved, palette };
 }

package/dist/{tui-ink → tui/model}/trace-groups.d.ts

@@ -19,6 +19,8 @@ export interface TraceGroup {
     hasError: boolean;
     errorCount: number;
     startedAt?: number;
+    /** Final lifecycle label for traces whose tool call launches background work. */
+    statusLabel?: string;
 }
 export interface TraceGroupOptions {
     maxItems?: number;