Fix desktop optimistic user echo

Author: Pyiner

desktop/garyx-desktop/src/renderer/src/app-shell/AppShell.tsx

@@ -5973,16 +5973,27 @@ export function AppShell() {
     });
     updateMessagesByThread((current) => {
       const existing = current[threadId] || [];
-      let updated = false;
+      let assistantUpdated = false;
       const nextEntries = existing.map((entry) => {
+        if (
+          entry.role === "user" &&
+          entry.intentId === intentId &&
+          entry.localState !== "remote_final"
+        ) {
+          return {
+            ...entry,
+            error: true,
+            localState: "error" as TranscriptEntryState,
+          };
+        }
         if (
           entry.role !== "assistant" ||
           entry.intentId !== intentId ||
           (!entry.pending && !entry.error)
         ) {
           return entry;
         }
-        updated = true;
+        assistantUpdated = true;
         return {
           ...entry,
           pending: false,
@@ -5991,7 +6002,7 @@ export function AppShell() {
           text: entry.pending ? message : entry.text || message,
         };
       });
-      if (updated) {
+      if (assistantUpdated) {
         return {
           ...current,
           [threadId]: nextEntries,
@@ -8421,8 +8432,19 @@ export function AppShell() {
         ...current,
         [threadId]: (() => {
           const existing = current[threadId] || [];
-          let updated = false;
+          let assistantUpdated = false;
           const next = existing.map((entry) => {
+            if (
+              entry.role === "user" &&
+              entry.intentId === failedIntentId &&
+              entry.localState !== "remote_final"
+            ) {
+              return {
+                ...entry,
+                error: true,
+                localState: errorState,
+              };
+            }
             const isTargetAssistant =
               entry.role === "assistant" &&
               entry.intentId === failedIntentId &&
@@ -8432,7 +8454,7 @@ export function AppShell() {
             if (!isTargetAssistant) {
               return entry;
             }
-            updated = true;
+            assistantUpdated = true;
             return {
               ...entry,
               pending: false,
@@ -8444,7 +8466,7 @@ export function AppShell() {
                 : entry.text || message,
             };
           });
-          if (updated) {
+          if (assistantUpdated) {
             return next;
           }
           return [
@@ -9070,6 +9092,18 @@ export function AppShell() {
     updateMessagesByThread((current) => ({
       ...current,
       [threadId]: (current[threadId] || []).map((entry) => {
+        if (
+          entry.role === "user" &&
+          entry.intentId &&
+          interruptedIntentIds.has(entry.intentId) &&
+          entry.localState !== "remote_final"
+        ) {
+          return {
+            ...entry,
+            error: true,
+            localState: "interrupted",
+          };
+        }
         if (entry.role !== "assistant") {
           return entry;
         }

desktop/garyx-desktop/src/renderer/src/app-shell/components/ThreadPage.tsx

@@ -46,7 +46,7 @@ import { parseTaskNotificationText } from "../../task-notification";
 import { deriveThreadTeamView } from "../../thread-model";
 import {
   buildThreadViewBlocks,
-  buildThreadViewRows,
+  buildThreadViewRowsWithLocalUsers,
   type MessagesBySeq,
   type RenderTranscriptBlock,
   type TurnRow,
@@ -550,8 +550,14 @@ export function ThreadPage({
   // block list so per-agent speaker headers can be interleaved.
   const turnRows = useMemo(
     () =>
-      teamView.isTeam ? [] : buildThreadViewRows(renderState, messagesBySeq),
-    [renderState, messagesBySeq, teamView.isTeam],
+      teamView.isTeam
+        ? []
+        : buildThreadViewRowsWithLocalUsers(
+            renderState,
+            messagesBySeq,
+            activeMessages,
+          ),
+    [renderState, messagesBySeq, activeMessages, teamView.isTeam],
   );
   const teamBlocks = useMemo(
     () =>

desktop/garyx-desktop/src/renderer/src/render-view-model.test.mjs

@@ -2,10 +2,13 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 
-import {
+import * as renderViewModel from './render-view-model.ts';
+
+const {
   buildThreadViewBlocks,
   buildThreadViewRows,
-} from './render-view-model.ts';
+  buildThreadViewRowsWithLocalUsers,
+} = renderViewModel;
 
 const renderFixture = JSON.parse(
   readFileSync(
@@ -239,6 +242,128 @@ test('origin user ids remain stable while the body resolves by seq', () => {
   assert.equal(rows[0].userBlock.entry.message.text, 'hello');
 });
 
+test('local optimistic user row renders before committed render_state includes it', () => {
+  const localUser = {
+    id: 'origin:intent-optimistic-1',
+    role: 'user',
+    text: 'Please run the desktop smoke test.',
+    timestamp: '2026-06-23T00:00:00.000Z',
+    intentId: 'intent-optimistic-1',
+    localState: 'optimistic',
+  };
+  const renderState = {
+    based_on_seq: 0,
+    rows: [],
+    tailActivity: 'none',
+    activeToolGroupId: null,
+    progress_locus: 'none',
+    visibleMessageIds: [],
+    filtered_placeholders: [],
+  };
+
+  const rows = buildThreadViewRowsWithLocalUsers(renderState, new Map(), [
+    localUser,
+  ]);
+
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].kind, 'user_turn');
+  assert.equal(rows[0].key, `user-turn:${localUser.id}`);
+  assert.equal(rows[0].userBlock.entry.message.text, localUser.text);
+});
+
+test('local optimistic user row dedupes once render_state represents its origin id', () => {
+  const originId = 'origin:intent-optimistic-2';
+  const renderState = {
+    based_on_seq: 3,
+    rows: [
+      {
+        kind: 'user_turn',
+        id: `user_turn:${originId}`,
+        user: { id: originId, seq: 3, role: 'user' },
+        activity: [],
+        started_at: null,
+        finished_at: null,
+      },
+    ],
+    tailActivity: 'none',
+    activeToolGroupId: null,
+    progress_locus: 'none',
+    visibleMessageIds: [originId],
+    filtered_placeholders: [],
+  };
+  const committed = {
+    id: originId,
+    seq: 3,
+    role: 'user',
+    text: 'Run the smoke test.',
+    localState: 'remote_final',
+  };
+  const optimistic = {
+    ...committed,
+    seq: undefined,
+    localState: 'optimistic',
+    intentId: 'intent-optimistic-2',
+  };
+
+  const rows = buildThreadViewRowsWithLocalUsers(
+    renderState,
+    new Map([[3, committed]]),
+    [optimistic],
+  );
+
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].kind, 'user_turn');
+  assert.equal(rows[0].userBlock.entry.message.text, committed.text);
+});
+
+test('local failed user row remains visible for retry chrome', () => {
+  const failedUser = {
+    id: 'origin:intent-failed-1',
+    role: 'user',
+    text: 'Deploy the staging build.',
+    timestamp: '2026-06-23T00:00:00.000Z',
+    intentId: 'intent-failed-1',
+    localState: 'error',
+    error: true,
+  };
+
+  const rows = buildThreadViewRowsWithLocalUsers(null, new Map(), [failedUser]);
+
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].kind, 'user_turn');
+  assert.equal(rows[0].userBlock.entry.message.error, true);
+  assert.equal(rows[0].userBlock.entry.message.localState, 'error');
+});
+
+test('local assistant error row does not render through the user overlay', () => {
+  const optimisticUser = {
+    id: 'origin:intent-failed-2',
+    role: 'user',
+    text: 'Deploy the staging build.',
+    timestamp: '2026-06-23T00:00:00.000Z',
+    intentId: 'intent-failed-2',
+    localState: 'optimistic',
+  };
+  const assistantError = {
+    id: 'assistant:error:intent-failed-2:synthetic',
+    role: 'assistant',
+    text: 'Gateway rejected the request.',
+    timestamp: '2026-06-23T00:00:01.000Z',
+    intentId: 'intent-failed-2',
+    localState: 'error',
+    error: true,
+  };
+
+  const rows = buildThreadViewRowsWithLocalUsers(null, new Map(), [
+    optimisticUser,
+    assistantError,
+  ]);
+
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].kind, 'user_turn');
+  assert.equal(rows[0].userBlock.entry.message.id, optimisticUser.id);
+});
+
 test('unloaded committed window: rows whose bodies are absent are skipped', () => {
   const fixtureCase = renderFixture.cases.find(
     (c) => c.name === 'final answer completed',

desktop/garyx-desktop/src/renderer/src/render-view-model.ts

@@ -79,6 +79,10 @@ export interface UserTurnRow {
 
 export type TurnRenderRow = FlatRow | TurnRow | UserTurnRow;
 
+type LocalTranscriptMessage = TranscriptMessage & {
+  localState?: string;
+};
+
 /**
  * Committed messages keyed by their raw transcript record `seq` (1-based),
  * stamped at the wire boundary (`TranscriptMessage.seq`). The message id is NOT
@@ -106,6 +110,69 @@ function messageBlock(message: TranscriptMessage): RenderTranscriptBlock {
   };
 }
 
+function collectBlockMessageIds(
+  block: RenderTranscriptBlock | null | undefined,
+  ids: Set<string>,
+) {
+  if (!block) {
+    return;
+  }
+  if (block.kind === 'message') {
+    ids.add(block.entry.message.id);
+    return;
+  }
+  for (const entry of block.entries) {
+    if (entry.toolUse) {
+      ids.add(entry.toolUse.id);
+    }
+    if (entry.toolResult) {
+      ids.add(entry.toolResult.id);
+    }
+  }
+}
+
+function collectActivityRowMessageIds(
+  row: UserTurnActivityRow,
+  ids: Set<string>,
+) {
+  if (row.kind === 'flat') {
+    collectBlockMessageIds(row.block, ids);
+    return;
+  }
+  for (const block of row.steps) {
+    collectBlockMessageIds(block, ids);
+  }
+  collectBlockMessageIds(row.finalBlock, ids);
+}
+
+function representedMessageIdsForRows(rows: TurnRenderRow[]): Set<string> {
+  const ids = new Set<string>();
+  for (const row of rows) {
+    if (row.kind === 'flat') {
+      collectBlockMessageIds(row.block, ids);
+      continue;
+    }
+    if (row.kind === 'turn') {
+      collectActivityRowMessageIds(row, ids);
+      continue;
+    }
+    collectBlockMessageIds(row.userBlock, ids);
+    for (const activityRow of row.activityRows) {
+      collectActivityRowMessageIds(activityRow, ids);
+    }
+  }
+  return ids;
+}
+
+function isLocalUserMessage(message: LocalTranscriptMessage): boolean {
+  return (
+    message.role === 'user' &&
+    Boolean(message.localState) &&
+    message.localState !== 'remote_final' &&
+    !(Boolean(message.internal) && message.internalKind === 'loop_continuation')
+  );
+}
+
 function toolEntry(
   entry: RenderToolEntry,
   messages: MessagesBySeq,
@@ -229,6 +296,37 @@ export function buildThreadViewRows(
   return rows;
 }
 
+export function buildThreadViewRowsWithLocalUsers(
+  renderState: RenderState | null | undefined,
+  messages: MessagesBySeq,
+  activeMessages: readonly LocalTranscriptMessage[],
+): TurnRenderRow[] {
+  const rows = buildThreadViewRows(renderState, messages);
+  const representedMessageIds = representedMessageIdsForRows(rows);
+  const committedMessageIds = new Set(
+    [...messages.values()].map((message) => message.id),
+  );
+  const localRows: UserTurnRow[] = [];
+  for (const message of activeMessages) {
+    if (!isLocalUserMessage(message)) {
+      continue;
+    }
+    if (
+      representedMessageIds.has(message.id) ||
+      committedMessageIds.has(message.id)
+    ) {
+      continue;
+    }
+    localRows.push({
+      kind: 'user_turn',
+      key: `user-turn:${message.id}`,
+      userBlock: messageBlock(message),
+      activityRows: [],
+    });
+  }
+  return localRows.length ? [...rows, ...localRows] : rows;
+}
+
 /**
  * Deterministic flatten of `render_state.rows` → ordered blocks for team mode,
  * which renders blocks linearly with per-agent speaker headers instead of