@fungi.computer/parakeet 0.1.0 → 0.2.0

package/dist/core/author-labels.d.ts

@@ -5,6 +5,8 @@ export type ParakeetAuthor = Readonly<{
     id: string;
     /** The name shown beside the line. */
     name: string;
+    /** Another Agent wrote the line; it shows as a compact block, not a bubble. */
+    kind?: "agent" | undefined;
 }>;
 /**
  * The host's reading of a message's opaque metadata: the author to show, or

package/dist/core/build-timeline.d.ts

@@ -20,6 +20,8 @@ export type PromptRequestIdOf = (commandId: string) => string | undefined;
 export type DurableTimelineProjection = TimelineProjection & Readonly<{
     completedMessageIds: ReadonlySet<string>;
     commandIds: ReadonlySet<string>;
+    requestIds: ReadonlySet<string>;
+    positionAnchors: ReadonlyMap<number, string | null>;
     commandAnchors: ReadonlyMap<string, string>;
 }>;
 /**
@@ -29,8 +31,8 @@ export type DurableTimelineProjection = TimelineProjection & Readonly<{
  * that changed nothing. The model's own context is unaffected by this purely
  * client-side projection.
  */
-export declare function buildDurableTimeline(messages: readonly SessionMessage[], compactions?: readonly SessionCompactionMarker[], activity?: SessionActivity, authorOf?: ParakeetAuthorOf, requestIdOf?: PromptRequestIdOf, notices?: readonly SessionCompactionNotice[]): DurableTimelineProjection;
+export declare function buildDurableTimeline(messages: readonly SessionMessage[], compactions?: readonly SessionCompactionMarker[], activity?: SessionActivity, authorOf?: ParakeetAuthorOf, requestIdOf?: PromptRequestIdOf, notices?: readonly SessionCompactionNotice[], positions?: readonly number[], shown?: (item: TimelineItem) => boolean): DurableTimelineProjection;
 /** Project replaceable live work without copying settled history. */
-export declare function buildTimelineTail(durable: DurableTimelineProjection, progress: SessionProgress | null, queued: readonly SessionPendingPrompt[], admissions?: readonly LocalPromptAdmission[], authorOf?: ParakeetAuthorOf, requestIdOf?: PromptRequestIdOf): readonly TimelineItem[];
+export declare function buildTimelineTail(durable: DurableTimelineProjection, progress: SessionProgress | null, queued: readonly SessionPendingPrompt[], admissions?: readonly LocalPromptAdmission[], authorOf?: ParakeetAuthorOf): readonly TimelineItem[];
 /** Overlay live progress and an optimistic prompt over stable durable rows. */
 export declare function buildTimeline(durable: DurableTimelineProjection, progress: SessionProgress | null, queued: readonly SessionPendingPrompt[], admissions?: readonly LocalPromptAdmission[]): TimelineProjection;

package/dist/core/build-timeline.js

@@ -118,7 +118,7 @@ function appendAssistant(items, toolIndexes, assistant) {
         items.push(item);
     }
 }
