@markusylisiurunen/tau 0.3.41 → 0.3.43

package/dist/tui/session_chat_controller.js

@@ -12,7 +12,7 @@ import { REASONING_LEVELS } from "../core/types.js";
 import { formatAdaptiveNumber, formatCwd, formatTokenWindow } from "../core/utils/format.js";
 import { extractAssistantText } from "../core/utils/messages.js";
 import { collectSpeechToTextContext } from "../core/utils/speech_to_text_context.js";
-import { getAutoCompactionMetadataFromMessage, hasAutoCompactionContinuationMetadata, } from "../core/utils/user_metadata.js";
+import { hasAutoCompactionContinuationMetadata } from "../core/utils/user_metadata.js";
 import { APP_VERSION } from "../core/version.js";
 import { applySessionProtocolDelta } from "../protocol/session_protocol.js";
 import { TauSessionProtocolResponseError } from "../transport/errors.js";
@@ -22,7 +22,7 @@ import { formatDiffReviewUserMessage } from "./chat_controller/diff_review_user_
 import { formatRewindCandidateAge, formatRewindCandidateLabel, } from "./chat_controller/history_labels.js";
 import { buildHistoryMessageModel, extractHistoryUserText, } from "./chat_controller/history_message_model.js";
 import { InterruptLifecycle } from "./chat_controller/interrupt_lifecycle.js";
-import { formatDurationMs, formatSessionCost } from "./chat_controller/status_format.js";
+import { formatDurationMs, formatFooterTokenCount, formatSessionCost, } from "./chat_controller/status_format.js";
 import { copyTextToClipboard } from "./clipboard.js";
 import { DOUBLE_PRESS_WINDOW_MS } from "./constants.js";
 import { cleanupListenTempFile, createListenTempFilePath, getSpeechToTextApiKey, getSpeechToTextApiKeyErrorMessage, LISTEN_RECORDING_MAX_DURATION_MS, LISTEN_RECORDING_MIN_BYTES, readListenAudio, startListenAudioCapture, transcribeListenAudio, } from "./listen_capture.js";
