@fungi.computer/parakeet 0.5.0 → 0.6.1

package/dist/core/session-projection.d.ts

@@ -8,4 +8,5 @@ export declare function mergeTerminals(current: readonly SessionTerminal[], inco
 export declare function mergeCompactions(current: readonly SessionCompactionMarker[], incoming: readonly SessionCompactionMarker[]): readonly SessionCompactionMarker[];
 /** Accumulate compaction notices by identity; a frame never removes one. */
 export declare function mergeCompactionNotices(current: readonly SessionCompactionNotice[], incoming: readonly SessionCompactionNotice[]): readonly SessionCompactionNotice[];
+/** Apply one already-decoded Shiitake frame to its authoritative projection. */
 export declare function applySessionFrame(current: SessionSnapshot, frame: SessionFrame): SessionSnapshot;

package/dist/core/session-projection.js

@@ -1,3 +1,4 @@
+import { appendSessionProgress } from "@fungi.computer/shiitake/client";
 import { sameRunningWork } from "./session-view-state.js";
 const durableMessageIds = new WeakMap();
 /** Derive completed durable message identity once per immutable history revision. */
@@ -103,11 +104,11 @@ function sameActivity(left, right) {
                     right.compaction !== null &&
                     left.compaction.trigger === right.compaction.trigger))));
 }
-/** Apply one already-decoded Shiitake frame to its authoritative projection. */
 /** Extension slots are small JSON values; compare them by content. */
 function sameExtensionSlots(next, current) {
     return next === current || JSON.stringify(next) === JSON.stringify(current);
 }
