mixdog 1.1.2 → 1.2.0

package/src/tui/session/turn-stream.mjs

@@ -5,6 +5,7 @@
 // scalars); every function here takes it as its first argument.
 import { TUI_FRAME_MS, yieldToRenderer } from './render-timing.mjs';
 import { retryStatusLine } from '../../runtime/shared/err-text.mjs';
+import { newTranscriptMessageId } from '../../runtime/shared/transcript-metadata.mjs';
 
 // Share Ink's exact 120fps cadence with the frame-batched store. A separate
 // 16ms timer left every other terminal frame idle, so completed script lines
@@ -59,9 +60,27 @@ function ensureAssistant(stream, initialText = '') {
   if (!stream.currentAssistantId) {
     stream.currentAssistantId = stream.nextId();
     const meta = stream.transcriptMeta;
-    const assistantAt =
-      Number.isFinite(Number(meta.assistantAt)) && Number(meta.assistantAt) > 0 ? Number(meta.assistantAt) : Date.now();
-    meta.assistantAt = assistantAt;
+    // A non-streaming continuation was persisted before its text reached this
+    // row: the runtime left that message's id and time (ask-session
+    // takeAssistant), and the row carries them instead of minting new ones.
+    const persisted = stream.claimPersistedAssistant ? meta.persistedAssistant : null;
+    if (persisted) meta.persistedAssistant = null;
+    let assistantAt = persisted?.at;
+    let messageId = persisted?.messageId;
+    if (!persisted) {
+      assistantAt =
+        Number.isFinite(Number(meta.assistantAt)) && Number(meta.assistantAt) > 0
+          ? Number(meta.assistantAt)
+          : Date.now();
+      meta.assistantAt = assistantAt;
+      // The reply this segment becomes is persisted with this stable id (the
+      // runtime takes it with assistantAt), so a compaction that drops the
+      // reply greys this row.
+      if (!(typeof meta.assistantMessageId === 'string' && meta.assistantMessageId)) {
+        meta.assistantMessageId = newTranscriptMessageId();
+      }
+      messageId = meta.assistantMessageId;
+    }
     // Do NOT reset currentAssistantText here: the first onTextDelta has
     // already accumulated the opening chunk before this batched flush runs.
     // Segment resets are owned by closeAssistantSegment(). Seed the new row
@@ -70,6 +89,7 @@ function ensureAssistant(stream, initialText = '') {
     stream.updateStreamingTail(stream.currentAssistantId, {
       text: String(initialText || ''),
       at: assistantAt,
+      messageId,
       ...stream.routeMeta,
     });
   }
@@ -86,6 +106,7 @@ function resetLineScan(stream) {
 function closeAssistantSegment(stream) {
   stream.currentAssistantId = null;
   stream.currentAssistantText = '';
+  stream.claimPersistedAssistant = false;
   resetLineScan(stream);
 }
 
@@ -290,11 +311,18 @@ export function appendTextDelta(stream, textChunk) {
 // Mid-turn assistant text that precedes a tool call from a provider that only
 // returns the final response.content (no deltas); the streaming path owns
 // the render when it already produced text for this segment.
-export function appendAssistantText(stream, full) {
+export function appendAssistantText(stream, full, { committed = false } = {}) {
   endThinkingForText(stream);
   stream.assistantText += full;
   stream.currentAssistantText += full;
   stream.pendingTextFlush = true;
+  // Only post-commit text is the persisted message's own: its row takes that
+  // id. Any other text (a tool preamble published before its message commits)
+  // leaves an earlier recorded id unclaimed, so drop it.
+  stream.claimPersistedAssistant = committed;
+  if (!committed && stream.transcriptMeta && typeof stream.transcriptMeta === 'object') {
+    stream.transcriptMeta.persistedAssistant = null;
+  }
   flushStreamBatch(stream);
 }
 

package/src/tui/session/turn-tool-cards.mjs

@@ -57,10 +57,12 @@ export async function builtinSkillNamesFor(runtime, calls) {
 }
 
 // Transcript spec for a standalone (non-aggregated) tool card.
-function standaloneCardSpec(itemId, name, args) {
+function standaloneCardSpec(itemId, name, args, callId = '') {
   return {
     kind: 'tool',
     id: itemId,
+    // Ties the card to its call (a compaction that drops it greys the card).
+    ...(callId ? { callId } : {}),
     name,
     args,
     result: null,
@@ -221,7 +223,13 @@ function openToolCard(cards, call, index, batch) {
     // Defer the visible push: the card enters the transcript when its real
     // header will paint (delay elapsed) or its result lands first, so no
     // blank placeholder height scrolls the body ahead of the glyphs.
-    const card = { itemId, callId: callKey, done: false, pushed: false, spec: standaloneCardSpec(itemId, name, args) };
+    const card = {
+      itemId,
+      callId: callKey,
+      done: false,
+      pushed: false,
+      spec: standaloneCardSpec(itemId, name, args, callId),
+    };
     cards.deferredCards.registerCard(card);
     trackCard(cards, callId, card);
     // Immediate row-reserve is deferred until every touched aggregate has its

package/src/tui/session/turn.mjs

@@ -18,6 +18,7 @@ import { isRejected429, safeErrorDetails } from '../../runtime/shared/error-pres
 import { registerTaskWaitSteeringCheck } from '../../runtime/agent/orchestrator/session/task-wait-control.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { yieldToRenderer } from './render-timing.mjs';
+import { archiveItemsForCompaction, compactionArchivedRows } from './compaction-view.mjs';
 import {
   createTurnStream,
   flushStreamBatch,
@@ -105,7 +106,8 @@ function beginTurn({ flags, getState, transcriptRouteMetadata }, options) {
     completionVerb,
   };
   flags.pendingTranscriptMeta = null;
-  const { at: _userItemAt, ...routeMeta } = transcriptMeta;
+  // The prompt's own time and stable id stay on the prompt row.
+  const { at: _userItemAt, messageId: _promptMessageId, ...routeMeta } = transcriptMeta;
   return {
     index,
     startedAt,
@@ -182,6 +184,11 @@ function commitPromptRestore(flags, turn) {
 
 function steeringItemExtras(steeringMeta) {
   return {
+    // The steered message's stable id, so a compaction that drops it greys
+    // this row.
+    ...(typeof steeringMeta?.messageId === 'string' && steeringMeta.messageId
+      ? { messageId: steeringMeta.messageId }
+      : {}),
     // Queue mode + execution provenance: a task notification is rendered as
     // a tool card, never as an injected user bubble.
     ...(steeringMeta?.mode === 'task-notification' ? { mode: 'task-notification' } : {}),
@@ -261,10 +268,10 @@ function publishContextPressure({ syncContextStats, getState, set }, info) {
 }
 
 // Compaction itself remains owned by the pre-provider-send pass. This event
-// trims the visible transcript to the current turn and refreshes the gauge
-// from the already-mutated transcript before another render can show stale
-// pressure.
-function applyCompactEvent(ctx, event) {
+// archives the visible rows before the current turn (they stay in view above
+// the compaction divider) and refreshes the gauge from the already-mutated
+// transcript before another render can show stale pressure.
+export function applyCompactEvent(ctx, event) {
   const { turn, stream, cards, getState, set, replaceItems, pushItem, nextId, syncContextStats, routeState } = ctx;
   flushStreamBatch(stream);
   // Non-tool transcript item — same block-boundary rule as the steered user
@@ -272,12 +279,31 @@ function applyCompactEvent(ctx, event) {
   cards.aggregates.clearAggregateContinuation();
   const compactStatus = String(event?.status || '').toLowerCase();
   const compactChanged = !['failed', 'skipped', 'no_change'].includes(compactStatus);
+  const doneItem = {
+    kind: 'statusdone',
+    id: nextId(),
+    label: compactEventLabel(event),
+    detail: compactEventDetail(event),
+  };
   if (compactChanged) {
-    set({ items: replaceItems(getState().items.slice(turn.currentItemsStart), { preserveStreamingTail: true }) });
-    turn.currentItemsStart = 0;
+    // The current turn starts at its submitted row (spill paging may have
+    // shifted the index recorded at turn start).
+    const current = getState().items;
+    const submitted = new Set(turn.submittedIds.filter((id) => id != null));
+    const submittedIndex = submitted.size ? current.findIndex((item) => submitted.has(item?.id)) : -1;
+    const boundary = submittedIndex >= 0 ? submittedIndex : turn.currentItemsStart;
+    const { items, dividerIndex } = archiveItemsForCompaction(current, doneItem, boundary, {
+      archived: compactionArchivedRows(event),
+      // Only explicit identities name what left the current turn; a bare
+      // count says nothing about it.
+      archiveTail: Boolean(event?.droppedIdentities && typeof event.droppedIdentities === 'object'),
+    });
+    set({ items: replaceItems(items, { preserveStreamingTail: true, preserveSpill: true }) });
+    turn.currentItemsStart = dividerIndex + 1;
     turn.transcriptCompacted = true;
+  } else {
+    pushItem(doneItem);
   }
-  pushItem({ kind: 'statusdone', id: nextId(), label: compactEventLabel(event), detail: compactEventDetail(event) });
   syncContextStats({ allowEstimated: true, invalidateExact: compactChanged });
   // syncContextStats only STAGES its patch; publication is the caller's, and
   // without this set the post-compact gauge reached React only if some later
@@ -359,7 +385,7 @@ function streamHandlers(ctx) {
       appendTextDelta(stream, textChunk);
     },
     onTextReset: (reset = {}) => (isCurrentTurn() ? resetStreamedText(stream, reset) : false),
-    onAssistantText: (text) => {
+    onAssistantText: (text, detail) => {
       const full = String(text ?? '');
       if (!full.trim() || !isCurrentTurn()) return;
       // The streaming path owns this segment when it already produced text.
@@ -367,7 +393,7 @@ function streamHandlers(ctx) {
       // there across tool calls.
       if (stream.currentAssistantText.trim()) return;
       ctx.markPromptCommitted();
-      appendAssistantText(stream, full);
+      appendAssistantText(stream, full, { committed: detail?.committed === true });
     },
     onReasoningDelta: (chunk) => {
       if (isCurrentTurn()) appendReasoningDelta(stream, String(chunk ?? ''));
@@ -420,9 +446,12 @@ export function failTurn(ctx, error) {
 }
 
 export function turnDoneItem({ turn, stream, cards, getState, nextId }) {
+  // The outer prompt id is the turn's change-record key (runtime.ask `id`).
+  const checkpointId = turn.submittedIds[0] == null ? '' : String(turn.submittedIds[0]).trim();
   return {
     kind: 'turndone',
     id: nextId(),
+    ...(checkpointId ? { checkpointId } : {}),
     elapsedMs: Date.now() - turn.startedAt,
     status: turnOutcome(turn.cancelled, turn.failed),
     // Notifications resolve this exact terminal assistant item, never a