fix: show approvals raised after a running Session is reloaded (#2026)

Author: 4pmtong

src/components/ChatBox/UserQueryGroup.tsx

@@ -13,7 +13,7 @@
 // ========= Copyright 2025-2026 @ Eigent.ai All Rights Reserved. =========
 
 import { isUserMessageReplyToAsk } from '@/lib/humanInteractionMessages';
-import { useRunWriterWait } from '@/lib/runEvents';
+import { useProjectedRunStatus, useRunWriterWait } from '@/lib/runEvents';
 import { inferSessionModeFromTask } from '@/lib/sessionMode';
 import { resolveWorkspaceFilePath } from '@/lib/workspaceRelativePath';
 import { completeHumanInteraction } from '@/service/humanInteractionCompletion';
@@ -209,6 +209,10 @@ export const UserQueryGroup: React.FC<UserQueryGroupProps> = ({
     (state) => state.activeProjectId
   );
   const writerWait = useRunWriterWait(activeProjectId, activeTaskId);
+  const projectedRunStatus = useProjectedRunStatus(
+    activeProjectId,
+    activeTaskId
+  );
 
   // Subscribe to streaming decompose text separately for efficient updates
   const streamingDecomposeText = useSyncExternalStore(
@@ -234,6 +238,16 @@ export const UserQueryGroup: React.FC<UserQueryGroupProps> = ({
     );
 
   const activeTask = activeTaskId ? chatState.tasks[activeTaskId] : undefined;
+  // A restored Run keeps the status read when its Session was loaded. A
+  // request raised after that reaches the same replay stream but only moves
+  // the Run projection, so it may lift a status that has not ended.
+  const replayRunStatus =
+    projectedRunStatus === 'waiting_for_user' &&
+    (activeTask?.durableRunStatus === undefined ||
+      activeTask.durableRunStatus === 'pending' ||
+      activeTask.durableRunStatus === 'running')
+      ? projectedRunStatus
+      : activeTask?.durableRunStatus;
   const ownsFailureSummary =
     queryGroup.ownsRunWorkLog === true &&
     UNSUCCESSFUL_RUN_STATUSES.has(activeTask?.durableRunStatus!) &&
@@ -523,7 +537,7 @@ export const UserQueryGroup: React.FC<UserQueryGroupProps> = ({
             activeTaskId,
             taskType: activeTask.type,
             taskStatus: activeTask.status,
-            durableRunStatus: activeTask.durableRunStatus,
+            durableRunStatus: replayRunStatus,
           });
 
         // A replay reattached to a live durable waiter remains actionable even

src/lib/runEvents/react.ts

@@ -13,7 +13,11 @@
 // ========= Copyright 2025-2026 @ Eigent.ai All Rights Reserved. =========
 // Licensed under the Apache License, Version 2.0 (the "License");
 
-import type { ProjectedWriterWait, ProjectViewState } from '@/lib/projector';
+import type {
+  ProjectedRun,
+  ProjectedWriterWait,
+  ProjectViewState,
+} from '@/lib/projector';
 import { useCallback, useSyncExternalStore } from 'react';
 import { runProjectionStore } from './projectionStore';
 
@@ -47,3 +51,16 @@ export function useRunWriterWait(
   );
   return useRunProjectionSelector(projectId, select);
 }
+
+/** The canonical status of a Run, or null before it is projected. */
+export function useProjectedRunStatus(
+  projectId: string | null,
+  runId: string | null | undefined
+): ProjectedRun['status'] | null {
+  const select = useCallback(
+    (state: ProjectViewState | null) =>
+      (runId && state?.runs[runId]?.status) || null,
+    [runId]
+  );
+  return useRunProjectionSelector(projectId, select);
+}

test/unit/components/ChatBox/UserQueryGroup.test.tsx

@@ -18,6 +18,7 @@ import type { VanillaChatStore } from '@/store/chatStore';
 import { useSpaceStore } from '@/store/spaceStore';
 import { AgentStep, ChatTaskStatus, SessionMode } from '@/types/constants';
 import {
+  act,
   cleanup,
   fireEvent,
   render,
@@ -56,6 +57,12 @@ vi.mock('@/store/projectRuntimeStore', () => ({
   ),
 }));
 
+// Brain confirms that every approval in these tests is still pending.
+vi.mock('@/service/humanInteractionApi', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@/service/humanInteractionApi')>()),
+  isHumanInteractionStillPending: vi.fn(async () => true),
+}));
+
 vi.mock('@/lib/projectRuntimeHydration', () => ({
   ensureProjectRuntimeLoaded: navigation.ensureProjectRuntimeLoaded,
 }));
@@ -586,3 +593,108 @@ describe('UserQueryGroup Space writer wait', () => {
     expect(screen.queryByRole('button', { name: 'Open session' })).toBeNull();
   });
 });
