@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/model/paste-operation-tracker.js

@@ -0,0 +1,25 @@
+/**
+ * Tracks overlapping paste operations by identity. Finishing an older paste
+ * must never clear the pending state of a newer paste.
+ */
+export class PasteOperationTracker {
+    nextId = 1;
+    active = new Set();
+    begin() {
+        const id = this.nextId++;
+        this.active.add(id);
+        return id;
+    }
+    finish(id) {
+        this.active.delete(id);
+    }
+    invalidateAll() {
+        this.active.clear();
+    }
+    get hasPending() {
+        return this.active.size > 0;
+    }
+    get pendingCount() {
+        return this.active.size;
+    }
+}

package/dist/tui/model/recent-activity.d.ts

@@ -0,0 +1,8 @@
+export interface RecentSession {
+    file: string;
+    modifiedAt: number;
+    preview: string;
+}
+export declare function getRecentSessions(cwd: string, limit?: number): RecentSession[];
+export declare function formatRelativeTime(timestampMs: number, now?: number): string;
+export declare function truncatePreview(preview: string, maxLen: number): string;

package/dist/tui/model/recent-activity.js

@@ -0,0 +1,71 @@
+import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import path from "node:path";
+import { getSessionsDir } from "../../session.js";
+export function getRecentSessions(cwd, limit = 3) {
+    const dir = getSessionsDir(cwd);
+    if (!existsSync(dir))
+        return [];
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    const withMtime = files.map((f) => {
+        const full = path.join(dir, f);
+        try {
+            return { file: f, full, modifiedAt: statSync(full).mtimeMs };
+        }
+        catch {
+            return { file: f, full, modifiedAt: 0 };
+        }
+    });
+    withMtime.sort((a, b) => b.modifiedAt - a.modifiedAt);
+    return withMtime.slice(0, limit).map(({ file, full, modifiedAt }) => ({
+        file,
+        modifiedAt,
+        preview: extractFirstUserMessage(full) ?? "(no messages)",
+    }));
+}
+export function formatRelativeTime(timestampMs, now = Date.now()) {
+    const diffSec = Math.max(0, Math.floor((now - timestampMs) / 1000));
+    if (diffSec < 60)
+        return "just now";
+    if (diffSec < 3600)
+        return `${Math.floor(diffSec / 60)}m ago`;
+    if (diffSec < 86400)
+        return `${Math.floor(diffSec / 3600)}h ago`;
+    if (diffSec < 604800)
+        return `${Math.floor(diffSec / 86400)}d ago`;
+    const weeks = Math.floor(diffSec / 604800);
+    if (weeks < 5)
+        return `${weeks}w ago`;
+    const months = Math.floor(diffSec / (30 * 86400));
+    return `${months}mo ago`;
+}
+function extractFirstUserMessage(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const lines = raw.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type === "user_message" && typeof entry.message?.content === "string") {
+            return entry.message.content;
+        }
+    }
+    return null;
+}
+export function truncatePreview(preview, maxLen) {
+    const firstLine = preview.split("\n")[0]?.trim() ?? "";
+    if (firstLine.length <= maxLen)
+        return firstLine;
+    return firstLine.slice(0, Math.max(1, maxLen - 1)) + "…";
+}