+/** Apply one already-decoded Shiitake frame to its authoritative projection. */
 export function applySessionFrame(current, frame) {
     if (frame.kind === "reset")
         return {
@@ -149,7 +150,7 @@ export function applySessionFrame(current, frame) {
             return activity === current.activity ? current : { ...current, activity };
         return {
             ...current,
-            progress: frame.progress,
+            progress: appendSessionProgress(current.progress, frame.progress),
             activity,
         };
     }

package/dist/core/session-view-state.d.ts

@@ -56,10 +56,8 @@ export type SessionActivityStatus = "cancelling" | "idle" | "queued" | "retrying
 /** Decide a Session's view state from its activity, terminals and progress. */
 export declare function sessionViewState(facts: SessionViewFacts): SessionViewState;
 export declare function sameRunningWork(left: AgentRunningWork | null, right: AgentRunningWork | null): boolean;
-/** Explain a queued Session using its owner's executor fact. */
-export declare function queuedSessionLabel(state: Extract<SessionViewState, {
-    kind: "queued";
-}>): string;
+/** Activity only: queued messages belong in the transcript, never in this label. */
+export declare function sessionStateLabel(state: SessionViewState, waitingOnYou?: boolean): "thinking" | "streaming" | "running a tool" | "idle" | "waiting on you" | "cancelling" | "failed";
 /** Whether two view states say the same thing, so a readout can stay stable. */
 export declare function sameSessionViewState(left: SessionViewState, right: SessionViewState): boolean;
 /** Coarse activity for a view state: what the composer gates on. */

package/dist/core/session-view-state.js

@@ -66,20 +66,40 @@ export function sessionViewState(facts) {
 export function sameRunningWork(left, right) {
     if (left === null || right === null)
         return left === right;
-    if (left.kind === "session" && right.kind === "session")
-        return (left.sessionId === right.sessionId && left.commandId === right.commandId);
-    if (left.kind === "host" && right.kind === "host")
-        return left.lane === right.lane && left.jobId === right.jobId;
-    return false;
+    return left.phase === right.phase;
 }
-/** Explain a queued Session using its owner's executor fact. */
-export function queuedSessionLabel(state) {
-    const work = state.runningWork;
-    if (work === null)
-        return "Queued for host";
-    return work.kind === "session"
-        ? `Waiting for Session ${collapsed(work.sessionId, 256)}`
-        : `Waiting for host job ${collapsed(work.lane, 256)} · ${collapsed(work.jobId, 256)}`;
+const occupancyLabels = {
+    thinking: "thinking",
+    streaming: "streaming",
+    running_tool: "running a tool",
+    waiting_on_you: "waiting on you",
+    cancelling: "cancelling",
+};
+/** Activity only: queued messages belong in the transcript, never in this label. */
+export function sessionStateLabel(state, waitingOnYou = false) {
+    switch (state.kind) {
+        case "queued":
+            return state.runningWork === null
+                ? "idle"
+                : occupancyLabels[state.runningWork.phase];
+        case "thinking":
+        case "compacting":
+        case "retrying":
+            return "thinking";
+        case "cancelling":
+            return "cancelling";
+        case "responding":
+            return "streaming";
+        case "running_tool":
+            return "running a tool";
+        case "error":
+            return "failed";
+        case "idle":
+        case "waiting_for_you":
+            // A completed turn is idle; an actual attention/approval request is
+            // what makes the caller show "waiting on you".
+            return waitingOnYou ? "waiting on you" : "idle";
+    }
 }
 /** Whether two view states say the same thing, so a readout can stay stable. */
 export function sameSessionViewState(left, right) {

package/dist/core/tool-groups.d.ts

@@ -1,5 +1,8 @@
 import type { ProjectedItem, TimelineItem, ToolGroupItem, ToolItem } from "../store/types.js";
 import { type ToolCallView } from "./tool-view.js";
+import type { SessionToolOutput } from "@fungi.computer/shiitake/client";
+/** Overlay only running calls; settled rows and their lazy result views stay shared. */
+export declare function overlayToolOutput(items: readonly TimelineItem[], output: readonly SessionToolOutput[]): readonly TimelineItem[];
 /** Build one group from a non-empty run of consecutive calls. */
 export declare function toolGroup(tools: readonly [ToolItem, ...ToolItem[]]): ToolGroupItem;
 /**

package/dist/core/tool-groups.js

@@ -1,5 +1,41 @@
 import { assistantMessageVisible } from "./assistant-visibility.js";
-import { toolCallView } from "./tool-view.js";
+import { liveOutputLines, toolCallView, } from "./tool-view.js";
+/** Overlay only running calls; settled rows and their lazy result views stay shared. */
+export function overlayToolOutput(items, output) {
+    if (output.length === 0)
+        return items;
+    return items.map((item) => {
+        if (item.kind !== "tool_group")
+            return item;
+        const tools = item.tools.map((tool) => {
+            const slot = output.find((candidate) => candidate.toolCallId === tool.id);
+            if (tool.status !== "running" || slot === undefined)
+                return tool;
+            return {
+                ...tool,
+                live: {
+                    lines: liveOutputLines(slot.tail),
+                    droppedBytes: slot.droppedBytes,
+                    revision: slot.revision,
+                },
+            };
+        });
+        if (tools.every((tool, index) => tool === item.tools[index]))
+            return item;
+        const calls = item.calls.map((call, index) => {
+            const tool = tools[index];
+            return tool === undefined || tool === item.tools[index]
+                ? call
+                : toolCallView(tool);
+        });
+        return {
+            ...item,
+            tools,
+            calls,
+            active: calls.find((call) => call.id === item.active?.id),
+        };
+    });
+}
 const nouns = {
     code: ["ran", "script", "scripts"],
     command: ["ran", "command", "commands"],

package/dist/core/tool-view.d.ts

@@ -173,7 +173,13 @@ export type ToolCallView = Readonly<{
     error?: string | undefined;
     /** Expanded body sections, in display order. */
     sections: readonly ToolCallSection[];
+    /** Replaceable output while the call runs. */
+    live?: ToolItem["live"];
 }>;
+/** Neutral lines from a bounded live tail. */
+export declare function liveOutputLines(tail: string): readonly string[];
+/** Live output stays visible when folded, independent of result disclosure. */
+export declare function toolLiveLines(call: ToolCallView, open: boolean): readonly string[];
 /** Items shown before "more" for excerpts, matches, and output. */
 export declare const toolPreviewLineLimit = 12;
 /** Build the renderer-neutral view of one call. */

package/dist/core/tool-view.js

@@ -4,6 +4,7 @@ import { formatPatch, parsePatch, structuredPatch, } from "diff";
 import { z } from "zod";
 import stripAnsi from "strip-ansi";
 import { reportFailure } from "../lib/failure.js";
+import { sanitizeDisplayText } from "./display-text.js";
 /** Shared tool status meaning, used by the browser and native presentations. */
 export function toolStatusTone(status) {
     if (status === "error")
@@ -27,6 +28,37 @@ export const toolKindSigils = {
     /** Artwork for search results. */
     search: "search",
 };
+/** Neutral lines from a bounded live tail. */
+export function liveOutputLines(tail) {
+    if (tail === "")
+        return [];
+    // Replacement dominance counts decoded code points, not rendered graphemes.
+    const characters = Array.from(tail);
+    if (characters.filter((character) => character === "\ufffd").length >
+        characters.length / 2)
+        return [
+            `[binary output, ${String(new TextEncoder().encode(tail).byteLength)} bytes]`,
+        ];
+    return stripAnsi(tail)
+        .replace(/\r\n/gu, "\n")
+        .replace(/\n$/u, "")
+        .split("\n")
+        .map((line) => sanitizeDisplayText(line.slice(line.lastIndexOf("\r") + 1)));
+}
+/** Live output stays visible when folded, independent of result disclosure. */
+export function toolLiveLines(call, open) {
+    const live = call.live;
+    if (live === undefined)
+        return [];
+    if (!open)
+        return live.lines.slice(-6);
+    return [
+        ...(live.droppedBytes === 0
+            ? []
+            : [`… ${String(Math.ceil(live.droppedBytes / 1024))} KiB earlier`]),
+        ...live.lines,
+    ];
+}
 /** Items shown before "more" for excerpts, matches, and output. */
 export const toolPreviewLineLimit = 12;
 /** Diff lines shown before "more". */
@@ -600,6 +632,7 @@ export function toolCallView(item) {
         kind,
         label: target.label,
         name: item.name,
+        live: item.status === "running" ? item.live : undefined,
         paths: target.paths,
         get sections() {
             return getDetails().sections;

package/dist/core/use-timeline-item-key.d.ts

@@ -1,8 +1,7 @@
 import type { TimelineItem } from "../store/types.js";
 /**
- * The virtualizer's row-key callback. Text-only progress replaces tail items
- * but not their keys, so the callback keeps its identity, and the virtualizer
- * its measurements, until the settled history or the order or identity of the
- * tail rows changes. Settled rows are keyed from the settled list alone.
+ * The virtualizer's row-key callback. Progress replaces row payloads, including
+ * live overlays on settled calls, but not row keys. Keep the callback and its
+ * measurements until the order or identity of the combined rows changes.
  */
 export declare function useTimelineItemKey(settled: readonly TimelineItem[], tail: readonly TimelineItem[]): (index: number) => string | number;

package/dist/core/use-timeline-item-key.js

@@ -9,21 +9,15 @@ function sameKeys(a, b) {
     return a.length === b.length && a.every((key, index) => key === b[index]);
 }
 /**
- * The virtualizer's row-key callback. Text-only progress replaces tail items
- * but not their keys, so the callback keeps its identity, and the virtualizer
- * its measurements, until the settled history or the order or identity of the
- * tail rows changes. Settled rows are keyed from the settled list alone.
+ * The virtualizer's row-key callback. Progress replaces row payloads, including
+ * live overlays on settled calls, but not row keys. Keep the callback and its
+ * measurements until the order or identity of the combined rows changes.
  */
 export function useTimelineItemKey(settled, tail) {
-    const next = tail.map(rowKey);
+    const next = [...settled, ...tail].map(rowKey);
     const [previous, setPrevious] = useState(next);
-    const tailKeys = sameKeys(previous, next) ? previous : next;
-    if (tailKeys !== previous)
-        setPrevious(tailKeys);
-    return useCallback((index) => {
-        const item = settled[index];
-        if (item !== undefined)
-            return rowKey(item);
-        return tailKeys[index - settled.length] ?? index;
-    }, [settled, tailKeys]);
+    const keys = sameKeys(previous, next) ? previous : next;
+    if (keys !== previous)
+        setPrevious(keys);
+    return useCallback((index) => keys[index] ?? index, [keys]);
 }

package/dist/headless.d.ts

@@ -1,12 +1,13 @@
 export { formatModelIdentity, formatModelWithLevel, } from "./core/model-identity.js";
 export type { QueuedRecallState, QueuedRecallOutcome, } from "./core/queued-recall.js";
 export type { ParakeetDraftIdentity, ParakeetDraftStorage, } from "./core/draft-storage.js";
+export { sanitizeDisplayText } from "./core/display-text.js";
 export { formatContextUsage, formatTokenCount } from "./core/format-context.js";
 export { formatWhen, oneLine } from "./core/picker-text.js";
 export { providerChoices } from "./provider-choices.js";
 export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useLastSessionReplyAt, useStatus, useTimeline, type ComposerController, type ParakeetDraftCheckpoint, type ParakeetModel, type ParakeetObservation, type ParakeetReconnectOutcome, type ParakeetStatus, type ParakeetSessionViewState, type ParakeetUsage, type StatusController, type TimelineController, } from "./conversation.js";
-export { sessionViewState, queuedSessionLabel, sessionActivityStatus, type SessionActivityStatus, type SessionViewFacts, type SessionViewState as ParakeetOwnerViewState, } from "./core/session-view-state.js";
-export { mergeTerminals } from "./core/session-projection.js";
+export { sessionViewState, sessionStateLabel, sessionActivityStatus, type SessionActivityStatus, type SessionViewFacts, type SessionViewState as ParakeetOwnerViewState, } from "./core/session-view-state.js";
+export { applySessionFrame, mergeTerminals, } from "./core/session-projection.js";
 export { type SessionActivity, seedSessionQuery, sessionQueryOptions, subscribeSessionActivity, } from "./core/session-query.js";
 export { accountCommandDefinitions, contributeAccountCommands, loginRegistry, type AccountCommandOptions, type AccountOwner, type ProviderAccess, type ModelAccountContext, type LoginHost, type LoginMethod, type LoginMethodKind, type LoginPolicy, type LoginProvider, type LoginScope, } from "./account-commands.js";
 export { contributeModelCommands, sessionModelCommandDefinitions, type SessionModelChoice, type SessionModelCommandOptions, } from "./model-commands.js";
@@ -23,7 +24,7 @@ export type { ParakeetSession, ParakeetSessionCommand, ParakeetPromptResult, } f
 export type { AssistantMessageItem as ParakeetAssistantMessageItem, TimelineItem as ParakeetTimelineItem, ToolGroupItem as ParakeetToolGroupItem, ToolItem as ParakeetToolItem, UserMessageItem as ParakeetUserMessageItem, } from "./store/types.js";
 export type { ToolArguments as ParakeetToolArguments } from "./core/tool-contract.js";
 export { useMarkdown, type MarkdownBlock, type MarkdownInline, } from "./markdown.js";
-export { formatToolDuration, toolCallView, toolKindSigils, toolStatusTone, type ToolCallSection as ParakeetToolCallSection, type ToolCallView as ParakeetToolCallView, type ToolDiffFile as ParakeetToolDiffFile, type ToolDiffHunk as ParakeetToolDiffHunk, type ToolDiffLine as ParakeetToolDiffLine, type ToolDiffRow as ParakeetToolDiffRow, type ToolExcerptLine as ParakeetToolExcerptLine, type ToolKind as ParakeetToolKind, type ToolMatch as ParakeetToolMatch, type ToolOutputLine as ParakeetToolOutputLine, } from "./core/tool-view.js";
+export { formatToolDuration, toolCallView, toolKindSigils, toolLiveLines, toolStatusTone, type ToolCallSection as ParakeetToolCallSection, type ToolCallView as ParakeetToolCallView, type ToolDiffFile as ParakeetToolDiffFile, type ToolDiffHunk as ParakeetToolDiffHunk, type ToolDiffLine as ParakeetToolDiffLine, type ToolDiffRow as ParakeetToolDiffRow, type ToolExcerptLine as ParakeetToolExcerptLine, type ToolKind as ParakeetToolKind, type ToolMatch as ParakeetToolMatch, type ToolOutputLine as ParakeetToolOutputLine, } from "./core/tool-view.js";
 export { assistantMessageVisible } from "./core/assistant-visibility.js";
 export { disclosureOpen, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, type ToolDisclosureState, } from "./core/tool-groups.js";
 export { useClientActions } from "./client-contributions.js";

package/dist/headless.js

@@ -1,10 +1,11 @@
 export { formatModelIdentity, formatModelWithLevel, } from "./core/model-identity.js";
+export { sanitizeDisplayText } from "./core/display-text.js";
 export { formatContextUsage, formatTokenCount } from "./core/format-context.js";
 export { formatWhen, oneLine } from "./core/picker-text.js";
 export { providerChoices } from "./provider-choices.js";
 export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useLastSessionReplyAt, useStatus, useTimeline, } from "./conversation.js";
-export { sessionViewState, queuedSessionLabel, sessionActivityStatus, } from "./core/session-view-state.js";
-export { mergeTerminals } from "./core/session-projection.js";
+export { sessionViewState, sessionStateLabel, sessionActivityStatus, } from "./core/session-view-state.js";
+export { applySessionFrame, mergeTerminals, } from "./core/session-projection.js";
 export { seedSessionQuery, sessionQueryOptions, subscribeSessionActivity, } from "./core/session-query.js";
 export { accountCommandDefinitions, contributeAccountCommands, loginRegistry, } from "./account-commands.js";
 export { contributeModelCommands, sessionModelCommandDefinitions, } from "./model-commands.js";
@@ -18,7 +19,7 @@ export { parakeetBuiltinCommands, } from "./commands/builtins.js";
 export { advertisedCommands, } from "./commands/advertised.js";
 export { useSlashCommands, } from "./commands/use-slash-commands.js";
 export { useMarkdown, } from "./markdown.js";
-export { formatToolDuration, toolCallView, toolKindSigils, toolStatusTone, } from "./core/tool-view.js";
+export { formatToolDuration, toolCallView, toolKindSigils, toolLiveLines, toolStatusTone, } from "./core/tool-view.js";
 export { assistantMessageVisible } from "./core/assistant-visibility.js";
 export { disclosureOpen, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./core/tool-groups.js";
 export { useClientActions } from "./client-contributions.js";

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatModelWithLevel, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
 export { Parakeet, ParakeetView } from "./parakeet.js";
+export { ComposerModelKey, type ComposerModelKeyProps, } from "./components/ComposerModelKey.js";
+export { composerSendState } from "./components/ComposerShell.js";
+export { ComposerShell, useComposerTextareaSize, type ComposerShellProps, type ComposerShellRow, } from "./components/ComposerShell.js";
 export type { ParakeetVisitor } from "./parakeet.js";
 export { InteractionPanel, type InteractionPanelProps, } from "./components/InteractionPanel.js";
 export type { QueuedRecallState, QueuedRecallOutcome, ParakeetAssistantMessageItem, ComposerController, ParakeetDraftCheckpoint, ParakeetDraftIdentity, ParakeetDraftStorage, ParakeetModel, ParakeetSession, ParakeetStatus, ParakeetTimelineItem, ParakeetToolArguments, ParakeetToolCallSection, ParakeetToolCallView, ParakeetToolDiffFile, ParakeetToolDiffHunk, ParakeetToolDiffLine, ParakeetToolDiffRow, ParakeetToolExcerptLine, ParakeetToolMatch, ParakeetToolOutputLine, ParakeetToolGroupItem, ParakeetToolItem, ParakeetToolKind, ToolDisclosureState, ParakeetUsage, ParakeetUserMessageItem, StatusController, TimelineController, MarkdownBlock, MarkdownInline, } from "./headless.js";

package/dist/index.js

@@ -1,4 +1,7 @@
 export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatModelWithLevel, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
 export { Parakeet, ParakeetView } from "./parakeet.js";
+export { ComposerModelKey, } from "./components/ComposerModelKey.js";
+export { composerSendState } from "./components/ComposerShell.js";
+export { ComposerShell, useComposerTextareaSize, } from "./components/ComposerShell.js";
 export { InteractionPanel, } from "./components/InteractionPanel.js";
 export * from "./agent-head.js";

package/dist/parakeet.js

@@ -15,7 +15,6 @@ import { ClientRows } from "./components/ClientRows.js";
 import { useClientActions } from "./client-contributions.js";
 import { placeClientTimeline } from "./core/client-timeline.js";
 import { InteractionPanel } from "./components/InteractionPanel.js";
-import { WaitingNotice } from "./components/WaitingNotice.js";
 import { useSlashCommands, } from "./commands/use-slash-commands.js";
 import { TimelineItem } from "./components/TimelineItem.js";
 import { MarkdownPolicyContext } from "./components/MarkdownRenderer.js";
@@ -168,7 +167,7 @@ function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focu
         timelineController.jumpToLatest();
         timeline.scrollToEnd({ behavior: "smooth" });
     }, [timeline, timelineController]);
-    return (_jsxs("div", { className: "prose relative min-h-0 flex-1", children: [_jsx("div", { "aria-live": "polite", "aria-atomic": "true", className: "sr-only", children: sessionReadout(sessionStatus.status, sessionStatus.viewState) }), sessionStatus.observation.status === "unavailable" ? (_jsxs("div", { className: "flex items-center justify-between gap-2 px-3 py-1 text-xs text-dim", role: "status", children: [_jsx("span", { children: sessionStatus.observation.reason }), _jsx("button", { className: "underline", onClick: () => void sessionStatus.reconnect(), type: "button", children: "Reconnect" })] })) : null, _jsx("div", { className: "h-full min-h-0 overflow-y-auto", "data-chat-scroller": true, ref: scrollerRef, onScroll: (event) => {
+    return (_jsxs("div", { className: "prose relative min-h-0 flex-1", children: [_jsx("div", { "aria-live": "polite", "aria-atomic": "true", className: "sr-only", children: sessionReadout(sessionStatus.status, sessionStatus.viewState) }), sessionStatus.observation.status === "unavailable" ? (_jsxs("div", { className: "flex items-center justify-between gap-2 px-3 py-1 text-xs text-dim", role: "status", children: [_jsx("span", { children: sessionStatus.observation.reason }), _jsx(Button, { variant: "outline", size: "xs", onClick: () => void sessionStatus.reconnect(), type: "button", children: "Reconnect" })] })) : null, _jsx("div", { className: "h-full min-h-0 overflow-y-auto", "data-chat-scroller": true, ref: scrollerRef, onScroll: (event) => {
                     const top = event.currentTarget.scrollTop;
                     if (previousScrollTop.current !== undefined &&
                         top < previousScrollTop.current)
@@ -220,21 +219,20 @@ function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focu
                                         : item, onDismissFailed: dismissFailed, onCancelQueued: cancelQueued, cancellingQueued: timelineController.cancellingQueued, onToggleTool: toggleTool, renderToolActions: renderToolActions, claimsToolMedia: claimsToolMedia, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText, toolDisclosure: toolDisclosure }), placed.after.get(item.id)?.map(({ entryId, cell }) => (_jsx(ClientRows, { entryId: entryId, rows: cell.rows, actions: clientActions, onOpen: onOpen }, `${entryId}:${cell.id}`)))] }, virtualItem.key));
                     }) })) : before.length > 0 ? (before) : hasMoreHistory ? null : ((empty ?? (_jsx("div", { className: "flex h-full items-center justify-center text-center", children: _jsxs("div", { children: [_jsx("p", { className: "mb-1 text-xs text-base-content", children: "Ready" }), _jsx("p", { className: "text-[10px] text-dim", children: "What would you like to build?" })] }) })))) }), count > 0 ? (_jsx(ScrollToBottomBlob, { direction: "forward", unread: unread, focusAfterJump: focusAfterJump, onJump: jumpToBottom, scrollerRef: scrollerRef })) : null] }));
 }
-/** The owner's queued state and independently contributed waiting controls. */
+/** Independently contributed waiting controls; queued messages stay in the transcript. */
 function ConversationWaiting({ clientActions, }) {
     const { viewState } = useStatus();
     const contributions = useClientContributions();
     const extensionWaiting = viewState.kind === "idle"
         ? contributions.find(({ value }) => value.waiting !== null)
         : undefined;
-    const waiting = viewState.kind === "queued" ? viewState : null;
-    return (_jsxs(_Fragment, { children: [extensionWaiting?.value.waiting === undefined ||
-                extensionWaiting.value.waiting === null ? null : (_jsxs("div", { className: "flex items-center gap-2 px-3 text-xs", children: [_jsx("span", { children: extensionWaiting.value.waiting.summary }), _jsx(Button, { size: "xs", variant: "outline", disabled: !clientActions.enabled ||
-                            clientActions.state.get(extensionWaiting.value.waiting.cancel)
-                                ?.pending === true, onClick: () => {
-                            if (extensionWaiting.value.waiting !== null)
-                                void clientActions.execute(extensionWaiting.entryId, extensionWaiting.value.waiting.cancel, true);
-                        }, children: extensionWaiting.value.waiting.cancel.label })] })), _jsx(WaitingNotice, { waiting: waiting })] }));
+    return (_jsx(_Fragment, { children: extensionWaiting?.value.waiting === undefined ||
+            extensionWaiting.value.waiting === null ? null : (_jsxs("div", { className: "flex items-center gap-2 px-3 text-xs", children: [_jsx("span", { children: extensionWaiting.value.waiting.summary }), _jsx(Button, { size: "xs", variant: "outline", disabled: !clientActions.enabled ||
+                        clientActions.state.get(extensionWaiting.value.waiting.cancel)
+                            ?.pending === true, onClick: () => {
+                        if (extensionWaiting.value.waiting !== null)
+                            void clientActions.execute(extensionWaiting.entryId, extensionWaiting.value.waiting.cancel, true);
+                    }, children: extensionWaiting.value.waiting.cancel.label })] })) }));
 }
 function ConversationComposer({ visitor, textareaRef, composerActionVariant, slash, }) {
     const composer = useComposer();

package/dist/store/types.d.ts

@@ -105,6 +105,15 @@ export type ToolItem = Readonly<{
     startedAt?: number;
     /** Owner-confirmed activity or result; unknown when neither is available. */
     status: "completed" | "error" | "running" | "unknown";
+    /** Replaceable display-only output, never part of the durable result. */
+    live?: Readonly<{
+        /** Neutral output lines. */
+        lines: readonly string[];
+        /** Raw producer bytes omitted before this tail. */
+        droppedBytes: number;
+        /** Owner-issued output revision. */
+        revision: number;
+    }>;
 }>;
 /**
  * One maximal run of consecutive tool calls between conversation rows. A lone