fix(flowchat): reload history after cross-device rollback

Author: wgqqqqq

src/web-ui/AGENTS.md

@@ -122,6 +122,11 @@ also run the focused state contracts:
 pnpm --dir src/web-ui run test:run src/app/services/sessionSceneLifecycle.test.ts src/flow_chat/services/sessionActivation.test.ts src/flow_chat/services/storeSync.test.ts src/app/stores/sceneStore.test.ts
 ```
 
+For cross-device undo/redo/rollback history invalidation and settled-Turn fences,
+run `pnpm --dir src/web-ui run test:run src/flow_chat/services/flow-chat-manager/EventHandlerModule.test.ts`.
+Missing fence identities (including legacy payloads) must reload authoritative
+history; an explicit settled-Turn identity must preserve newer live Turns.
+
 For ecosystem discovery, import, or compatibility status presentation changes:
 
 ```bash

src/web-ui/src/flow_chat/services/flow-chat-manager/EventHandlerModule.test.ts

@@ -1647,6 +1647,7 @@ describe('handleSessionHistoryChanged', () => {
     const context = createFlowChatContext();
     handleSessionHistoryChanged(context, {
       sessionId: 'session-1',
+      settledTurnId: 'turn-1',
     });
     await Promise.resolve();
 
@@ -1672,12 +1673,84 @@ describe('handleSessionHistoryChanged', () => {
     const context = createFlowChatContext();
     handleSessionHistoryChanged(context, {
       sessionId: 'session-1',
+      settledTurnId: 'turn-1',
     });
     await Promise.resolve();
 
     expect(reconcile).not.toHaveBeenCalled();
     expect(context.pendingHistoryFenceSessions.has('session-1')).toBe(true);
   });
+
+  it.each([
+    { sessionId: 'session-1', settledTurnId: null },
+    { sessionId: 'session-1' },
+    { session_id: 'session-1', settled_turn_id: null },
+  ])('removes rolled-back turns with an authoritative reload, including legacy payloads: %j', async event => {
+    createSessionWithTurn({
+      ...createFinishingTurn(),
+      status: 'completed',
+      endTime: 1000,
+    });
+    const store = FlowChatStore.getInstance();
+    store.setState(prev => ({
+      ...prev,
+      activeSessionId: 'session-1',
+      sessions: new Map([['session-1', {
+        ...prev.sessions.get('session-1')!,
+        workspacePath: '/workspace',
+        workspaceId: 'workspace-1',
+        config: { agentType: 'Standard', workspaceId: 'workspace-1' },
+      }]]),
+    }));
+    vi.spyOn(agentAPI, 'restoreSessionView').mockResolvedValue({
+      session: {
+        sessionId: 'session-1', sessionName: 'Session 1', agentType: 'Standard',
+        state: 'Idle', turnCount: 0, createdAt: 1, updatedAt: 2,
+      },
+      turns: [],
+      contextRestoreState: 'ready',
+      isPartial: false,
+      loadedTurnCount: 0,
+      totalTurnCount: 0,
+    } as any);
+    const reconcile = vi.spyOn(store, 'reconcileSettledDialogTurn');
+    const context = createFlowChatContext();
+    context.pendingHistoryFenceSessions.add('session-1');
+
+    handleSessionHistoryChanged(context, event);
+
+    await vi.waitFor(() => expect(store.getState().sessions.get('session-1')?.dialogTurns).toEqual([]));
+    expect(reconcile).not.toHaveBeenCalled();
+    expect(context.pendingHistoryFenceSessions.has('session-1')).toBe(false);
+  });
+
+  it('reloads an out-of-lifecycle edit even when the obsolete local tail is still finishing', () => {
+    createSessionWithTurn(createFinishingTurn());
+    const store = FlowChatStore.getInstance();
+    const reload = vi.spyOn(store, 'loadSessionHistory').mockResolvedValue(undefined);
+    const context = createFlowChatContext();
+
+    handleSessionHistoryChanged(context, { sessionId: 'session-1', settledTurnId: null });
+
+    expect(reload).toHaveBeenCalledExactlyOnceWith('session-1', { includeInternal: false });
+    expect(context.pendingHistoryFenceSessions.has('session-1')).toBe(false);
+  });
+
+  it('repairs the identified settled turn without dropping a newer live turn', () => {
+    createSessionWithTurn({ ...createFinishingTurn(), status: 'completed', endTime: 1000 });
+    const store = FlowChatStore.getInstance();
+    store.addDialogTurn('session-1', { ...createFinishingTurn(), id: 'turn-2', status: 'processing' });
+    const reconcile = vi.spyOn(store, 'reconcileSettledDialogTurn').mockResolvedValue(false);
+    const reload = vi.spyOn(store, 'loadSessionHistory').mockResolvedValue(undefined);
+    const context = createFlowChatContext();
+
+    handleSessionHistoryChanged(context, { session_id: 'session-1', settled_turn_id: 'turn-1' });
+
+    expect(reconcile).toHaveBeenCalledExactlyOnceWith('session-1', 'turn-1');
+    expect(reload).not.toHaveBeenCalled();
+    expect(context.pendingHistoryFenceSessions.has('session-1')).toBe(false);
+    expect(store.getState().sessions.get('session-1')?.dialogTurns.at(-1)?.status).toBe('processing');
+  });
 });
 
 describe('handleDialogTurnComplete', () => {
@@ -1761,7 +1834,7 @@ describe('handleDialogTurnComplete', () => {
 
     // Durable fence lands while the turn is still finalizing: it must be
     // parked instead of racing the persistence commit with an extra read.
-    handleSessionHistoryChanged(context, { sessionId: 'session-1' });
+    handleSessionHistoryChanged(context, { sessionId: 'session-1', settledTurnId: 'turn-1' });
     expect(FlowChatStore.getInstance().reconcileSettledDialogTurn)
       .not.toHaveBeenCalled();
     expect(context.pendingHistoryFenceSessions.has('session-1')).toBe(true);

src/web-ui/src/flow_chat/services/flow-chat-manager/EventHandlerModule.ts

@@ -1603,6 +1603,8 @@ export function handleSessionStateChanged(context: FlowChatContext, event: any):
 }
 
 /**
+ * Reload the authoritative history after an out-of-lifecycle edit. A durable
+ * fence carrying a settled Turn identity only needs to re-read that Turn.
  * Re-read the terminal tail only after the Runtime announces that its Turn is
  * durable. DialogTurnCompleted is intentionally lower latency than the final
  * persistence write, so relying on that event alone can preserve a painted
@@ -1626,17 +1628,28 @@ export function handleSessionHistoryChanged(context: FlowChatContext, event: any
     return;
   }
 
-  const latestTurn = session.dialogTurns[session.dialogTurns.length - 1];
-  if (latestTurn && !['completed', 'cancelled', 'error'].includes(latestTurn.status)) {
+  const settledTurnId = event?.settledTurnId ?? event?.settled_turn_id;
+  if (!settledTurnId) {
+    // Undo/redo and rollback remove visible Turns. Repairing one old tail Turn
+    // cannot remove that suffix, including when the history becomes empty.
+    // Older hosts omit the optional identity, so use full invalidation there too.
+    context.pendingHistoryFenceSessions.delete(sessionId);
+    void context.flowChatStore.loadSessionHistory(sessionId, {
+      includeInternal: session.sessionKind === 'subagent',
+    }).catch(error => {
+      log.warn('Failed to reload changed session history', { sessionId, error });
+    });
+    return;
+  }
+
+  const settledTurn = session.dialogTurns.find(turn => turn.id === settledTurnId);
+  if (settledTurn && !['completed', 'cancelled', 'error'].includes(settledTurn.status)) {
     // The local projection has not settled yet (completion quiet window, or
     // the next Turn already started). Defer to the completion finalizer.
     context.pendingHistoryFenceSessions.add(sessionId);
     return;
   }
 
-  const settledTurn = [...session.dialogTurns]
-    .reverse()
-    .find(turn => ['completed', 'cancelled', 'error'].includes(turn.status));
   if (!settledTurn) {
     return;
   }