+
+describe('UserQueryGroup restored Run requests', () => {
+  const expiresAt = Date.now() / 1000 + 86_400;
+  const messages = [
+    { id: 'user-1', role: 'user', content: 'Write two files' },
+    {
+      id: 'ask-two',
+      role: 'agent',
+      step: AgentStep.ASK,
+      content: 'The agent wants to write a file.',
+      agent_name: 'single_agent',
+      interaction: {
+        interaction_id: 'approval:call-two',
+        interaction_type: 'approval',
+        approval_id: 'approval:call-two',
+        run_id: 'run-1',
+        version: 0,
+        expires_at: expiresAt,
+        question: 'The agent wants to write a file.',
+        title: 'Allow write_to_file?',
+        agent: 'single_agent',
+        action_digest: 'digest-two',
+        allowed_scopes: ['once'],
+        target_resources: [],
+      },
+    },
+  ];
+  let version = 0;
+  const project = (...eventTypes: string[]) => {
+    const ingress = new RunEventIngress('session-waiting', 'run-1');
+    for (const eventType of eventTypes) {
+      version += 1;
+      ingress.ingest({
+        event_id: `restored-${version}`,
+        project_id: 'session-waiting',
+        run_id: 'run-1',
+        run_sequence: version,
+        run_version: version,
+        event_type: eventType,
+        legacy_step: null,
+        created_at: '2026-10-07T10:00:00Z',
+        payload:
+          eventType === 'approval.requested'
+            ? { approval_id: 'approval:call-two', expires_at: expiresAt }
+            : {},
+      });
+    }
+  };
+  const restored = (durableRunStatus: string | undefined) =>
+    renderGroups(messages, { type: 'replay', durableRunStatus });
+  const card = () => screen.queryByText('Allow write_to_file?');
+
+  afterEach(() => {
+    cleanup();
+    runProjectionStore.clear();
+    version = 0;
+  });
+
+  it('offers a request raised after the Session was restored', async () => {
+    project('run.attempt_created', 'run.attempt_started');
+    restored('running');
+    expect(card()).toBeNull();
+
+    act(() => project('approval.requested'));
+
+    expect(card()).not.toBeNull();
+    await waitFor(() =>
+      expect(screen.getByRole('button', { name: 'Approve once' })).toBeEnabled()
+    );
+  });
+
+  it('keeps the card of a Run that was already waiting when restored', () => {
+    restored('waiting_for_user');
+
+    expect(card()).not.toBeNull();
+  });
+
+  it('keeps the request read-only after the Run was interrupted', () => {
+    project('run.attempt_created', 'run.attempt_started', 'run.interrupted');
+    restored('running');
+
+    expect(card()).toBeNull();
+  });
+
+  it('never reopens a Run that has ended', () => {
+    project('run.attempt_created', 'approval.requested');
+    restored('completed');
+
+    expect(card()).toBeNull();
+  });
+
+  it('offers the request when only the projection knows the Run waits', () => {
+    project('run.attempt_created', 'approval.requested');
+    restored(undefined);
+
+    expect(card()).not.toBeNull();
+  });
+
+  it('keeps a replay read-only until its Run waits', () => {
+    project('run.attempt_created', 'run.attempt_started');
+    restored(undefined);
+
+    expect(card()).toBeNull();
+  });
+});