-function completeTool(items, toolIndexes, value) {
+function completeTool(items, toolIndexes, value, data) {
     const toolIndex = toolIndexes.get(value.toolCallId);
     if (toolIndex === undefined)
         return;
@@ -128,6 +128,7 @@ function completeTool(items, toolIndexes, value) {
     items[toolIndex] = {
         ...tool,
         result: value,
+        data,
         status: value.isError ? "error" : "completed",
     };
 }
@@ -138,16 +139,18 @@ function completeTool(items, toolIndexes, value) {
  * that changed nothing. The model's own context is unaffected by this purely
  * client-side projection.
  */
-export function buildDurableTimeline(messages, compactions = [], activity, authorOf = noAuthor, requestIdOf = noRequestId, notices = []) {
+export function buildDurableTimeline(messages, compactions = [], activity, authorOf = noAuthor, requestIdOf = noRequestId, notices = [], positions = [], shown = () => true) {
     const items = [];
     const toolIndexes = new Map();
     const commandIds = new Set();
+    const itemSequences = new Map();
     const itemCommands = new Map();
     let model;
     let tokens = 0;
     let cost = 0;
     for (const source of orderedSources(messages, compactions, notices)) {
         if (source.kind === "marker") {
+            itemSequences.set(source.marker.id, source.sequence);
             items.push({
                 id: source.marker.id,
                 kind: "compaction_divider",
@@ -158,6 +161,7 @@ export function buildDurableTimeline(messages, compactions = [], activity, autho
             continue;
         }
         if (source.kind === "notice") {
+            itemSequences.set(source.notice.id, source.sequence);
             items.push({
                 id: source.notice.id,
                 kind: "compaction_notice",
@@ -186,7 +190,7 @@ export function buildDurableTimeline(messages, compactions = [], activity, autho
                     author: authorOf(message.meta),
                     origin: message.origin,
                 };
-                items.push(withRequestId(confirmed, requestIdOf(commandId)));
+                items.push(withRequestId(confirmed, message.requestId ?? requestIdOf(commandId)));
                 break;
             }
             case "assistant": {
@@ -198,7 +202,7 @@ export function buildDurableTimeline(messages, compactions = [], activity, autho
                 break;
             }
             case "toolResult":
-                completeTool(items, toolIndexes, value);
+                completeTool(items, toolIndexes, value, message.data);
                 if (message.commandId !== null) {
                     const commands = itemCommands.get(value.toolCallId) ?? new Set();
                     commands.add(message.commandId);
@@ -206,6 +210,8 @@ export function buildDurableTimeline(messages, compactions = [], activity, autho
                 }
                 break;
         }
+        for (const item of items.slice(firstItem))
+            itemSequences.set(item.id, source.sequence);
         if (message.commandId !== null) {
             for (const item of items.slice(firstItem))
                 itemCommands.set(item.id, new Set([message.commandId]));
@@ -234,7 +240,18 @@ export function buildDurableTimeline(messages, compactions = [], activity, autho
         if (active?.kind === "tool")
             items[toolIndex] = { ...active, status: "running" };
     }
-    const grouped = groupToolCalls(items);
+    // Later calls must not grow a tool group across a committed event.
+    const breakBefore = new Set();
+    let previousSequence = 0;
+    for (const item of items) {
+        const sequence = itemSequences.get(item.id);
+        if (sequence === undefined)
+            continue;
+        if (positions.some((position) => previousSequence <= position && position < sequence))
+            breakBefore.add(item.id);
+        previousSequence = sequence;
+    }
+    const grouped = groupToolCalls(items, breakBefore);
     const commandAnchors = new Map();
     for (const row of grouped) {
         if (row.kind === "assistant_message" && !assistantMessageVisible(row))
@@ -244,18 +261,37 @@ export function buildDurableTimeline(messages, compactions = [], activity, autho
             for (const command of itemCommands.get(member.id) ?? [])
                 commandAnchors.set(command, row.id);
     }
+    const positionAnchors = new Map();
+    for (const position of positions) {
+        let anchor = null;
+        for (const row of grouped) {
+            if (!shown(row))
+                continue;
+            if (row.kind === "assistant_message" && !assistantMessageVisible(row))
+                continue;
+            const members = row.kind === "tool_group" ? row.tools : [row];
+            if (members.some((member) => {
+                const sequence = itemSequences.get(member.id);
+                return sequence !== undefined && sequence <= position;
+            }))
+                anchor = row.id;
+        }
+        positionAnchors.set(position, anchor);
+    }
     const base = {
         commandAnchors,
+        positionAnchors,
         completedMessageIds: completedMessageIds(messages),
         items: grouped,
         commandIds,
+        requestIds: new Set(messages.flatMap((message) => message.requestId === undefined ? [] : [message.requestId])),
     };
     return model === undefined
         ? base
         : { ...base, model, usage: { cost, tokens } };
 }
 /** Project replaceable live work without copying settled history. */
-export function buildTimelineTail(durable, progress, queued, admissions = [], authorOf = noAuthor, requestIdOf = noRequestId) {
+export function buildTimelineTail(durable, progress, queued, admissions = [], authorOf = noAuthor) {
     const visibleProgress = progress === null ||
         durable.completedMessageIds.has(progress.messageId) ||
         (progress.text === "" && progress.thinking === "")
@@ -280,9 +316,12 @@ export function buildTimelineTail(durable, progress, queued, admissions = [], au
             origin: prompt.origin,
             author: authorOf(prompt.meta),
         };
-        items.push(withRequestId(waiting, requestIdOf(prompt.commandId)));
+        items.push(withRequestId(waiting, prompt.requestId));
     }
     for (const admission of admissions) {
+        if (durable.requestIds.has(admission.requestId) ||
+            queued.some((prompt) => prompt.requestId === admission.requestId))
+            continue;
         if (admission.commandId !== undefined &&
             (queuedCommandIds.has(admission.commandId) ||
                 durable.commandIds.has(admission.commandId)))

package/dist/core/client-actions.js

@@ -69,13 +69,16 @@ export function createClientActions(options) {
                 return;
             publish(intent, { pending: true });
             const notificationOnly = {
+                // Waiting cancellation has no interactive retry surface.
+                run: (operation) => operation(),
                 signal: controller.signal,
                 prompt: () => Promise.reject(new WhistleActionError("client_waiting_prompt", "A waiting cancellation cannot request an answer")),
                 notify: (notice) => {
-                    if (retired())
+                    // A success only confirms the person's own action: no echo.
+                    if (retired() || notice.type === "success")
                         return;
-                    options.interactions.report({
-                        tone: notice.type === "success" ? "success" : "info",
+                    options.interactions.toast({
+                        variant: "info",
                         message: notice.type === "handoff"
                             ? (notice.message ?? notice.url)
                             : notice.message,

package/dist/core/client-timeline.d.ts

@@ -7,8 +7,15 @@ export type PlacedClientCell = Readonly<{
     /** Producer event, unchanged by host placement. */
     cell: ClientTimelineCellV1;
 }>;
-/** Page visibility follows real durable command anchors, never event time. */
-export declare function placeClientTimeline(entries: readonly ClientContribution[], anchors: ReadonlyMap<string, string>): {
+/** Fixed positions and command anchors follow loaded history, never event time. */
+export declare function placeClientTimeline(entries: readonly ClientContribution[], anchors: ReadonlyMap<string, string>, positions?: ReadonlyMap<number, string | null>): {
+    /** Events before the first visible row of the root history page. */
+    before: Readonly<{
+        /** Namespace of the entry that produced this committed event. */
+        entryId: string;
+        /** Producer event, unchanged by host placement. */
+        cell: ClientTimelineCellV1;
+    }>[];
     /** Loaded durable row IDs mapped to their following committed events. */
     after: Map<string, Readonly<{
         /** Namespace of the entry that produced this committed event. */

package/dist/core/client-timeline.js

@@ -31,20 +31,29 @@ function mergeCells(cells) {
     }
     return merged;
 }
-/** Page visibility follows real durable command anchors, never event time. */
-export function placeClientTimeline(entries, anchors) {
+/** Fixed positions and command anchors follow loaded history, never event time. */
+export function placeClientTimeline(entries, anchors, positions = new Map()) {
     const anchored = new Map();
+    const before = [];
     const unanchored = [];
     for (const { entryId, value } of entries) {
         for (const cell of value.timeline.cells) {
             const placed = { entryId, cell };
-            if (cell.commandId === null) {
+            if (cell.afterSequence === undefined && cell.commandId === null) {
                 unanchored.push(placed);
                 continue;
             }
-            const itemId = anchors.get(cell.commandId);
+            const itemId = cell.afterSequence !== undefined
+                ? positions.get(cell.afterSequence)
+                : cell.commandId === null
+                    ? undefined
+                    : anchors.get(cell.commandId);
             if (itemId === undefined)
                 continue;
+            if (itemId === null) {
+                before.push(placed);
+                continue;
+            }
             const existing = anchored.get(itemId);
             if (existing === undefined)
                 anchored.set(itemId, [placed]);
@@ -53,6 +62,8 @@ export function placeClientTimeline(entries, anchors) {
         }
     }
     return {
+        /** Events before the first visible row of the root history page. */
+        before: mergeCells(before),
         /** Loaded durable row IDs mapped to their following committed events. */
         after: new Map([...anchored].map(([id, cells]) => [id, mergeCells(cells)])),
         /** Null-anchor events for the separate Extension changes section. */

package/dist/core/draft-storage.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+/** Durable owner identity, independent of the current service endpoint. */
+export type ParakeetDraftIdentity = Readonly<{
+    /** Agent that owns the Session. */
+    agentId: string;
+    /** Durable Session identity, not its transport address. */
+    sessionId: string;
+}>;
+/** Hosts must commit a replacement before returning, or throw without changing it. */
+export type ParakeetDraftStorage = Readonly<{
+    /** Read the complete journal, or null when no draft has been saved. */
+    getItem: (key: string) => string | null;
+    /** Atomically replace the journal; throw if it cannot be committed. */
+    setItem: (key: string, value: string) => void;
+}>;
+declare const journal: z.ZodObject<{
+    draft: z.ZodString;
+    images: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, z.core.$strip>>>>;
+    delivery: z.ZodOptional<z.ZodEnum<{
+        steer: "steer";
+        followUp: "followUp";
+    }>>;
+    recall: z.ZodOptional<z.ZodObject<{
+        commandId: z.ZodString;
+        requestId: z.ZodString;
+        text: z.ZodString;
+        images: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            data: z.ZodString;
+            mimeType: z.ZodString;
+        }, z.core.$strip>>>>;
+        delivery: z.ZodEnum<{
+            steer: "steer";
+            followUp: "followUp";
+        }>;
+    }, z.core.$strip>>;
+    pending: z.ZodArray<z.ZodObject<{
+        requestId: z.ZodString;
+        content: z.ZodString;
+        submittedDraft: z.ZodString;
+        delivery: z.ZodEnum<{
+            steer: "steer";
+            followUp: "followUp";
+        }>;
+        images: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            data: z.ZodString;
+            mimeType: z.ZodString;
+        }, z.core.$strip>>>>;
+        restoreDraft: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type DraftJournal = z.infer<typeof journal>;
+/** One owner-scoped journal commits pending text and composer text together. */
+export declare function draftJournal(scope: string, storage: ParakeetDraftStorage | undefined): {
+    read(): DraftJournal;
+    write(value: DraftJournal): void;
+};
+export {};

package/dist/core/draft-storage.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+const images = z
+    .array(z.object({
+    type: z.literal("image"),
+    data: z.string(),
+    mimeType: z.string(),
+}))
+    .readonly();
+const delivery = z.enum(["steer", "followUp"]);
+const recalledPrompt = z.object({
+    commandId: z.string(),
+    requestId: z.string(),
+    text: z.string(),
+    images: images.optional(),
+    delivery,
+});
+const pendingDraft = z.object({
+    requestId: z.string().min(1),
+    content: z.string(),
+    submittedDraft: z.string(),
+    delivery,
+    images: images.optional(),
+    restoreDraft: z.boolean(),
+});
+const journal = z.object({
+    draft: z.string(),
+    images: images.optional(),
+    delivery: delivery.optional(),
+    recall: recalledPrompt.optional(),
+    pending: z.array(pendingDraft).max(32),
+});
+/** One owner-scoped journal commits pending text and composer text together. */
+export function draftJournal(scope, storage) {
+    const key = `fungi.parakeet.drafts.v1:${scope}`;
+    return {
+        read() {
+            if (storage === undefined)
+                return { draft: "", pending: [] };
+            const saved = storage.getItem(key);
+            return saved === null
+                ? { draft: "", pending: [] }
+                : journal.parse(JSON.parse(saved));
+        },
+        write(value) {
+            if (storage === undefined)
+                throw new Error("Durable draft storage is unavailable");
+            storage.setItem(key, JSON.stringify(value));
+        },
+    };
+}

package/dist/core/model-identity.d.ts

@@ -1,3 +1,5 @@
 import type { ParakeetModel } from "../conversation.js";
 /** The durable assistant's provider/model ids, shared by browser and terminal. */
 export declare function formatModelIdentity(model: ParakeetModel): string;
+/** The model identity with its thinking level, "provider/model (level)"; no level, no suffix. */
+export declare function formatModelWithLevel(model: ParakeetModel, level: string | undefined): string;

package/dist/core/model-identity.js

@@ -5,3 +5,9 @@ export function formatModelIdentity(model) {
         ? model.model
         : `${prefix}${model.model}`;
 }
+/** The model identity with its thinking level, "provider/model (level)"; no level, no suffix. */
+export function formatModelWithLevel(model, level) {
+    return level === undefined
+        ? formatModelIdentity(model)
+        : `${formatModelIdentity(model)} (${level})`;
+}

package/dist/core/queued-recall.d.ts

@@ -0,0 +1,35 @@
+import type { SessionPendingPrompt, ShiitakeSession } from "@fungi.computer/shiitake/client";
+/** Ephemeral composer reservation, never an admission journal or queue. */
+export type QueuedRecallState = Readonly<{
+    /** Whether recall is available, reserved, or restored into the composer. */
+    kind: "idle" | "recalling" | "restored";
+}> | Readonly<{
+    /** A definitive refusal or an unresolved owner response. */
+    kind: "too_late" | "uncertain";
+    /** Explanation suitable for the host's existing toast surface. */
+    message: string;
+}>;
+/** Result of one recall gesture; an empty queue permits local input history. */
+export type QueuedRecallOutcome = "ignored" | "empty" | "restored" | "too_late" | "uncertain";
+/** Composer boundary consumed by the queued-recall owner. */
+export type RecallComposer = Readonly<{
+    session: Pick<ShiitakeSession, "latestPending" | "cancel">;
+    recovery: SessionPendingPrompt | undefined;
+    /** Commit in the existing Session draft journal before cancellation can start. */
+    reserve: (prompt: SessionPendingPrompt) => void;
+    /** Clear that journal's reservation after a definitive TooLate. */
+    forget: () => void;
+    /** Undefined when text, attachments or a pending paste make recall unsafe. */
+    emptyDraftRevision: () => number | undefined;
+    /** Atomically restore the full payload iff this empty revision still owns input. */
+    restore: (prompt: SessionPendingPrompt, revision: number) => boolean;
+    /** Hosts use their existing toast seam and derive read-only from `recalling`. */
+    onState: (state: QueuedRecallState) => void;
+}>;
+export type QueuedRecall = Readonly<{
+    readonly state: QueuedRecallState;
+    recall: () => Promise<QueuedRecallOutcome>;
+    dispose: () => void;
+}>;
+/** One instance belongs to one mounted Session composer, not a surface or Agent. */
+export declare function createQueuedRecall(composer: RecallComposer): QueuedRecall;

package/dist/core/queued-recall.js

@@ -0,0 +1,138 @@
+/** A private UI wait ceiling; it does not cancel or reinterpret owner work. */
+const recallWaitMs = 5_000;
+const tooLateMessage = "Too late: that message already started";
+function failureMessage(cause) {
+    return cause instanceof Error
+        ? cause.message
+        : "Could not recall queued message";
+}
+/** One instance belongs to one mounted Session composer, not a surface or Agent. */
+export function createQueuedRecall(composer) {
+    let state = { kind: "idle" };
+    let target = composer.recovery === undefined ? undefined : { prompt: composer.recovery };
+    let disposed = false;
+    const isDisposed = () => disposed;
+    let releaseWait;
+    let pendingDecision;
+    const update = (next) => {
+        state = next;
+        composer.onState(next);
+    };
+    async function decide(revision, attempt) {
+        if (target === undefined) {
+            const prompt = await composer.session.latestPending();
+            // A late lookup must never begin cancellation after input was unlocked.
+            if (!attempt.active || isDisposed())
+                return { kind: "ignored" };
+            if (composer.emptyDraftRevision() !== revision)
+                return { kind: "ignored" };
+            if (prompt === null)
+                return { kind: "empty" };
+            composer.reserve(prompt);
+            target = { prompt };
+        }
+        const selected = target;
+        const result = selected.result ??
+            (await composer.session.cancel({
+                commandId: selected.prompt.commandId,
+                onlyIfPending: true,
+            }));
+        // An ambiguous timeout retains this result for a deliberate subsequent Up.
+        // Never mutate another target or restore input from a late response.
+        if (!isDisposed() && target === selected)
+            selected.result = result;
+        return { kind: "decided", target: selected, result };
+    }
+    async function recall() {
+        const revision = composer.emptyDraftRevision();
+        if (isDisposed() || state.kind === "recalling" || revision === undefined)
+            return "ignored";
+        // A UI timeout cannot abort the owner's Promise. Do not accumulate hidden
+        // requests or waiters while it is unsettled; another Up can recover its
+        // result once it arrives, or retry this exact target after a rejection.
+        if (pendingDecision !== undefined)
+            return "uncertain";
+        update({ kind: "recalling" });
+        const attempt = { active: true };
+        const interrupted = new Promise((resolve) => {
+            releaseWait = () => {
+                resolve({ kind: "ignored" });
+            };
+        });
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                attempt.active = false;
+                resolve({
+                    kind: "uncertain",
+                    message: "Recall is unconfirmed. Press Up on an empty composer to retry.",
+                });
+            }, recallWaitMs);
+        });
+        pendingDecision = decide(revision, attempt)
+            .catch((cause) => ({
+            kind: "uncertain",
+            message: failureMessage(cause),
+        }))
+            .finally(() => {
+            pendingDecision = undefined;
+        });
+        const decision = await Promise.race([
+            pendingDecision,
+            timeout,
+            interrupted,
+        ]);
+        attempt.active = false;
+        clearTimeout(timer);
+        releaseWait = undefined;
+        if (isDisposed())
+            return "ignored";
+        if (decision.kind === "ignored" || decision.kind === "empty") {
+            update({ kind: "idle" });
+            return decision.kind;
+        }
+        if (decision.kind === "uncertain") {
+            update(decision);
+            return "uncertain";
+        }
+        if (decision.result.status === "too_late") {
+            try {
+                composer.forget();
+            }
+            catch (cause) {
+                update({ kind: "uncertain", message: failureMessage(cause) });
+                return "uncertain";
+            }
+            target = undefined;
+            update({ kind: "too_late", message: tooLateMessage });
+            return "too_late";
+        }
+        try {
+            if (composer.restore(decision.target.prompt, revision)) {
+                target = undefined;
+                update({ kind: "restored" });
+                return "restored";
+            }
+            update({
+                kind: "uncertain",
+                message: "Message recalled. Clear the composer and press Up to restore it.",
+            });
+        }
+        catch (cause) {
+            // Keep the accepted payload if, for example, the existing draft journal
+            // refused the restore. A later Up retries restoration, not cancellation.
+            update({ kind: "uncertain", message: failureMessage(cause) });
+        }
+        return "uncertain";
+    }
+    return {
+        get state() {
+            return state;
+        },
+        recall,
+        dispose: () => {
+            disposed = true;
+            releaseWait?.();
+        },
+    };
+}

package/dist/core/session-projection.js

@@ -116,6 +116,18 @@ export function applySessionFrame(current, frame) {
             compactions: mergeCompactions([], frame.baseline.compactions ?? []),
             compactionNotices: mergeCompactionNotices([], frame.baseline.compactionNotices ?? []),
         };
+    if (frame.kind === "tool_output") {
+        const completed = new Set(current.messages.flatMap((message) => message.value.role === "toolResult" ? [message.value.toolCallId] : []));
+        const toolOutput = frame.toolOutput
+            .filter((slot) => !completed.has(slot.toolCallId))
+            .map((slot) => {
+            const previous = current.toolOutput.find((value) => value.toolCallId === slot.toolCallId);
+            return previous !== undefined && previous.revision > slot.revision
+                ? previous
+                : slot;
+        });
+        return { ...current, activity: frame.activity, toolOutput };
+    }
     if (frame.kind === "progress") {
         const completed = completedMessageIds(current.messages).has(frame.progress.messageId);
         const currentProgress = current.progress;
@@ -141,6 +153,9 @@ export function applySessionFrame(current, frame) {
         ? current.pending
         : frame.pending;
     const messages = mergeMessages(current.messages, frame.messages);
+    const completedTools = new Set(messages.flatMap((message) => message.value.role === "toolResult" ? [message.value.toolCallId] : []));
+    const toolOutput = current.toolOutput.filter((slot) => frame.activity.queue.state !== "idle" &&
+        !completedTools.has(slot.toolCallId));
     const terminals = mergeTerminals(current.terminals, frame.terminals);
     const currentCompactions = current.compactions ?? [];
     const compactions = mergeCompactions(currentCompactions, frame.compactions ?? []);
@@ -160,6 +175,7 @@ export function applySessionFrame(current, frame) {
         compactions === currentCompactions &&
         compactionNotices === currentCompactionNotices &&
         progress === current.progress &&
+        toolOutput.length === current.toolOutput.length &&
         pending === current.pending &&
         sameExtensionSlots(frame.extensions, current.extensions) &&
         sameAttention(frame.attention, current.attention) &&
@@ -175,6 +191,7 @@ export function applySessionFrame(current, frame) {
         compactions,
         compactionNotices,
         progress,
+        toolOutput,
         activity: sameActivity(current.activity, frame.activity)
             ? current.activity
             : frame.activity,