@@ -46,15 +46,21 @@ export class SessionChatController {
     diffReviewService;
     snapshot;
     renderedMessageIds = [];
+    viewMessageIds = new Map();
+    usedViewMessageIds = new Set();
     hiddenHistoryEntryIds = new Set();
+    ephemeralTimelineItems = new Map();
+    renderSegment = 0;
     observedSessionRevision;
     eventUnsubscribe;
+    ephemeralUnsubscribe;
     pendingUserMessagesUnsubscribe;
     snapshotRecovery;
     snapshotRecoveryDeltas = [];
     hasPendingUserMessages = false;
     pendingIdleNotification = false;
     isStreaming = false;
+    assistantInterruptRequested = false;
     submittedTurnInProgress = false;
     manualCompactionInProgress = false;
     localDiffReviewInProgress = false;
@@ -66,11 +72,10 @@ export class SessionChatController {
     lastTurnDurationMs = 0;
     turnTimer;
     lastEmptySubmitAt;
-    assistantMessages = [];
     listenRecording;
     listenTransition;
     isTranscribingListen = false;
-    speechStatusHint;
+    speechActivityLabel;
     caffeinated;
     turnCaffeinate;
     disableCaffeinateForSession = false;
@@ -107,7 +112,7 @@ export class SessionChatController {
             persona: (id) => this.setPersona(id),
             prompt: (id) => this.insertPrompt(id),
             theme: (id) => this.switchTheme(id),
-            unknown: () => this.view.addSystemMessage("unknown command. type /help.", "error"),
+            unknown: () => this.view.addTranscriptNotice("unknown command", "error", ["type /help for commands"]),
         };
         this.diffReviewService = new DiffReviewService({
             view: this.view,
@@ -130,11 +135,13 @@ export class SessionChatController {
         this.renderSnapshot(this.snapshot);
         this.hydrateRunningSnapshotState();
         this.eventUnsubscribe = this.session.onDelta((delta) => this.onSdkDelta(delta));
+        this.ephemeralUnsubscribe = this.session.onEphemeral((message) => this.onSdkEphemeral(message));
         this.pendingUserMessagesUnsubscribe = this.session.onPendingUserMessages((message) => this.onSdkPendingUserMessages(message));
         this.refreshStatus();
     }
     async dispose() {
         this.eventUnsubscribe?.();
+        this.ephemeralUnsubscribe?.();
         this.pendingUserMessagesUnsubscribe?.();
         if (this.listenTransition) {
             await this.listenTransition;
@@ -216,7 +223,7 @@ export class SessionChatController {
         this.lastEmptySubmitAt = undefined;
         if (this.isSessionOperationActive()) {
             if (this.isBlockingSessionOperationActive()) {
-                this.view.addSystemMessage("wait for tau to become idle before submitting input", "warn");
+                this.view.showFooterNotice("wait for tau to become idle before submitting input", "default");
                 return;
             }
             if (trimmed.startsWith("/") && this.isSingleLineInput(text)) {
@@ -226,7 +233,7 @@ export class SessionChatController {
                         await this.commandRegistry.dispatch(parsed, this.commandHandlers);
                     }
                     else {
-                        this.view.addSystemMessage("wait for tau to become idle before running commands", "warn");
+                        this.view.showFooterNotice("wait for tau to become idle before running commands", "default");
                     }
                     return;
                 }
@@ -270,16 +277,19 @@ export class SessionChatController {
         await this.handleSubmit(text);
     }
     showHelp() {
-        this.view.addSystemMessage(this.commandRegistry.buildHelpText({
-            agentsFiles: this.getAgentsFilePaths(),
-            skills: this.snapshot.catalog.skills,
-            themes: this.themeIds,
-            formatPath: (path) => formatPathForSessionDisplay(path, this.snapshot.executionEnvironment.home),
-        }), "muted");
+        this.view.addMessage({
+            type: "transcript_text",
+            text: this.commandRegistry.buildHelpText({
+                agentsFiles: this.getAgentsFilePaths(),
+                skills: this.snapshot.catalog.skills,
+                themes: this.themeIds,
+                formatPath: (path) => formatPathForSessionDisplay(path, this.snapshot.executionEnvironment.home),
+            }),
+        });
     }
     switchTheme(themeId) {
         this.view.updateTheme(themeId);
-        this.view.addSystemMessage(`theme set to ${themeId}`, "success");
+        this.view.showFooterNotice(`theme set to ${themeId}`, "default");
     }
     handleEditorChange(text) {
         const wasBash = this.isBashMode;
@@ -397,7 +407,7 @@ export class SessionChatController {
             });
             if (result.userHistoryEntryId) {
                 this.hiddenHistoryEntryIds.add(result.userHistoryEntryId);
-                this.renderedMessageIds.push(result.userHistoryEntryId);
+                this.renderedMessageIds.push(this.getViewMessageId(result.userHistoryEntryId));
             }
             this.view.updateLocalToolUi({
                 toolCallId,
@@ -438,7 +448,7 @@ export class SessionChatController {
             return;
         }
         if (this.isBlockingSessionOperationActive()) {
-            this.view.addSystemMessage("wait for tau to become idle before submitting input", "warn");
+            this.view.showFooterNotice("wait for tau to become idle before submitting input", "default");
             return;
         }
         this.submitSteeringText(trimmed);
@@ -446,14 +456,18 @@ export class SessionChatController {
     submitQueuedText(text) {
         void this.session.queue(text).catch((error) => {
             if (!this.isPendingMessageCancellation(error)) {
-                this.view.addSystemMessage(`queueing failed: ${formatSessionError(error)}`, "error");
+                this.view.addTranscriptNotice("failed to queue message", "error", [
+                    formatSessionError(error),
+                ]);
             }
         });
     }
     submitSteeringText(text) {
         void this.session.steer(text).catch((error) => {
             if (!this.isPendingMessageCancellation(error)) {
-                this.view.addSystemMessage(`steering failed: ${formatSessionError(error)}`, "error");
+                this.view.addTranscriptNotice("failed to steer assistant", "error", [
+                    formatSessionError(error),
+                ]);
             }
         });
     }
@@ -468,7 +482,9 @@ export class SessionChatController {
             this.view.requestRender();
         }
         catch (error) {
-            this.view.addSystemMessage(`pending message cancellation failed: ${error.message}`, "error");
+            this.view.addTranscriptNotice("failed to cancel pending messages", "error", [
+                error.message,
+            ]);
         }
     }
     isPendingMessageCancellation(error) {
@@ -513,7 +529,9 @@ export class SessionChatController {
                 return;
             }
             this.disableCaffeinateForSession = true;
-            this.view.addSystemMessage(`failed to run caffeinate: ${error.message}`, "warn");
+            this.view.addTranscriptNotice("caffeinate unavailable", "default", [
+                error.message,
+            ]);
         }
     }
     async runSessionTurn(task) {
@@ -521,23 +539,20 @@ export class SessionChatController {
             return;
         }
         this.isStreaming = true;
+        this.assistantInterruptRequested = false;
         this.submittedTurnInProgress = true;
         this.startTurnTimer();
         this.startTurnCaffeinate();
         this.view.startWorkingIcon();
         this.refreshStatus();
         try {
-            const result = await task();
-            if (result.turn.status === "blocked") {
-                this.view.addSystemMessage(`turn blocked: ${result.turn.message}`, "error");
-            }
-            else if (result.turn.status === "failed") {
-                this.view.addSystemMessage(`turn failed: ${result.turn.errorMessage ?? "model provider returned an error"}`, "error");
-            }
+            await task();
             await this.syncFromSessionSnapshot();
         }
         catch (error) {
-            this.view.addSystemMessage(`session turn failed: ${formatSessionError(error)}`, "error");
+            this.view.addTranscriptNotice("failed to run assistant turn", "error", [
+                formatSessionError(error),
+            ]);
             this.stopVisibleSessionTurn();
             void this.stopTurnCaffeinate();
             await this.syncFromSessionSnapshot();
@@ -551,7 +566,7 @@ export class SessionChatController {
     }
     async interrupt() {
         if (this.interruptLifecycle.interruptActiveTask()) {
-            this.view.addSystemMessage("interrupted", "error");
+            this.view.showFooterNotice("interrupted", "default");
             return;
         }
         if (this.listenRecording) {
@@ -562,23 +577,29 @@ export class SessionChatController {
             if (!this.speakTask.abortController.signal.aborted) {
                 this.speakTask.abortController.abort();
             }
-            this.view.addSystemMessage("interrupted", "error");
+            this.view.showFooterNotice("interrupted", "default");
             return;
         }
-        if (!this.isStreaming) {
+        if (!this.isStreaming || this.assistantInterruptRequested) {
             return;
         }
+        this.assistantInterruptRequested = true;
         try {
             const result = await this.session.interrupt();
-            this.view.addSystemMessage(result.interrupted ? "interrupted" : "interrupt requested", "error");
+            if (!result.interrupted) {
+                this.assistantInterruptRequested = false;
+            }
         }
         catch (error) {
-            this.view.addSystemMessage(`interrupt failed: ${error.message}`, "error");
+            this.assistantInterruptRequested = false;
+            this.view.addTranscriptNotice("failed to interrupt assistant", "error", [
+                error.message,
+            ]);
         }
     }
     async toggleListenCapture() {
         if (this.listenTransition) {
-            this.view.addSystemMessage("speech recording state change already in progress", "warn");
+            this.view.showFooterNotice("speech recording state change already in progress", "default");
             return;
         }
         if (this.listenRecording) {
@@ -589,15 +610,15 @@ export class SessionChatController {
     }
     async startListenCaptureFromCommand() {
         if (this.listenTransition) {
-            this.view.addSystemMessage("speech recording state change already in progress", "warn");
+            this.view.showFooterNotice("speech recording state change already in progress", "default");
             return;
         }
         if (this.listenRecording) {
-            this.view.addSystemMessage("speech recording already in progress", "warn");
+            this.view.showFooterNotice("speech recording already in progress", "default");
             return;
         }
         if (this.isTranscribingListen) {
-            this.view.addSystemMessage("speech transcription already in progress", "warn");
+            this.view.showFooterNotice("speech transcription already in progress", "default");
             return;
         }
         await this.runListenTransition(() => this.startListenCapture());
@@ -619,12 +640,14 @@ export class SessionChatController {
     }
     async startListenCapture() {
         if (this.deps.env.platform() !== "darwin") {
-            this.view.addSystemMessage("/listen is currently supported only on macOS.", "warn");
+            this.view.showFooterNotice("/listen is currently supported only on macOS.", "default");
             return;
         }
         const apiKey = getSpeechToTextApiKey(this.config, this.deps);
         if (!apiKey) {
-            this.view.addSystemMessage(getSpeechToTextApiKeyErrorMessage(this.config, "use /listen"), "error");
+            this.view.addTranscriptNotice("speech-to-text is not configured", "error", [
+                getSpeechToTextApiKeyErrorMessage(this.config, "use /listen"),
+            ]);
             return;
         }
         let audioPath;
@@ -656,7 +679,7 @@ export class SessionChatController {
             if (audioPath) {
                 await cleanupListenTempFile(audioPath);
             }
-            this.view.addSystemMessage(`failed to start recording: ${err.message}`, "error");
+            this.view.addTranscriptNotice("failed to start recording", "error", [err.message]);
         }
     }
     async stopListenCapture() {
@@ -673,15 +696,16 @@ export class SessionChatController {
             await recording.completion;
         }
         catch (err) {
-            this.view.addSystemMessage(`recording failed: ${err.message}`, "error");
+            this.view.addTranscriptNotice("failed to record audio", "error", [err.message]);
             await cleanupListenTempFile(recording.audioPath);
             return;
         }
         this.isTranscribingListen = true;
+        this.refreshStatus();
         try {
             const audio = await readListenAudio(recording.audioPath);
             if (audio.byteLength < LISTEN_RECORDING_MIN_BYTES) {
-                this.view.addSystemMessage("recording too short, try again", "warn");
+                this.view.showFooterNotice("recording too short, try again", "default");
                 return;
             }
             const transcript = await transcribeListenAudio({
@@ -697,10 +721,13 @@ export class SessionChatController {
             this.view.insertEditorTextAtCursor(text);
         }
         catch (err) {
-            this.view.addSystemMessage(`speech transcription failed: ${err.message}`, "error");
+            this.view.addTranscriptNotice("failed to transcribe speech", "error", [
+                err.message,
+            ]);
         }
         finally {
             this.isTranscribingListen = false;
+            this.refreshStatus();
             await cleanupListenTempFile(recording.audioPath);
         }
     }
@@ -736,7 +763,7 @@ export class SessionChatController {
                 : result.closeSignal
                     ? `ffmpeg terminated by signal ${result.closeSignal}`
                     : "ffmpeg exited";
-            this.view.addSystemMessage(`recording stopped unexpectedly (${detail})`, "error");
+            this.view.addTranscriptNotice("recording stopped unexpectedly", "error", [detail]);
             await cleanupListenTempFile(recording.audioPath);
         }
         catch (err) {
@@ -748,10 +775,12 @@ export class SessionChatController {
             this.refreshStatus();
             const error = err;
             if (error.code === "ENOENT") {
-                this.view.addSystemMessage("ffmpeg not found. install it with: brew install ffmpeg", "error");
+                this.view.addTranscriptNotice("ffmpeg not found", "error", [
+                    "install it with: brew install ffmpeg",
+                ]);
             }
             else {
-                this.view.addSystemMessage(`recording failed: ${error.message}`, "error");
+                this.view.addTranscriptNotice("failed to record audio", "error", [error.message]);
             }
             await cleanupListenTempFile(recording.audioPath);
         }
@@ -764,11 +793,11 @@ export class SessionChatController {
     }
     async createNewSession() {
         if (this.isSessionOperationActive()) {
-            this.view.addSystemMessage("cannot create a new session while another session operation is running", "warn");
+            this.view.showFooterNotice("cannot create a new session while another session operation is running", "default");
             return;
         }
         if (!this.createSession) {
-            this.view.addSystemMessage("new session creation is unavailable", "error");
+            this.view.addTranscriptNotice("cannot create a new session", "error");
             return;
         }
         const createInput = {
@@ -788,12 +817,14 @@ export class SessionChatController {
         this.refreshStatus();
         let nextSession;
         let nextEventUnsubscribe;
+        let nextEphemeralUnsubscribe;
         let nextPendingUserMessagesUnsubscribe;
         let installed = false;
         try {
             nextSession = await this.createSession(createInput);
             const nextSnapshot = await nextSession.snapshot();
             const pendingDeltas = [];
+            const pendingEphemeralMessages = [];
             const pendingUserMessages = [];
             let forwardEvents = false;
             nextEventUnsubscribe = nextSession.onDelta((delta) => {
@@ -804,6 +835,14 @@ export class SessionChatController {
                     pendingDeltas.push(delta);
                 }
             });
+            nextEphemeralUnsubscribe = nextSession.onEphemeral((message) => {
+                if (forwardEvents) {
+                    this.onSdkEphemeral(message);
+                }
+                else {
+                    pendingEphemeralMessages.push(message);
+                }
+            });
             nextPendingUserMessagesUnsubscribe = nextSession.onPendingUserMessages((message) => {
                 if (forwardEvents) {
                     this.onSdkPendingUserMessages(message);
@@ -814,21 +853,25 @@ export class SessionChatController {
             });
             const previousSession = this.session;
             this.eventUnsubscribe?.();
+            this.ephemeralUnsubscribe?.();
             this.pendingUserMessagesUnsubscribe?.();
             this.session = nextSession;
             this.snapshot = nextSnapshot;
             this.observedSessionRevision = nextSnapshot.revision;
             this.eventUnsubscribe = nextEventUnsubscribe;
+            this.ephemeralUnsubscribe = nextEphemeralUnsubscribe;
             this.pendingUserMessagesUnsubscribe = nextPendingUserMessagesUnsubscribe;
             installed = true;
             this.view.resetToolUiSession();
-            this.assistantMessages = [];
             this.startLocalUiSession();
             this.addSessionIdentityMessage();
             this.renderSnapshot(this.snapshot);
             for (const delta of pendingDeltas) {
                 this.onSdkDelta(delta);
             }
+            for (const message of pendingEphemeralMessages) {
+                this.onSdkEphemeral(message);
+            }
             for (const message of pendingUserMessages) {
                 this.onSdkPendingUserMessages(message);
             }
@@ -837,16 +880,21 @@ export class SessionChatController {
                 await previousSession.unobserve();
             }
             catch (detachError) {
-                this.view.addSystemMessage(`old session unobserve failed: ${detachError.message}`, "warn");
+                this.view.addTranscriptNotice("failed to detach previous session", "error", [
+                    detachError.message,
+                ]);
             }
         }
         catch (error) {
             if (!installed && nextSession) {
                 nextEventUnsubscribe?.();
+                nextEphemeralUnsubscribe?.();
                 nextPendingUserMessagesUnsubscribe?.();
                 await nextSession.unobserve().catch(() => undefined);
             }
-            this.view.addSystemMessage(`new session failed: ${error.message}`, "error");
+            this.view.addTranscriptNotice("failed to create session", "error", [
+                error.message,
+            ]);
         }
         finally {
             this.sessionReplacementInProgress = false;
@@ -879,6 +927,23 @@ export class SessionChatController {
         this.view.setPendingUserMessages(message.state.messages);
         this.sendPendingIdleNotification();
     }
+    onSdkEphemeral(message) {
+        const event = message.event;
+        switch (event.type) {
+            case "feedback.notice":
+                this.view.showFooterNotice(event.title, event.tone, event.durationMs);
+                return;
+            case "timeline.item":
+                if (event.epoch !== this.snapshot.timeline.epoch) {
+                    return;
+                }
+                this.ephemeralTimelineItems.set(event.item.id, event.item);
+                this.syncRenderedHistory(this.snapshot);
+                return;
+            case "ephemeral-agent.thread-update":
+                return;
+        }
+    }
     onSdkDelta(delta) {
         if (this.snapshotRecovery) {
             this.snapshotRecoveryDeltas.push(delta);
@@ -891,10 +956,7 @@ export class SessionChatController {
         void this.recoverFromRevisionGap();
     }
     tryApplySdkDelta(delta) {
-        if (delta.delta.type === "snapshot.reset" && delta.toRevision < this.snapshot.revision) {
-            return true;
-        }
-        if (delta.delta.type === "snapshot.patch" && delta.toRevision <= this.snapshot.revision) {
+        if (delta.toRevision <= this.snapshot.revision) {
             return true;
         }
         if (delta.delta.type === "snapshot.patch" && delta.fromRevision !== this.snapshot.revision) {
@@ -911,16 +973,28 @@ export class SessionChatController {
                 return true;
             }
             const nextSnapshot = applySessionProtocolDelta(this.snapshot, delta);
-            if (this.shouldRenderAutoCompactedReset(delta)) {
-                this.renderAutoCompactedReset(nextSnapshot);
+            if (delta.cause.type === "compaction" && delta.delta.type === "snapshot.reset") {
+                this.renderCompactedReset(nextSnapshot, delta.cause);
             }
             else {
+                if (delta.cause.type === "rewind") {
+                    for (const [id, item] of this.ephemeralTimelineItems) {
+                        if (item.sequence > delta.cause.cutoffSequence) {
+                            this.ephemeralTimelineItems.delete(id);
+                        }
+                    }
+                }
+                else if (nextSnapshot.timeline.epoch !== this.snapshot.timeline.epoch) {
+                    this.ephemeralTimelineItems.clear();
+                }
                 this.syncRenderedHistory(nextSnapshot);
             }
             this.refreshStatus();
         }
         catch (error) {
-            this.view.addSystemMessage(`session delta failed: ${error.message}`, "warn");
+            this.view.addTranscriptNotice("failed to update session", "error", [
+                error.message,
+            ]);
             return false;
         }
         return true;
@@ -939,6 +1013,7 @@ export class SessionChatController {
         const message = nextSnapshot.messages.find((entry) => entry.id === change.messageId);
         if (!message ||
             this.hiddenHistoryEntryIds.has(message.id) ||
+            !this.isMessageProjected(message.id) ||
             !isMessageInTimeline(nextSnapshot, message.id)) {
             return true;
         }
@@ -946,16 +1021,17 @@ export class SessionChatController {
         if (!model) {
             return true;
         }
-        if (this.renderedMessageIds.includes(message.id)) {
+        const viewMessageId = this.getViewMessageId(message.id);
+        if (this.renderedMessageIds.includes(viewMessageId)) {
             if (model.type === "assistant" || model.type === "assistant_partial") {
-                this.view.updateAssistantMessage(message.id, model);
+                this.view.updateAssistantMessage(viewMessageId, model);
             }
             else {
-                this.view.updateMessage(message.id, model);
+                this.view.updateMessage(viewMessageId, model);
             }
         }
         else {
-            this.renderedMessageIds.push(this.view.addMessage(model, message.id));
+            this.renderedMessageIds.push(this.view.addMessage(model, viewMessageId));
         }
         return true;
     }
@@ -988,26 +1064,45 @@ export class SessionChatController {
         if (facetChanges.some(({ facet }) => facet.kind !== "tau.tool-ui-events" || facet.subject.type !== "tool")) {
             return false;
         }
-        this.snapshot = applySessionProtocolDelta(this.snapshot, delta);
-        this.observedSessionRevision = Math.max(this.observedSessionRevision, this.snapshot.revision);
-        this.view.reconcileToolUiSession(getToolUiModelsInModelOrder(this.snapshot));
+        const nextSnapshot = applySessionProtocolDelta(this.snapshot, delta);
+        this.syncRenderedHistory(nextSnapshot);
         this.refreshStatus();
         return true;
     }
+    getViewMessageId(protocolId) {
+        const existingId = this.viewMessageIds.get(protocolId);
+        if (existingId)
+            return existingId;
+        let viewId = protocolId;
+        if (this.usedViewMessageIds.has(viewId)) {
+            const baseId = `timeline-segment:${this.renderSegment}:${protocolId}`;
+            viewId = baseId;
+            for (let suffix = 2; this.usedViewMessageIds.has(viewId); suffix += 1) {
+                viewId = `${baseId}:${suffix}`;
+            }
+        }
+        this.viewMessageIds.set(protocolId, viewId);
+        this.usedViewMessageIds.add(viewId);
+        return viewId;
+    }
     renderSnapshot(snapshot) {
         this.snapshot = snapshot;
         this.observedSessionRevision = Math.max(this.observedSessionRevision, snapshot.revision);
-        this.assistantMessages = [];
-        for (const item of getRenderableTimelineItems(snapshot)) {
+        for (const item of getRenderableTimelineItems(snapshot, this.ephemeralTimelineItems.values())) {
+            const viewMessageId = this.getViewMessageId(item.id);
             if (item.type === "notice") {
                 this.renderedMessageIds.push(this.view.addMessage({
-                    type: "system",
-                    text: item.text,
-                    kind: item.severity === "info" ? "muted" : item.severity,
-                }, item.id));
+                    type: "transcript_notice",
+                    title: item.title,
+                    ...(item.content ? { content: item.content } : {}),
+                    tone: item.severity === "error" ? "error" : "default",
+                }, viewMessageId));
+            }
+            else if (item.type === "tool") {
+                this.renderedMessageIds.push(this.view.addMessage({ type: "tool", tool: item.model }, viewMessageId));
             }
             else {
-                this.renderProtocolMessage(item.message);
+                this.renderProtocolMessage(item.message, viewMessageId);
             }
         }
         this.syncSnapshotToolAndAgentUi(snapshot);
@@ -1020,21 +1115,18 @@ export class SessionChatController {
         this.startTurnTimer();
         this.view.startWorkingIcon();
     }
-    renderProtocolMessage(message) {
+    renderProtocolMessage(message, viewMessageId) {
         const model = this.buildProtocolMessageModel(message);
         if (!model) {
             return;
         }
-        if (isAssistantMessage(message.message)) {
-            this.assistantMessages.push(message.message);
-        }
-        this.renderedMessageIds.push(this.view.addMessage(model, message.id));
+        this.renderedMessageIds.push(this.view.addMessage(model, viewMessageId));
     }
     syncRenderedHistory(snapshot) {
         this.snapshot = snapshot;
         this.observedSessionRevision = Math.max(this.observedSessionRevision, snapshot.revision);
-        const items = getRenderableTimelineItems(snapshot);
-        const snapshotIds = new Set(items.map((item) => item.id));
+        const items = getRenderableTimelineItems(snapshot, this.ephemeralTimelineItems.values());
+        const snapshotIds = new Set(items.map((item) => this.getViewMessageId(item.id)));
         const staleIds = this.renderedMessageIds.filter((id) => !snapshotIds.has(id));
         if (staleIds.length > 0) {
             this.view.removeMessages(staleIds);
@@ -1042,35 +1134,38 @@ export class SessionChatController {
         const renderedIds = new Set(this.renderedMessageIds);
         this.renderedMessageIds.splice(0, this.renderedMessageIds.length, ...this.renderedMessageIds.filter((id) => snapshotIds.has(id)));
         for (const item of items) {
+            const viewMessageId = this.getViewMessageId(item.id);
             if (item.type === "message" && this.hiddenHistoryEntryIds.has(item.id)) {
-                if (!renderedIds.has(item.id)) {
-                    this.renderedMessageIds.push(item.id);
+                if (!renderedIds.has(viewMessageId)) {
+                    this.renderedMessageIds.push(viewMessageId);
                 }
                 continue;
             }
             const model = item.type === "notice"
                 ? {
-                    type: "system",
-                    text: item.text,
-                    kind: item.severity === "info" ? "muted" : item.severity,
+                    type: "transcript_notice",
+                    title: item.title,
+                    ...(item.content ? { content: item.content } : {}),
+                    tone: item.severity === "error" ? "error" : "default",
                 }
-                : this.buildProtocolMessageModel(item.message);
+                : item.type === "tool"
+                    ? { type: "tool", tool: item.model }
+                    : this.buildProtocolMessageModel(item.message);
             if (!model) {
                 continue;
             }
-            if (renderedIds.has(item.id)) {
+            if (renderedIds.has(viewMessageId)) {
                 if (model.type === "assistant") {
-                    this.view.updateAssistantMessage(item.id, model);
+                    this.view.updateAssistantMessage(viewMessageId, model);
                 }
                 else {
-                    this.view.updateMessage(item.id, model);
+                    this.view.updateMessage(viewMessageId, model);
                 }
             }
             else {
-                this.renderedMessageIds.push(this.view.addMessage(model, item.id));
+                this.renderedMessageIds.push(this.view.addMessage(model, viewMessageId));
             }
         }
-        this.assistantMessages = this.collectAssistantMessages(snapshot);
         this.updateStreamingStateFromSnapshot(snapshot);
         this.syncSnapshotToolAndAgentUi(snapshot);
     }
@@ -1105,30 +1200,34 @@ export class SessionChatController {
         }
         this.finishObservedSessionTurn();
     }
+    isMessageProjected(messageId) {
+        return isMessageInTimeline(this.snapshot, messageId);
+    }
     syncSnapshotToolAndAgentUi(snapshot) {
-        this.view.reconcileToolUiSession(getToolUiModelsInModelOrder(snapshot));
         this.view.reconcileSubagentUiSession(Object.values(snapshot.agents).map((agent) => ({
             state: structuredClone(agent),
             activity: getSubagentActivity(snapshot, agent.id),
         })));
     }
-    collectAssistantMessages(snapshot) {
-        const messages = [];
-        for (const entry of snapshot.messages) {
-            if (isAssistantMessage(entry.message)) {
-                messages.push(entry.message);
-            }
-        }
-        return messages;
-    }
-    async syncFromSessionSnapshot() {
+    async syncFromSessionSnapshot(ephemeralTimelineItemIdsToDiscard) {
         try {
-            this.syncRenderedHistory(await this.session.snapshot());
+            const snapshot = await this.session.snapshot();
+            for (const id of ephemeralTimelineItemIdsToDiscard ?? []) {
+                this.ephemeralTimelineItems.delete(id);
+            }
+            if (snapshot.timeline.epoch > this.snapshot.timeline.epoch) {
+                this.renderCompactedSnapshot(snapshot);
+            }
+            else {
+                this.syncRenderedHistory(snapshot);
+            }
             this.refreshStatus();
             return true;
         }
         catch (error) {
-            this.view.addSystemMessage(`snapshot refresh failed: ${error.message}`, "warn");
+            this.view.addTranscriptNotice("failed to refresh session", "error", [
+                error.message,
+            ]);
             return false;
         }
     }
@@ -1152,6 +1251,7 @@ export class SessionChatController {
             return false;
         }
         this.isStreaming = false;
+        this.assistantInterruptRequested = false;
         this.view.stopWorkingIcon();
         this.stopTurnTimer();
         this.refreshStatus();
@@ -1162,6 +1262,7 @@ export class SessionChatController {
             return;
         }
         this.isStreaming = true;
+        this.assistantInterruptRequested = false;
         this.startTurnTimer();
         this.startTurnCaffeinate();
         this.view.startWorkingIcon();
@@ -1179,7 +1280,7 @@ export class SessionChatController {
         if (this.snapshotRecovery) {
             return;
         }
-        this.snapshotRecovery = this.syncFromSessionSnapshot()
+        this.snapshotRecovery = this.syncFromSessionSnapshotAfterRevisionGap()
             .then((synced) => {
             if (synced) {
                 return this.replaySnapshotRecoveryDeltas();
@@ -1190,6 +1291,9 @@ export class SessionChatController {
         });
         await this.snapshotRecovery;
     }
+    syncFromSessionSnapshotAfterRevisionGap() {
+        return this.syncFromSessionSnapshot(new Set(this.ephemeralTimelineItems.keys()));
+    }
     async replaySnapshotRecoveryDeltas() {
         while (this.snapshotRecoveryDeltas.length > 0) {
             const deltas = this.snapshotRecoveryDeltas.splice(0);
@@ -1198,7 +1302,7 @@ export class SessionChatController {
                 if (this.tryApplySdkDelta(delta)) {
                     continue;
                 }
-                if (!(await this.syncFromSessionSnapshot())) {
+                if (!(await this.syncFromSessionSnapshotAfterRevisionGap())) {
                     this.snapshotRecoveryDeltas.unshift(delta, ...deltas.slice(index + 1));
                     return;
                 }
@@ -1206,44 +1310,46 @@ export class SessionChatController {
         }
     }
     startLocalUiSession() {
+        this.renderSegment += 1;
+        this.viewMessageIds.clear();
+        this.ephemeralTimelineItems.clear();
         this.hiddenHistoryEntryIds.clear();
         this.renderedMessageIds.splice(0);
         this.view.addMessage({ type: "session_divider", label: "new session" });
     }
+    startCompactedUiSession() {
+        this.renderSegment += 1;
+        this.viewMessageIds.clear();
+        this.ephemeralTimelineItems.clear();
+        this.hiddenHistoryEntryIds.clear();
+        this.renderedMessageIds.splice(0);
+        this.view.addMessage({ type: "session_divider", label: "compacted context" });
+    }
     addSessionIdentityMessage() {
-        this.view.addSystemMessage(this.formatSessionIdentityText(), "muted");
+        this.view.addTranscriptNotice("session id", "default", [this.snapshot.sessionId]);
     }
     renderCompactedSnapshot(snapshot) {
-        this.startLocalUiSession();
+        this.view.resetToolUiSessionPreservingSubagents();
+        this.startCompactedUiSession();
         this.renderSnapshot(snapshot);
     }
-    shouldRenderAutoCompactedReset(delta) {
-        return (delta.reason === "maintenance" &&
-            delta.delta.type === "snapshot.reset" &&
-            this.hasRunningAutoCompactionOperation(this.snapshot));
-    }
-    renderAutoCompactedReset(snapshot) {
+    renderCompactedReset(snapshot, cause) {
         this.view.resetToolUiSessionPreservingSubagents();
-        this.startLocalUiSession();
+        this.startCompactedUiSession();
         this.renderSnapshot(snapshot);
-        const metadata = this.getAutoCompactionMetadata(snapshot);
-        if (metadata) {
-            this.view.addMessage({
-                type: "system",
-                text: formatAutoCompactionRetainedText(metadata),
-                kind: "muted",
-            });
+        if (cause.kind === "auto") {
+            this.view.addTranscriptNotice(formatAutoCompactionRetainedText(cause), "default");
         }
     }
     toggleThinkingVisibility() {
         this.showThinking = !this.showThinking;
         this.view.setThinkingVisibility(this.showThinking);
-        this.view.addSystemMessage(this.showThinking ? "thoughts visible" : "thoughts hidden", "success");
+        this.view.showFooterNotice(this.showThinking ? "thoughts visible" : "thoughts hidden", "default");
     }
     async cyclePersonality() {
         const personas = this.snapshot.catalog.personas;
         if (personas.length === 0) {
-            this.view.addSystemMessage("no personas available.", "warn");
+            this.view.showFooterNotice("no personas available.", "default");
             return;
         }
         const currentIndex = personas.findIndex((persona) => persona.id.toLowerCase() === this.snapshot.settings.personaId.toLowerCase());
@@ -1265,7 +1371,9 @@ export class SessionChatController {
             this.refreshStatus();
         }
         catch (error) {
-            this.view.addSystemMessage(`reasoning change failed: ${error.message}`, "error");
+            this.view.addTranscriptNotice("failed to change reasoning", "error", [
+                error.message,
+            ]);
         }
     }
     getAllowedReasoningLevels(persona) {
@@ -1283,37 +1391,39 @@ export class SessionChatController {
     async setPersona(rawId) {
         const id = rawId.trim();
         if (!id) {
-            this.view.addSystemMessage("missing persona id", "error");
+            this.view.addTranscriptNotice("missing persona id", "error");
             return;
         }
         const persona = this.snapshot.catalog.personas.find((candidate) => candidate.id.toLowerCase() === id.toLowerCase());
         if (!persona) {
-            this.view.addSystemMessage(`unknown persona '${id}'.`, "error");
+            this.view.addTranscriptNotice("unknown persona", "error", [id]);
             return;
         }
         if (this.isSessionOperationActive()) {
-            this.view.addSystemMessage("cannot switch persona while a session turn is running", "warn");
+            this.view.showFooterNotice("cannot switch persona while a session turn is running", "default");
             return;
         }
         try {
             this.snapshot = await this.session.setPersona(persona.id);
             this.syncRenderedHistory(this.snapshot);
             this.refreshStatus();
-            this.view.addSystemMessage(`switched to ${persona.label} (${this.snapshot.bootstrap.model.id})`, "success");
+            this.view.showFooterNotice(`switched to ${persona.label} (${this.snapshot.bootstrap.model.id})`, "default");
         }
         catch (error) {
-            this.view.addSystemMessage(`persona switch failed: ${error.message}`, "error");
+            this.view.addTranscriptNotice("failed to switch persona", "error", [
+                error.message,
+            ]);
         }
     }
     async insertPrompt(rawId) {
         const id = rawId.trim();
         if (!id) {
-            this.view.addSystemMessage("missing prompt id", "error");
+            this.view.addTranscriptNotice("missing prompt id", "error");
             return;
         }
         const prompt = this.snapshot.catalog.prompts.find((candidate) => candidate.id.toLowerCase() === id.toLowerCase());
         if (!prompt) {
-            this.view.addSystemMessage(`unknown prompt '${id}'.`, "error");
+            this.view.addTranscriptNotice("unknown prompt", "error", [id]);
             return;
         }
         try {
@@ -1321,12 +1431,12 @@ export class SessionChatController {
             this.view.setEditorText(resolved.text);
         }
         catch (error) {
-            this.view.addSystemMessage(`prompt load failed: ${error.message}`, "error");
+            this.view.addTranscriptNotice("failed to load prompt", "error", [error.message]);
         }
     }
     async reloadContent() {
         if (this.isSessionOperationActive()) {
-            this.view.addSystemMessage("cannot reload while a session turn is running", "warn");
+            this.view.showFooterNotice("cannot reload while a session turn is running", "default");
             return;
         }
         try {
@@ -1335,7 +1445,7 @@ export class SessionChatController {
             this.syncRenderedHistory(this.snapshot);
             this.refreshStatus();
             for (const warning of result.warnings) {
-                this.view.addSystemMessage(warning, "warn");
+                this.view.addTranscriptNotice("configuration warning", "default", [warning]);
             }
             const summary = [
                 `${result.counts.personas} personas`,
@@ -1343,35 +1453,33 @@ export class SessionChatController {
                 `${result.counts.skills} skills`,
                 ...formatAgentsMdReloadSummary(this.getAgentsFilePaths().length),
             ].join(", ");
-            this.view.addSystemMessage(`reloaded: ${summary}.`, "success");
+            this.view.showFooterNotice(`reloaded: ${summary}.`, "default");
         }
         catch (error) {
-            this.view.addSystemMessage(`reload failed: ${error.message}`, "error");
+            this.view.addTranscriptNotice("failed to reload session content", "error", [
+                error.message,
+            ]);
         }
     }
     async compactSession(mode, guidanceText) {
         if (this.isSessionOperationActive()) {
-            this.view.addSystemMessage("cannot compact while a session turn is running", "warn");
+            this.view.showFooterNotice("cannot compact while a session turn is running", "default");
             return;
         }
         const guidance = guidanceText?.trim() ?? "";
         this.manualCompactionInProgress = true;
         this.refreshStatus();
-        this.view.addSystemMessage("summarizing session...", "success");
         try {
             const result = await this.session.compact(mode, {
                 ...(guidance ? { guidance } : {}),
             });
-            this.renderCompactedSnapshot(result.snapshot);
-            const message = mode === "summary-and-last" && result.includedLastAssistant
-                ? "session compacted. previous context and last assistant message have been included."
-                : "session compacted. previous context has been summarized.";
-            this.view.addSystemMessage(message, "success");
+            if (result.snapshot.revision > this.snapshot.revision) {
+                this.renderCompactedSnapshot(result.snapshot);
+            }
         }
         catch (error) {
             const message = error.message || "compaction failed";
-            const kind = message === "no conversation to compact." ? "warn" : "error";
-            this.view.addSystemMessage(kind === "warn" ? message : `compact failed: ${message}`, kind);
+            this.view.addTranscriptNotice("failed to compact session", "error", [message]);
         }
         finally {
             this.manualCompactionInProgress = false;
@@ -1381,7 +1489,7 @@ export class SessionChatController {
     async handleGoalAction(action) {
         if (action.type === "show") {
             const goal = this.snapshot.goal;
-            this.view.addSystemMessage(goal ? `goal ${goal.status}: ${goal.objective}` : "no session goal", goal ? "success" : "muted");
+            this.view.addTranscriptNotice(goal ? `goal ${goal.status}` : "no session goal", "default", goal ? [goal.objective] : undefined);
             return;
         }
         if (action.type === "start") {
@@ -1395,41 +1503,43 @@ export class SessionChatController {
         try {
             this.snapshot = await this.session.clearGoal();
             this.refreshStatus();
-            this.view.addSystemMessage("session goal cleared", "success");
+            this.view.showFooterNotice("session goal cleared", "default");
         }
         catch (error) {
-            this.view.addSystemMessage(`goal clear failed: ${error.message}`, "error");
+            this.view.addTranscriptNotice("failed to clear goal", "error", [error.message]);
         }
     }
     async speakLastAssistantMessage() {
         if (this.speakTask) {
-            this.view.addSystemMessage("speech playback already in progress", "warn");
+            this.view.showFooterNotice("speech playback already in progress", "default");
             return;
         }
         if (this.isSessionOperationActive()) {
-            this.view.addSystemMessage("wait for the assistant to finish before speaking", "warn");
+            this.view.showFooterNotice("wait for the assistant to finish before speaking", "default");
             return;
         }
         if (this.deps.env.platform() !== "darwin") {
-            this.view.addSystemMessage("/speak is currently supported only on macOS.", "warn");
+            this.view.showFooterNotice("/speak is currently supported only on macOS.", "default");
             return;
         }
         const lastAssistant = this.getLastAssistantMessage();
         if (!lastAssistant) {
-            this.view.addSystemMessage("no assistant message to speak yet.", "warn");
+            this.view.showFooterNotice("no assistant message to speak yet.", "default");
             return;
         }
         const sourceText = extractAssistantText(lastAssistant).trim();
         if (!sourceText) {
-            this.view.addSystemMessage("last assistant message was empty.", "warn");
+            this.view.showFooterNotice("last assistant message was empty.", "default");
             return;
         }
         const apiKey = getGoogleApiKey(this.config, this.deps.env.env());
         if (!apiKey) {
-            this.view.addSystemMessage("set GEMINI_API_KEY or apiKeys.google to use /speak", "error");
+            this.view.addTranscriptNotice("speech synthesis is not configured", "error", [
+                "set GEMINI_API_KEY or apiKeys.google to use /speak",
+            ]);
             return;
         }
-        this.speechStatusHint = "rewriting for speech...";
+        this.speechActivityLabel = "rewriting for speech";
         this.refreshStatus();
         this.view.startWorkingIcon();
         const abortController = new AbortController();
@@ -1447,13 +1557,15 @@ export class SessionChatController {
             if (abortController.signal.aborted) {
                 return;
             }
-            this.view.addSystemMessage(`speech synthesis failed: ${err.message}`, "error");
+            this.view.addTranscriptNotice("failed to synthesize speech", "error", [
+                err.message,
+            ]);
         }
         finally {
             if (this.speakTask === task) {
                 this.speakTask = undefined;
             }
-            this.speechStatusHint = undefined;
+            this.speechActivityLabel = undefined;
             this.view.stopWorkingIcon();
             this.refreshStatus();
             this.view.requestRender();
@@ -1465,22 +1577,25 @@ export class SessionChatController {
             apiKey: args.apiKey,
             sourceText: args.sourceText,
             signal: args.signal,
-            onStatusHint: (hint) => {
-                this.speechStatusHint = hint;
+            onActivityLabel: (hint) => {
+                this.speechActivityLabel = hint;
                 this.refreshStatus();
             },
         });
     }
     refreshStatus() {
+        const activityLabel = this.getActivityLabel();
         this.view.updateStatus({
-            footer: {
-                cwdLabel: this.getFooterCwdLabel(),
-                contextUsage: this.getContextUsageString(),
-                sessionCost: this.getSessionCostString(),
-                duration: this.getTurnDurationString(),
-                statusHint: this.diffReviewService.getStatusHint(this.getSessionOperationStatusHint() ?? this.speechStatusHint),
-                pursuingGoal: this.snapshot.goal?.status === "active",
-            },
+            footer: activityLabel
+                ? { type: "activity", label: activityLabel }
+                : {
+                    type: "regular",
+                    cwdLabel: this.getFooterCwdLabel(),
+                    contextUsage: this.getContextUsageString(),
+                    sessionCost: this.getSessionCostString(),
+                    duration: this.getTurnDurationString(),
+                    pursuingGoal: this.snapshot.goal?.status === "active",
+                },
             editor: {
                 mode: this.getInputMode(),
                 personaName: this.getCurrentPersonaSnapshot()?.label ?? this.snapshot.settings.personaId,
@@ -1501,17 +1616,24 @@ export class SessionChatController {
             return "bash";
         return "normal";
     }
-    getSessionOperationStatusHint() {
-        if (this.manualCompactionInProgress) {
-            return "compacting context...";
+    getActivityLabel() {
+        if (this.manualCompactionInProgress || this.hasRunningCompactionOperation(this.snapshot)) {
+            return "compacting context";
+        }
+        if (this.isTranscribingListen) {
+            return "transcribing voice input";
         }
-        const hasRunningAutoCompaction = this.hasRunningAutoCompactionOperation(this.snapshot);
-        return hasRunningAutoCompaction ? "compacting context..." : undefined;
+        return this.diffReviewService.getActivityLabel(this.speechActivityLabel);
     }
-    hasRunningAutoCompactionOperation(snapshot) {
-        return snapshot.timeline.some((item) => item.type === "operation" &&
-            item.operation.kind === "auto-compaction" &&
-            item.operation.status === "running");
+    hasRunningCompactionOperation(snapshot) {
+        return snapshot.timeline.items.some((item) => {
+            if (item.type !== "operation") {
+                return false;
+            }
+            const operation = snapshot.operations[item.operationId];
+            return (operation?.status === "running" &&
+                (operation.kind === "auto-compaction" || operation.kind === "manual-compaction"));
+        });
     }
     getContextUsageString() {
         const last = this.getLastAssistantMessage();
@@ -1519,7 +1641,7 @@ export class SessionChatController {
             ? this.getContextWindowForLastTurn(last)
             : this.getBootstrapContextWindow();
         const { input, read, write, output } = this.getSessionUsageTotals();
-        const stats = `↑${formatTokenWindow(input)} ↓${formatTokenWindow(output)} r${formatTokenWindow(read)} w${formatTokenWindow(write)}`;
+        const stats = `↑${formatFooterTokenCount(input)} ↓${formatFooterTokenCount(output)} r${formatFooterTokenCount(read)} w${formatFooterTokenCount(write)}`;
         const contextWindowUsageTokens = getAssistantContextWindowUsage(last);
         const percent = windowTokens > 0 ? (contextWindowUsageTokens / windowTokens) * 100 : 0;
         const percentStr = `${formatAdaptiveNumber(percent, 1, 3)}%`;
@@ -1554,11 +1676,8 @@ export class SessionChatController {
         }
     }
     getLastAssistantMessage() {
-        if (this.assistantMessages.length > 0) {
-            return this.assistantMessages[this.assistantMessages.length - 1];
-        }
-        for (let i = this.snapshot.messages.length - 1; i >= 0; i -= 1) {
-            const message = this.snapshot.messages[i]?.message;
+        for (let index = this.snapshot.messages.length - 1; index >= 0; index -= 1) {
+            const message = this.snapshot.messages[index]?.message;
             if (isAssistantMessage(message)) {
                 return message;
             }
@@ -1616,18 +1735,6 @@ export class SessionChatController {
         }
         return [...files];
     }
-    getAutoCompactionMetadata(snapshot) {
-        for (const entry of snapshot.messages) {
-            if (!isCoreMessage(entry.message)) {
-                continue;
-            }
-            const metadata = getAutoCompactionMetadataFromMessage(entry.message);
-            if (metadata) {
-                return metadata;
-            }
-        }
-        return undefined;
-    }
     async copyLastAssistantText() {
         await copyAssistantTextToClipboard({
             view: this.view,
@@ -1652,11 +1759,11 @@ export class SessionChatController {
     }
     async startDiffReview(argsText) {
         if (this.diffReviewService.isActive()) {
-            this.view.addSystemMessage("diff review is already active.", "warn");
+            this.view.showFooterNotice("diff review is already active.", "default");
             return;
         }
         if (!this.isDiffReviewIdle()) {
-            this.view.addSystemMessage("wait for tau to become idle before starting /diff.", "warn");
+            this.view.showFooterNotice("wait for tau to become idle before starting /diff.", "default");
             return;
         }
         const session = this.session;
@@ -1769,6 +1876,7 @@ export class SessionChatController {
         const now = Date.now();
         const candidates = this.snapshot.messages.flatMap((entry) => {
             if (!entry.modelVisible ||
+                !this.isMessageProjected(entry.id) ||
                 entry.message.role !== "user" ||
                 hasAutoCompactionContinuationMetadata(entry.message)) {
                 return [];
@@ -1787,7 +1895,7 @@ export class SessionChatController {
             ];
         });
         if (candidates.length === 0) {
-            this.view.addSystemMessage("no user messages available to rewind.", "warn");
+            this.view.showFooterNotice("no user messages available to rewind.", "default");
             return;
         }
         this.view.showRewindPicker({
@@ -1796,7 +1904,7 @@ export class SessionChatController {
                 const selected = candidates.find((candidate) => candidate.id === id);
                 if (!selected) {
                     this.view.hideRewindPicker();
-                    this.view.addSystemMessage("rewind selection failed.", "error");
+                    this.view.addTranscriptNotice("failed to select rewind point", "error");
                     return;
                 }
                 void this.applyRewindSelection(selected.id);
@@ -1817,39 +1925,43 @@ export class SessionChatController {
             this.refreshStatus();
         }
         catch {
-            this.view.addSystemMessage("rewind failed.", "error");
+            this.view.addTranscriptNotice("failed to rewind session", "error");
         }
     }
     interruptSelectedSubagent() {
         const selectedId = this.view.getSelectedSubagentId();
         if (!selectedId) {
-            this.view.addSystemMessage("no active subagent selected", "warn");
+            this.view.showFooterNotice("no active subagent selected", "default");
             return;
         }
         void this.session
             .interruptSubagent(selectedId)
             .then((result) => {
             if (!result.found) {
-                this.view.addSystemMessage(`unknown subagent id: ${selectedId}`, "warn");
+                this.view.showFooterNotice(`unknown subagent id: ${selectedId}`, "default");
             }
         })
             .catch((err) => {
-            this.view.addSystemMessage(`failed to interrupt subagent: ${err.message}`, "error");
+            this.view.addTranscriptNotice("failed to interrupt subagent", "error", [
+                err.message,
+            ]);
         });
     }
     async stashEditorToClipboard() {
         const text = this.view.getExpandedEditorText();
         if (!text.trim()) {
-            this.view.addSystemMessage("no input to stash yet", "warn");
+            this.view.showFooterNotice("no input to stash yet", "default");
             return;
         }
         try {
             await copyTextToClipboard(text);
             this.view.setEditorText("");
-            this.view.addSystemMessage("stashed input to clipboard", "success");
+            this.view.showFooterNotice("stashed input to clipboard", "default");
         }
         catch (err) {
-            this.view.addSystemMessage(`clipboard copy failed: ${err.message}`, "error");
+            this.view.addTranscriptNotice("failed to copy to clipboard", "error", [
+                err.message,
+            ]);
         }
     }
     isSingleLineInput(text) {
@@ -1871,28 +1983,69 @@ function formatSessionError(error) {
         : undefined;
     return cause && cause !== message ? `${message}: ${cause}` : message;
 }
-function getRenderableTimelineItems(snapshot) {
+function getRenderableTimelineItems(snapshot, ephemeralItems) {
     const messagesById = new Map(snapshot.messages.map((message) => [message.id, message]));
-    return snapshot.timeline.flatMap((item) => {
+    const items = [...snapshot.timeline.items, ...ephemeralItems].sort((left, right) => left.sequence - right.sequence);
+    return items.flatMap((item) => {
         if (item.type === "notice") {
             return [
                 {
                     type: "notice",
                     id: item.id,
                     severity: item.notice.severity,
-                    text: item.notice.text,
+                    title: item.notice.presentation.title,
+                    ...(item.notice.presentation.content
+                        ? { content: item.notice.presentation.content }
+                        : {}),
                 },
             ];
         }
-        if (item.type !== "message") {
-            return [];
+        if (item.type === "message") {
+            const message = messagesById.get(item.messageId);
+            if (!message) {
+                return [];
+            }
+            const outcomeNotice = getMessageOutcomeNotice(message);
+            return [
+                { type: "message", id: message.id, message },
+                ...(outcomeNotice ? [outcomeNotice] : []),
+            ];
+        }
+        if (item.type === "tool") {
+            const tool = snapshot.tools[item.toolId];
+            return tool ? [{ type: "tool", id: item.id, model: buildToolUiModel(snapshot, tool) }] : [];
         }
-        const message = messagesById.get(item.messageId);
-        return message ? [{ type: "message", id: message.id, message }] : [];
+        return [];
     });
 }
+function getMessageOutcomeNotice(message) {
+    if (!isAssistantMessage(message.message)) {
+        return undefined;
+    }
+    if (message.message.stopReason === "error") {
+        const afterToolExecution = message.message.content.some((content) => content.type === "toolCall");
+        return {
+            type: "notice",
+            id: `presentation:failure:${message.id}`,
+            severity: "error",
+            title: afterToolExecution
+                ? "model request failed after tool execution"
+                : "model request failed",
+            content: [message.message.errorMessage ?? "the model provider returned an unknown error"],
+        };
+    }
+    if (message.state === "interrupted") {
+        return {
+            type: "notice",
+            id: `presentation:interruption:${message.id}`,
+            severity: "info",
+            title: "assistant turn interrupted",
+        };
+    }
+    return undefined;
+}
 function isMessageInTimeline(snapshot, messageId) {
-    return snapshot.timeline.some((item) => item.type === "message" && item.messageId === messageId);
+    return snapshot.timeline.items.some((item) => item.type === "message" && item.messageId === messageId);
 }
 function assistantPartialFromProtocolMessage(message) {
     if (message.message.role !== "assistant") {
@@ -1985,21 +2138,15 @@ const RECOVERED_TOOL_ACTION_LABELS = {
     blocked: "blocked",
     cancelled: "cancelled",
 };
-function getToolUiModelsInModelOrder(snapshot) {
-    const facetsByToolId = new Map();
-    for (const facet of Object.values(snapshot.facets)) {
-        if (facet.kind === "tau.tool-ui-events" && facet.subject.type === "tool") {
-            facetsByToolId.set(facet.subject.id, facet);
-        }
-    }
-    return getToolIdsInModelOrder(snapshot).map((toolId) => {
-        const tool = snapshot.tools[toolId];
-        return {
-            toolCallId: tool.toolCallId,
-            status: tool.status,
-            presentation: getToolPresentation(snapshot, tool, facetsByToolId.get(toolId)),
-        };
-    });
+function buildToolUiModel(snapshot, tool) {
+    const facet = Object.values(snapshot.facets).find((candidate) => candidate.kind === "tau.tool-ui-events" &&
+        candidate.subject.type === "tool" &&
+        candidate.subject.id === tool.id);
+    return {
+        toolCallId: tool.toolCallId,
+        status: tool.status,
+        presentation: getToolPresentation(snapshot, tool, facet),
+    };
 }
 function getToolPresentation(snapshot, tool, facet) {
     if (facet?.kind !== "tau.tool-ui-events" || facet.version !== TOOL_UI_FACET_VERSION) {
@@ -2047,19 +2194,6 @@ function getRecoveredToolResult(snapshot, tool) {
     }
     return tool.error?.trim() || tool.summary?.trim() || undefined;
 }
-function getToolIdsInModelOrder(snapshot) {
-    const messageOrder = new Map(snapshot.messages.map((message, index) => [message.id, index]));
-    return Object.values(snapshot.tools)
-        .sort((left, right) => {
-        const leftPosition = left.status === "streaming" ? left.origin : left.call;
-        const rightPosition = right.status === "streaming" ? right.origin : right.call;
-        const leftMessageIndex = messageOrder.get(leftPosition.messageId) ?? Number.MAX_SAFE_INTEGER;
-        const rightMessageIndex = messageOrder.get(rightPosition.messageId) ?? Number.MAX_SAFE_INTEGER;
-        return (leftMessageIndex - rightMessageIndex ||
-            leftPosition.contentIndex - rightPosition.contentIndex);
-    })
-        .map((tool) => tool.id);
-}
 function getSubagentActivity(snapshot, agentId) {
     const facet = Object.values(snapshot.facets).find((candidate) => candidate.kind === SUBAGENT_ACTIVITY_FACET_KIND &&
         candidate.subject.type === "agent" &&