package/dist/tui/model/subagent-view.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Shared subagent view-model + presentation helpers, used by both the inline
+ * 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 { Theme } from "./theme.js";
+import type { DisplayMessage, DisplayToolCall } from "./display-history.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;
+export declare function subagentRole(subagent: SubagentDisplay): string;
+export declare function subagentDescriptor(subagent: SubagentDisplay, includeThinking?: boolean): string;
+export declare function subagentStatusColor(status: string | undefined, theme: Theme): string;
+export declare function subagentSummary(subagents: SubagentDisplay[]): string;
+export declare function sortSubagents(subagents: SubagentDisplay[]): SubagentDisplay[];
+/** A spawn_agent (one member) or a run_workflow (a group of members). The
+ * "team"/"batch" kinds survive only to render transcripts recorded before
+ * those tools were removed (2026-07-06). */
+export interface SubagentGroup {
+    id: string;
+    runId?: string;
+    kind: "single" | "team" | "batch" | "workflow";
+    label: string;
+    members: SubagentDisplay[];
+}
+/** Maps every tool call in the transcript; returns the same array when nothing changed. */
+export declare function mapTranscriptTools(messages: DisplayMessage[], updateTool: (tool: DisplayToolCall) => DisplayToolCall): DisplayMessage[];
+/**
+ * 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
+ * update replacing the last.
+ */
+export declare function mergeToolMetadata(current: ToolResultMetadata | undefined, incoming: ToolResultMetadata | undefined): ToolResultMetadata | undefined;
+/**
+ * Applies a subagent tool_update whose launching call has already settled out
+ * of the streaming round. Children keep reporting against the launching
+ * spawn_agent / run_workflow call id across later rounds (e.g. while a
+ * wait_workflow blocks), so the update is merged into that entry by id — which
+ * absorbs members a workflow spawned after commit — and then projected onto
+ * every echo referencing the same members. The settled transcript is the only
+ * data source; the live tail never carries synthetic tool rows.
+ */
+export declare function applySubagentUpdateToMessages(messages: DisplayMessage[], update: {
+    id: string;
+    name: string;
+    metadata?: ToolResultMetadata;
+}): DisplayMessage[];
+/**
+ * Collects every spawned subagent from the live transcript + streaming tools,
+ * grouped by their originating tool call, for the inspector. Pure.
+ *
+ * The same subagent is echoed by MULTIPLE lifecycle tool calls — its spawn_agent
+ * (a stale snapshot) plus every wait_agent/list_agents that observed it (later
+ * snapshots), all carrying metadata.subagents (agent-lifecycle formatLifecycleResult).
+ * So we dedupe by subAgentId, keep the freshest snapshot, group team/batch members
+ * by their originating tool call, and collapse a single agent's many lifecycle
+ * echoes into one "single" group keyed by the agent itself.
+ */
+export declare function collectSubagentGroups(messages: DisplayMessage[], streamingTools: DisplayToolCall[]): SubagentGroup[];

package/dist/tui/model/subagent-view.js

