Fix aiAct execution/report misalignment in recorder flows (#2204)

* test(core): reproduce aiAct timeline mismatch

* fix(core): isolate aiAct history per action

* fix(report): sort executions by stable start time

* fix(report): move execution sorting from sidebar view to store layer

Sorting only in the sidebar tableData left replay-all, keyboard
navigation (Cmd+Up/Down), and useAllCurrentTasks() consuming the
unsorted raw executions array. This caused the player animation
order to diverge from the sidebar when concurrent executions
reordered by timestamp.

Move sortExecutions() into setGroupedDump so that dump.executions
is sorted once at the data entry point, making sidebar rendering,
replay-all playback, and keyboard traversal all share the same
chronological order.

* fix(report): preserve execution array order in store

* fix(report): revert store changes from pr

Author: quanru

packages/core/src/agent/tasks.ts

@@ -73,8 +73,6 @@ export class TaskExecutor {
 
   private readonly taskBuilder: TaskBuilder;
 
-  private conversationHistory: ConversationHistory;
-
   onTaskStartCallback?: ExecutionTaskProgressOptions['onTaskStart'];
 
   private readonly hooks?: TaskExecutorHooks;
@@ -111,7 +109,6 @@ export class TaskExecutor {
     this.waitAfterAction = opts.waitAfterAction;
     this.useDeviceTimestamp = opts.useDeviceTimestamp;
     this.hooks = opts.hooks;
-    this.conversationHistory = new ConversationHistory();
     this.providedActionSpace = opts.actionSpace;
     this.taskBuilder = new TaskBuilder({
       interfaceInstance,
@@ -295,7 +292,7 @@ export class TaskExecutor {
       | undefined
     >
   > {
-    this.conversationHistory.reset();
+    const conversationHistory = new ConversationHistory();
 
     const session = this.createExecutionSession(
       taskTitleStr('Act', userPrompt),
@@ -324,12 +321,10 @@ export class TaskExecutor {
       }
 
       // Get sub-goal status text if available
-      const subGoalStatus =
-        this.conversationHistory.subGoalsToText() || undefined;
+      const subGoalStatus = conversationHistory.subGoalsToText() || undefined;
 
       // Get memories text if available
-      const memoriesStatus =
-        this.conversationHistory.memoriesToText() || undefined;
+      const memoriesStatus = conversationHistory.memoriesToText() || undefined;
 
       const result = await session.appendAndRun(
         {
@@ -376,7 +371,7 @@ export class TaskExecutor {
                 interfaceType: this.interface.interfaceType as InterfaceType,
                 actionSpace,
                 modelConfig: modelConfigForPlanning,
-                conversationHistory: this.conversationHistory,
+                conversationHistory,
                 includeBbox: includeBboxInPlanning,
                 imagesIncludeCount,
                 deepThink,
@@ -479,24 +474,24 @@ export class TaskExecutor {
           )}`,
         );
       }
-      if (this.conversationHistory.pendingFeedbackMessage) {
+      if (conversationHistory.pendingFeedbackMessage) {
         console.warn(
           'unconsumed pending feedback message detected, this may lead to unexpected planning result:',
-          this.conversationHistory.pendingFeedbackMessage,
+          conversationHistory.pendingFeedbackMessage,
         );
       }
 
       // Set initial time context for the first planning call
       const initialTimeString = await this.getTimeString();
-      this.conversationHistory.pendingFeedbackMessage += `Current time: ${initialTimeString}`;
+      conversationHistory.pendingFeedbackMessage += `Current time: ${initialTimeString}`;
 
       try {
         await session.appendAndRun(executables.tasks);
       } catch (error: any) {
         // errorFlag = true;
         errorCountInOnePlanningLoop++;
         const timeString = await this.getTimeString();
-        this.conversationHistory.pendingFeedbackMessage = `Time: ${timeString}, Error executing running tasks: ${error?.message || String(error)}`;
+        conversationHistory.pendingFeedbackMessage = `Time: ${timeString}, Error executing running tasks: ${error?.message || String(error)}`;
         debug(
           'error when executing running tasks, but continue to run if it is not too many errors:',
           error instanceof Error ? error.message : String(error),
@@ -529,9 +524,9 @@ export class TaskExecutor {
         return session.appendErrorPlan(errorMsg);
       }
 
-      if (!this.conversationHistory.pendingFeedbackMessage) {
+      if (!conversationHistory.pendingFeedbackMessage) {
         const timeString = await this.getTimeString();
-        this.conversationHistory.pendingFeedbackMessage = `Time: ${timeString}, I have finished the action previously planned.`;
+        conversationHistory.pendingFeedbackMessage = `Time: ${timeString}, I have finished the action previously planned.`;
       }
     }
 

packages/core/src/task-runner.ts

@@ -47,6 +47,8 @@ export class TaskRunner {
     | ((runner: TaskRunner, error?: TaskExecutionError) => Promise<void> | void)
     | undefined;
 
+  private readonly executionLogTime: number;
+
   constructor(
     name: string,
     uiContextBuilder: () => Promise<UIContext>,
@@ -61,6 +63,7 @@ export class TaskRunner {
     this.onTaskStart = options?.onTaskStart;
     this.uiContextBuilder = uiContextBuilder;
     this.onTaskUpdate = options?.onTaskUpdate;
+    this.executionLogTime = Date.now();
   }
 
   private async emitOnTaskUpdate(error?: TaskExecutionError): Promise<void> {
@@ -380,7 +383,7 @@ export class TaskRunner {
 
   dump(): ExecutionDump {
     return new ExecutionDump({
-      logTime: Date.now(),
+      logTime: this.executionLogTime,
       name: this.name,
       tasks: this.tasks,
     });

packages/core/tests/unit-test/task-executor-concurrency.test.ts

@@ -0,0 +1,111 @@
+import { TaskExecutor } from '@/agent/tasks';
+import type { AbstractInterface } from '@/device';
+import { ScreenshotItem } from '@/screenshot-item';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type Service from '../../src';
+
+vi.mock('@/ai-model/llm-planning', () => ({
+  plan: vi.fn(),
+}));
+
+import { plan } from '@/ai-model/llm-planning';
+
+const validBase64Image =
+  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
+
+const createDeferred = () => {
+  let resolve!: () => void;
+  const promise = new Promise<void>((res) => {
+    resolve = res;
+  });
+
+  return { promise, resolve };
+};
+
+describe('TaskExecutor concurrency isolation', () => {
+  let taskExecutor: TaskExecutor;
+  let mockInterface: AbstractInterface;
+  let mockService: Service;
+
+  beforeEach(() => {
+    mockInterface = {
+      interfaceType: 'web',
+      actionSpace: vi.fn().mockReturnValue([]),
+    } as unknown as AbstractInterface;
+
+    mockService = {
+      contextRetrieverFn: vi.fn().mockResolvedValue({
+        screenshot: ScreenshotItem.create(validBase64Image, Date.now()),
+        shotSize: { width: 1920, height: 1080 },
+        shrunkShotToLogicalRatio: 1,
+        tree: {
+          id: 'root',
+          attributes: {},
+          children: [],
+        },
+      }),
+    } as unknown as Service;
+
+    taskExecutor = new TaskExecutor(mockInterface, mockService, {
+      replanningCycleLimit: 1,
+      actionSpace: [],
+    });
+
+    vi.spyOn(taskExecutor, 'convertPlanToExecutable').mockResolvedValue({
+      tasks: [],
+      yamlFlow: [],
+    } as any);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should isolate conversation history between concurrent action calls', async () => {
+    const waitForBothCalls = createDeferred();
+    const releasePlans = createDeferred();
+
+    const seenHistories: any[] = [];
+
+    vi.mocked(plan).mockImplementation(async (_instruction, opts: any) => {
+      seenHistories.push(opts.conversationHistory);
+      if (seenHistories.length === 2) {
+        waitForBothCalls.resolve();
+      }
+
+      if (seenHistories.length < 2) {
+        await releasePlans.promise;
+      }
+
+      return {
+        actions: [],
+        yamlFlow: [],
+        shouldContinuePlanning: false,
+        log: '',
+        rawResponse: '',
+        finalizeSuccess: true,
+        finalizeMessage: 'done',
+      };
+    });
+
+    const actionPromiseA = taskExecutor.action(
+      'first prompt',
+      { modelName: 'planning-model' } as any,
+      { modelName: 'default-model' } as any,
+      true,
+    );
+    const actionPromiseB = taskExecutor.action(
+      'second prompt',
+      { modelName: 'planning-model' } as any,
+      { modelName: 'default-model' } as any,
+      true,
+    );
+
+    await waitForBothCalls.promise;
+    expect(seenHistories).toHaveLength(2);
+    expect(seenHistories[0]).not.toBe(seenHistories[1]);
+
+    releasePlans.resolve();
+    await Promise.all([actionPromiseA, actionPromiseB]);
+  });
+});

packages/core/tests/unit-test/task-runner-log-time.test.ts

@@ -0,0 +1,28 @@
+import { ScreenshotItem } from '@/screenshot-item';
+import { TaskRunner } from '@/task-runner';
+import type { UIContext } from '@/types';
+import { describe, expect, it } from 'vitest';
+
+const fakeUIContextBuilder = async () => {
+  const screenshot = ScreenshotItem.create('', Date.now());
+  return {
+    screenshot,
+    tree: { node: null, children: [] },
+    shotSize: { width: 0, height: 0 },
+    shrunkShotToLogicalRatio: 1,
+  } as unknown as UIContext;
+};
+
+describe('TaskRunner dump logTime stability', () => {
+  it('should keep the same logTime across repeated dumps of the same runner', async () => {
+    const runner = new TaskRunner('stable-log-time', fakeUIContextBuilder);
+
+    const firstDump = runner.dump();
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    const secondDump = runner.dump();
+
+    expect(secondDump.logTime).toBe(firstDump.logTime);
+  });
+});