@@ -0,0 +1,336 @@
+/**
+ * Shared subagent view-model + presentation helpers, used by both the inline
+ * 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";
+export function latestSubagentNote(subagent) {
+    const note = subagent.error
+        || subagent.toolNotes?.filter(Boolean).at(-1)
+        || subagent.summary
+        || subagent.task
+        || "";
+    return note.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).find(Boolean) ?? "";
+}
+export function subagentLabel(subagent) {
+    return subagent.nickname ?? subagent.agentName ?? "subagent";
+}
+export function subagentRole(subagent) {
+    return [subagent.agentName, subagent.category ? `/${subagent.category}` : ""].join("") || "default";
+}
+export function subagentDescriptor(subagent, includeThinking = false) {
+    const route = formatSubagentRoute(subagent.route, { includeThinking });
+    const role = subagentRole(subagent);
+    return route ? `${role} @ ${route}` : role;
+}
+export function subagentStatusColor(status, theme) {
+    if (status === "completed")
+        return theme.success;
+    if (status === "failed" || status === "blocked" || status === "cancelled")
+        return theme.error;
+    if (status === "queued")
+        return theme.muted;
+    return theme.toolPending;
+}
+export function subagentSummary(subagents) {
+    if (subagents.length === 0)
+        return "no subagents";
+    const counts = new Map();
+    for (const subagent of subagents) {
+        const status = subagent.status ?? "running";
+        counts.set(status, (counts.get(status) ?? 0) + 1);
+    }
+    const order = ["running", "queued", "completed", "blocked", "failed", "cancelled"];
+    return order
+        .filter((status) => counts.has(status))
+        .map((status) => `${counts.get(status)} ${status}`)
+        .join("  ");
+}
+export function sortSubagents(subagents) {
+    const rank = {
+        running: 0,
+        blocked: 1,
+        failed: 2,
+        queued: 3,
+        cancelled: 4,
+        completed: 5,
+    };
+    return [...subagents].sort((a, b) => (rank[a.status ?? "running"] ?? 9) - (rank[b.status ?? "running"] ?? 9));
+}
+function subagentStatusRank(status) {
+    if (status === "completed" || status === "failed" || status === "blocked" || status === "cancelled" || status === "closed")
+        return 3;
+    if (status === "running")
+        return 2;
+    if (status === "queued")
+        return 1;
+    return 0;
+}
+/** Higher = more "complete"/recent snapshot of the same subagent. */
+function subagentFreshness(member) {
+    return subagentStatusRank(member.status) * 100_000
+        + (member.toolNotes?.length ?? 0) * 10
+        + (member.summary ? 1 : 0);
+}
+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()];
+}
+/** Maps every tool call in the transcript; returns the same array when nothing changed. */
+export function mapTranscriptTools(messages, updateTool) {
+    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;
+}
+/**
+ * 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;
+    };
+    return mapTranscriptTools(messages, updateTool);
+}
+/** 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
+ * update replacing the last.
+ */
+export function mergeToolMetadata(current, incoming) {
+    if (!incoming)
+        return current;
+    if (current?.kind !== "subagent" || incoming.kind !== "subagent") {
+        return incoming;
+    }
+    const currentSubagents = Array.isArray(current.subagents) ? current.subagents : [];
+    const incomingSubagents = Array.isArray(incoming.subagents) ? incoming.subagents : [];
+    const byId = new Map();
+    for (const item of currentSubagents) {
+        const subAgentId = typeof item === "object" && item !== null && "subAgentId" in item
+            ? String(item.subAgentId)
+            : "";
+        byId.set(subAgentId || `current:${byId.size}`, item);
+    }
+    for (const item of incomingSubagents) {
+        const subAgentId = typeof item === "object" && item !== null && "subAgentId" in item
+            ? String(item.subAgentId)
+            : "";
+        byId.set(subAgentId || `incoming:${byId.size}`, item);
+    }
+    return {
+        ...current,
+        ...incoming,
+        subagents: [...byId.values()],
+    };
+}
+/**
+ * Applies a subagent tool_update whose launching call has already settled out
+ * of the streaming round. Children keep reporting against the launching
+ * spawn_agent / run_workflow call id across later rounds (e.g. while a
+ * wait_workflow blocks), so the update is merged into that entry by id — which
+ * absorbs members a workflow spawned after commit — and then projected onto
+ * every echo referencing the same members. The settled transcript is the only
+ * data source; the live tail never carries synthetic tool rows.
+ */
+export function applySubagentUpdateToMessages(messages, update) {
+    if (update.metadata?.kind !== "subagent")
+        return messages;
+    const byId = mapTranscriptTools(messages, (tool) => {
+        if (tool.id !== update.id)
+            return tool;
+        const metadata = mergeToolMetadata(tool.metadata, update.metadata);
+        if (!metadata || metadata === tool.metadata)
+            return tool;
+        // Per-child updates carry no mode; keep them grouped under the launching
+        // workflow call rather than falling back to one single-agent group each.
+        if (update.name === "run_workflow" && metadata.mode === undefined)
+            metadata.mode = "workflow";
+        return { ...tool, metadata };
+    });
+    return mergeSubagentSnapshotsIntoMessages(byId, update.metadata);
+}
+/**
+ * Collects every spawned subagent from the live transcript + streaming tools,
+ * grouped by their originating tool call, for the inspector. Pure.
+ *
+ * The same subagent is echoed by MULTIPLE lifecycle tool calls — its spawn_agent
+ * (a stale snapshot) plus every wait_agent/list_agents that observed it (later
+ * snapshots), all carrying metadata.subagents (agent-lifecycle formatLifecycleResult).
+ * So we dedupe by subAgentId, keep the freshest snapshot, group team/batch members
+ * by their originating tool call, and collapse a single agent's many lifecycle
+ * echoes into one "single" group keyed by the agent itself.
+ */
+export function collectSubagentGroups(messages, streamingTools) {
+    const toolCalls = [];
+    const ingest = (tcs) => {
+        if (!tcs)
+            return;
+        for (const tc of tcs)
+            if (tc.metadata?.kind === "subagent")
+                toolCalls.push(tc);
+    };
+    for (const message of messages) {
+        ingest(message.toolCalls);
+        if (message.parts) {
+            for (const part of message.parts) {
+                if (part.type === "tools")
+                    ingest(part.toolCalls);
+            }
+        }
+    }
+    ingest(streamingTools);
+    const freshest = new Map();
+    const memberToGroup = new Map();
+    const groups = new Map();
+    let order = 0;
+    for (const tc of toolCalls) {
+        const rawMembers = Array.isArray(tc.metadata?.subagents) ? tc.metadata.subagents : [];
+        const members = rawMembers.filter((m) => typeof m === "object" && m !== null);
+        if (members.length === 0)
+            continue;
+        // Track the freshest snapshot seen for each subagent.
+        for (const m of members) {
+            const key = memberKey(m);
+            const prev = freshest.get(key);
+            if (!prev || subagentFreshness(m) >= subagentFreshness(prev))
+                freshest.set(key, m);
+        }
+        const mode = tc.metadata.mode;
+        if (mode === "team" || mode === "batch" || mode === "workflow") {
+            // A team/batch/workflow tool call is the canonical group for its members.
+            const groupKey = tc.id;
+            if (!groups.has(groupKey)) {
+                const description = typeof tc.args?.description === "string" ? tc.args.description.trim()
+                    : typeof tc.args?.title === "string" ? tc.args.title.trim() : "";
+                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) {
+                const key = memberKey(m);
+                if (!memberToGroup.has(key)) {
+                    memberToGroup.set(key, groupKey);
+                    group.memberKeys.push(key);
+                }
+            }
+        }
+        else {
+            // Lifecycle echo (spawn/wait/list/...): one "single" group per agent,
+            // collapsing all its echoes; skip any already claimed by a team/batch.
+            for (const m of members) {
+                const key = memberKey(m);
+                if (memberToGroup.has(key))
+                    continue;
+                const groupKey = `single:${key}`;
+                memberToGroup.set(key, groupKey);
+                groups.set(groupKey, { kind: "single", label: m.nickname ?? m.task ?? "subagent", runId: typeof m.runId === "string" ? String(m.runId) : undefined, memberKeys: [key], order: order++ });
+            }
+        }
+    }
+    return [...groups.entries()]
+        .sort((a, b) => a[1].order - b[1].order)
+        .map(([id, g]) => ({
+        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
+        // wait_workflow result vs the live accumulator) claimed all its members.
+        .filter((group) => group.members.length > 0);
+}

package/dist/tui/model/submit-dedupe.d.ts

@@ -0,0 +1,5 @@
+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;
+export declare function decideStartingSubmitFingerprint(activeFingerprint: string | null, submitFingerprint: string): StartingSubmitDecision;

package/dist/tui/model/submit-dedupe.js

@@ -0,0 +1,25 @@
+import { createHash } from "node:crypto";
+function hashValue(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function submitPayloadFingerprint(payload) {
+    return JSON.stringify({
+        text: payload.text,
+        displayText: payload.displayText ?? "",
+        images: payload.images.map((image) => ({
+            mediaType: image.mediaType,
+            bytes: image.bytes,
+            filename: image.filename ?? "",
+            sourcePath: image.sourcePath ?? "",
+            dataUrlHash: hashValue(image.dataUrl),
+        })),
+    });
+}
+export function decideStartingSubmit(activeFingerprint, payload) {
+    return decideStartingSubmitFingerprint(activeFingerprint, submitPayloadFingerprint(payload));
+}
+export function decideStartingSubmitFingerprint(activeFingerprint, submitFingerprint) {
+    if (!activeFingerprint)
+        return "accept";
+    return activeFingerprint === submitFingerprint ? "ignore" : "queue";
+}

package/dist/tui/model/sync-output.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Synchronized-output wrapper (CSI ?2026, "sync updates").
+ *
+ * Every frame Ink writes gets bracketed in begin/end synchronized-output so
+ * the terminal composites it atomically instead of painting mid-erase state —
+ * the primary source of visible flicker during streaming. This is exactly
+ * what pi's main-screen renderer does per paint batch; alt-screen is NOT
+ * required for it.
+ *
+ * Terminals that don't implement mode 2026 ignore unknown DEC private modes,
+ * so emitting unconditionally is safe; BUBBLE_NO_SYNC_OUTPUT=1 is the escape
+ * hatch for anything that misbehaves. Only string chunks are bracketed —
+ * Ink writes frames as strings; binary writes pass through untouched.
+ */
+export declare const BEGIN_SYNC = "\u001B[?2026h";
+export declare const END_SYNC = "\u001B[?2026l";
+export declare function wrapSynchronizedOutput(stream: NodeJS.WriteStream): NodeJS.WriteStream;

package/dist/tui/model/sync-output.js

@@ -0,0 +1,35 @@
+/**
+ * Synchronized-output wrapper (CSI ?2026, "sync updates").
+ *
+ * Every frame Ink writes gets bracketed in begin/end synchronized-output so
+ * the terminal composites it atomically instead of painting mid-erase state —
+ * the primary source of visible flicker during streaming. This is exactly
+ * what pi's main-screen renderer does per paint batch; alt-screen is NOT
+ * required for it.
+ *
+ * Terminals that don't implement mode 2026 ignore unknown DEC private modes,
+ * so emitting unconditionally is safe; BUBBLE_NO_SYNC_OUTPUT=1 is the escape
+ * hatch for anything that misbehaves. Only string chunks are bracketed —
+ * Ink writes frames as strings; binary writes pass through untouched.
+ */
+export const BEGIN_SYNC = "\x1b[?2026h";
+export const END_SYNC = "\x1b[?2026l";
+export function wrapSynchronizedOutput(stream) {
+    if (!stream.isTTY || process.env.BUBBLE_NO_SYNC_OUTPUT === "1")
+        return stream;
+    return new Proxy(stream, {
+        get(target, prop) {
+            if (prop === "write") {
+                return (chunk, ...rest) => typeof chunk === "string" && chunk.length > 0
+                    ? target.write(BEGIN_SYNC + chunk + END_SYNC, ...rest)
+                    : target.write(chunk, ...rest);
+            }
+            const value = Reflect.get(target, prop, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+        set(target, prop, value) {
+            Reflect.set(target, prop, value);
+            return true;
+        },
+    });
+}

package/dist/tui/model/task-lifecycle.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Background task lifecycle projection for the transcript.
+ *
+ * A `bash run_in_background` call settles as soon as the process is spawned,
+ * leaving a "Task started" row in the trace. When the task later finishes,
+ * its terminal state (completed / failed / killed, exit code, duration,
+ * output tail) is landed on that same launch row by task id, so the reader
+ * sees the outcome where the command was issued rather than as a detached
+ * row appended after the assistant's answer.
+ *
+ * A synthetic terminal row is only produced when no launch row exists (the
+ * transcript was cleared, or the task was started outside this transcript).
+ */
+import type { BackgroundTaskInfo } from "../../tasks/manager.js";
+import { type DisplayMessage, type DisplayToolCall } from "./display-history.js";
+/**
+ * Occurrence for a restored terminal marker whose task_started marker is not
+ * in the retained log (the task was launched before a conversation_clear).
+ * It must never land on a later launch that happens to reuse the task id.
+ */
+export declare const UNMATCHED_LAUNCH = -1;
+export interface TaskLifecycleTerminal {
+    task: BackgroundTaskInfo;
+    output?: string;
+    /**
+     * Which launch of this task id the terminal state belongs to (0-based, in
+     * transcript order), or UNMATCHED_LAUNCH. Task ids restart at task_0001 in
+     * every process, so a resumed session can hold several launches sharing
+     * one id; persisted markers carry their launch order. Omitted for live
+     * completions, which always belong to the newest launch not settled yet.
+     */
+    occurrence?: number;
+}
+/** Returns a copy of `tool` carrying the task's terminal state. */
+export declare function applyTaskLifecycleToTool(tool: DisplayToolCall, task: BackgroundTaskInfo, output?: string): DisplayToolCall;
+/**
+ * Lands the terminal state on a launch row that is still in the streaming
+ * accumulator. Mutates in place because the accumulator's parts share the
+ * same tool objects. A row whose tool_end has not arrived yet is skipped:
+ * the reducer would overwrite the merge when the result lands.
+ */
+export declare function mergeTaskLifecycleIntoLiveTools(tools: DisplayToolCall[], task: BackgroundTaskInfo, output?: string): boolean;
+/**
+ * Lands the terminal state on exactly one committed launch row: the given
+ * launch occurrence, or (for live completions) the newest one still open.
+ */
+export declare function applyTaskLifecycleToMessages(messages: DisplayMessage[], task: BackgroundTaskInfo, output?: string, occurrence?: number): {
+    messages: DisplayMessage[];
+    merged: boolean;
+};
+/** Detached terminal row for a task whose launch row is not in the transcript. */
+export declare function taskLifecycleDisplayMessage(task: BackgroundTaskInfo, output?: string): DisplayMessage;
+/**
+ * Lands every terminal state on its launch row; tasks without one get a
+ * detached row appended in the given order.
+ */
+export declare function landTaskLifecycles(messages: DisplayMessage[], terminals: TaskLifecycleTerminal[]): DisplayMessage[];