fix(workhub): follow delegated message ownership

Generated-by: Codex

Author: ARE404

apps/desktop/src/main/__tests__/runtime-host-session-execution-ipc-main.test.ts

@@ -630,6 +630,37 @@ test('returns Host-owned cancellation proof to the renderer', async () => {
   );
 });
 
+test('returns Host-owned Message execution proof to the renderer', async () => {
+  const ipc = ipcHarness();
+  registerExecutionIpc(
+    {
+      client: executionClient({
+        queryMessageExecutions: async (input) => ({
+          resolutions: input.messageIds.map((messageId) => ({
+            messageId,
+            state: 'owned' as const,
+            turnId: 'successor-turn',
+            runId: 'successor-run',
+          })),
+        }),
+      }),
+    },
+    ipc,
+  );
+
+  assert.deepEqual(
+    await ipc.invoke('sessions:queryMessageExecutions', 'session-1', ['message-delegated']),
+    {
+      resolutions: [{
+        messageId: 'message-delegated',
+        state: 'owned',
+        turnId: 'successor-turn',
+        runId: 'successor-run',
+      }],
+    },
+  );
+});
+
 test('submits a slash Skill message and reports the Host Skill outcome', async () => {
   const submits: unknown[] = [];
   const ipc = ipcHarness();
@@ -1502,6 +1533,7 @@ function executionClient(overrides: Partial<ExecutionClient>): ExecutionClient {
     interruptTurn: unavailable,
     listSessionTurnLandmarks: unavailable,
     listSessionTurns: unavailable,
+    queryMessageExecutions: unavailable,
     queryMessages: unavailable,
     queryTurnResume: unavailable,
     readExecutionBoundary: unavailable,

apps/desktop/src/main/__tests__/workhub-controller.test.ts

@@ -103,6 +103,7 @@ function coordinationAssignmentTurn(): WorkHubCoordinationTurn {
       delegationId: 'delegation-1',
       targetSessionId: 'payment',
       targetSessionName: 'Payments',
+      targetMessageId: 'payment-message',
       targetTurnId: 'payment-turn',
       feedbackState: 'accepted',
     },

apps/desktop/src/main/__tests__/workhub-coordination-host-scope.test.ts

@@ -44,6 +44,7 @@ test('WorkHub candidates follow the resolved Coordination Session Host only', as
       completeHostIds: ['host-a', 'host-b'],
     }),
     listTurns: async () => [],
+    queryMessageExecutions: async () => ({ resolutions: [] }),
     create: async () => {
       throw new Error('unscoped create must not be used');
     },

apps/desktop/src/main/__tests__/workhub-session-port.test.ts

@@ -56,6 +56,13 @@ const unusedTranscripts = {
   },
 };
 
+const noMessageExecutions = async () => ({
+  resolutions: [] as Array<
+    | { messageId: string; state: 'pending' }
+    | { messageId: string; state: 'owned'; turnId: string; runId: string }
+  >,
+});
+
 function transcriptsWith(messages: readonly StoredMessage[]) {
   return {
     open: async (sessionId: string, handler: (batch: DesktopTranscriptBatch) => void) => {
@@ -151,6 +158,7 @@ test('projects the durable Coordination transcript into the WorkHub conversation
       delegationId: 'payments-delegation',
       targetSessionId: 'payments',
       targetSessionName: 'Payments',
+      targetMessageId: 'payments-message',
       targetTurnId: 'payments-turn',
       feedbackState: 'accepted',
     },
@@ -294,6 +302,7 @@ test('desktop adapter rebuilds recent turns from the Session transcript and clos
     sessions: {
       list: async () => [],
       listTurns: async () => [],
+      queryMessageExecutions: noMessageExecutions,
       create: async () => {
         throw new Error('not used');
       },
@@ -369,6 +378,7 @@ test('desktop adapter cancels an unavailable transcript without hiding ready Ses
     sessions: {
       list: async () => [],
       listTurns: async () => [],
+      queryMessageExecutions: noMessageExecutions,
       create: async () => { throw new Error('not used'); },
       send: async () => { throw new Error('not used'); },
       stop: async () => {},
@@ -451,6 +461,7 @@ test('desktop adapter projects Session catalog facts without owning copies', asy
     sessions: {
       list: async () => source,
       listTurns: async () => [],
+      queryMessageExecutions: noMessageExecutions,
       create: async () => {
         throw new Error('not used');
       },
@@ -509,7 +520,7 @@ test('desktop adapter projects Session catalog facts without owning copies', asy
   ]);
 });
 
-test('desktop adapter rebuilds delegation feedback from the exact authoritative Turn', async () => {
+test('desktop adapter rebuilds delegation feedback from the Message-owned execution Turn', async () => {
   const sessions = [
     desktopSession('accepted'),
     desktopSession('running', { status: 'running', runningTurnIds: ['turn-running'] }),
@@ -544,6 +555,18 @@ test('desktop adapter rebuilds delegation feedback from the exact authoritative
         if (sessionId === 'recovering') throw new Error('Host is recovering');
         return turns.get(sessionId) ?? [];
       },
+      queryMessageExecutions: async (sessionId, messageIds) => ({
+        resolutions: sessionId === 'accepted'
+          ? messageIds.map((messageId) => ({ messageId, state: 'pending' as const }))
+          : sessionId === 'recovering'
+            ? []
+            : messageIds.map((messageId) => ({
+              messageId,
+              state: 'owned' as const,
+              turnId: `turn-${sessionId}`,
+              runId: `run-${sessionId}`,
+            })),
+      }),
       create: async () => { throw new Error('not used'); },
       send: async () => { throw new Error('not used'); },
       stop: async () => {},
@@ -563,6 +586,7 @@ test('desktop adapter rebuilds delegation feedback from the exact authoritative
   ].map(([targetSessionId, targetTurnId]) => ({
     delegationId: `delegation-${targetSessionId}`,
     targetSessionId: targetSessionId!,
+    targetMessageId: `message-${targetSessionId}`,
     targetTurnId: targetTurnId!,
   }));
 
@@ -579,6 +603,63 @@ test('desktop adapter rebuilds delegation feedback from the exact authoritative
   ]);
 });
 
+test('desktop adapter follows a delegated Message into its successor Turn', async () => {
+  const targetSessionId = desktopSessionKey({ hostId: 'local-host', sessionId: 'payments' });
+  const adapter = createDesktopWorkHubSessionPort({
+    transcripts: transcriptsWith([{
+      type: 'user',
+      id: 'payment-message',
+      turnId: 'successor-turn',
+      ts: 2,
+      text: 'Continue payment recovery',
+      steeringEventId: 'payment-message',
+    }]),
+    sessions: {
+      list: async () => [desktopSession(targetSessionId, {
+        status: 'running',
+        runningTurnIds: ['successor-turn'],
+      })],
+      listTurns: async () => [
+        {
+          turnId: 'admission-turn',
+          status: 'completed',
+          statusSource: 'recorded',
+        },
+        {
+          turnId: 'successor-turn',
+          status: 'running',
+          statusSource: 'recorded',
+        },
+      ],
+      queryMessageExecutions: async (_sessionId, messageIds) => ({
+        resolutions: messageIds.map((messageId) => ({
+          messageId,
+          state: 'owned' as const,
+          turnId: 'successor-turn',
+          runId: 'successor-run',
+        })),
+      }),
+      create: async () => { throw new Error('not used'); },
+      send: async () => { throw new Error('not used'); },
+      stop: async () => {},
+      subscribeChanges: () => () => {},
+    },
+    projectName: () => 'Maka',
+    newTurnId: () => 'unused',
+  });
+
+  const references = [{
+    delegationId: 'payment-delegation',
+    targetSessionId,
+    targetTurnId: 'admission-turn',
+    targetMessageId: 'payment-message',
+  }];
+  assert.deepEqual(await adapter.delegationFeedback(references), [{
+    delegationId: 'payment-delegation',
+    state: 'running',
+  }]);
+});
+
 test('desktop adapter preserves per-Host catalog coverage for ownership reconciliation', async () => {
   const localSessionId = desktopSessionKey({ hostId: 'local-host', sessionId: 'local' });
   const adapter = createDesktopWorkHubSessionPort({
@@ -590,6 +671,7 @@ test('desktop adapter preserves per-Host catalog coverage for ownership reconcil
         completeHostIds: ['local-host'],
       }),
       listTurns: async () => [],
+      queryMessageExecutions: noMessageExecutions,
       create: async () => { throw new Error('not used'); },
       send: async () => { throw new Error('not used'); },
       stop: async () => {},
@@ -619,6 +701,7 @@ test('desktop adapter delegates create, send, and invalidation to Session APIs',
         runningTurnIds: ['turn-new'],
       })],
       listTurns: async () => [],
+      queryMessageExecutions: noMessageExecutions,
       create: async (input) => {
         calls.push(['create', input]);
         return desktopSession('created', { name: input.name });
@@ -667,6 +750,7 @@ test('desktop adapter preserves when Session delivery steered an existing root T
     sessions: {
       list: async () => [],
       listTurns: async () => [],
+      queryMessageExecutions: noMessageExecutions,
       create: async () => {
         throw new Error('not used');
       },
@@ -699,6 +783,7 @@ test('desktop adapter distinguishes definite rejection from an unknown delivery
     sessions: {
       list: async () => [],
       listTurns: async () => [],
+      queryMessageExecutions: noMessageExecutions,
       create: async () => { throw new Error('not used'); },
       send: async () => {
         if (outcome === 'throw') throw new Error('transport disconnected');
@@ -792,6 +877,7 @@ test('desktop adapter reconciles lost replies from authoritative transcript iden
       sessions: {
         list: async () => [],
         listTurns: async () => [],
+        queryMessageExecutions: noMessageExecutions,
         create: async () => { throw new Error('not used'); },
         send: async () => { throw new Error('not used'); },
         stop: async () => {},
@@ -818,6 +904,7 @@ test('desktop adapter binds stop to the root Turn owned by the WorkHub submissio
     sessions: {
       list: async () => [],
       listTurns: async () => [],
+      queryMessageExecutions: noMessageExecutions,
       create: async () => {
         throw new Error('not used');
       },
@@ -855,6 +942,7 @@ test('desktop adapter derives stable origin evidence from the existing Session l
           { userPromptPreview: '把风险按高、中、低分组' },
         ];
       },
+      queryMessageExecutions: noMessageExecutions,
       create: async () => {
         throw new Error('not used');
       },

apps/desktop/src/main/__tests__/workhub-surface-flow.test.ts

@@ -130,6 +130,7 @@ test('durable delegation renders every projected target state as a navigable res
         delegationId: 'delegation-1',
         targetSessionId: 'payment',
         targetSessionName: 'Payments',
+        targetMessageId: 'payment-message',
         targetTurnId: 'payment-turn',
         feedbackState: state,
       },
@@ -334,6 +335,7 @@ test('real Session projection creates new guide topics and preserves origin ambi
       list: async () => sessions,
       listTurns: async (sessionId) =>
         (prompts.get(sessionId) ?? []).map((userPromptPreview) => ({ userPromptPreview })),
+      queryMessageExecutions: async () => ({ resolutions: [] }),
       create: async ({ name }) => {
         const id = name.includes('支付回调') ? 'payment' : 'layout';
         const session: WorkHubDesktopSession = {

apps/desktop/src/main/runtime-host-client.ts

@@ -1084,6 +1084,12 @@ export class DesktopRuntimeHostClient {
     return this.request('turn.message.query', input);
   }
 
+  queryMessageExecutions(
+    input: OperationInput<'turn.message.execution.query'>,
+  ): Promise<OperationOutput<'turn.message.execution.query'>> {
+    return this.request('turn.message.execution.query', input);
+  }
+
   retractQueueEntry(
     input: Omit<QueueEntryRetractInput, "originHostEpoch">,
   ): Promise<QueueMutationResult> {

apps/desktop/src/main/runtime-host-session-execution-ipc-main.ts

@@ -95,6 +95,7 @@ type RuntimeHostSessionExecutionClient = Pick<
   | "interruptTurn"
   | 'listSessionTurns'
   | 'listSessionTurnLandmarks'
+  | 'queryMessageExecutions'
   | 'queryMessages'
   | "queryTurnResume"
   | "readExecutionBoundary"
@@ -211,6 +212,14 @@ export function registerRuntimeHostSessionExecutionIpc(
     },
   );
 
+  ipcMain.handle(
+    'sessions:queryMessageExecutions',
+    async (_event, sessionId: string, messageIds: unknown) => {
+      if (!Array.isArray(messageIds)) throw new Error('Invalid Message identities');
+      return deps.client.queryMessageExecutions({ sessionId, messageIds });
+    },
+  );
+
   handleReconnectableRead(
     ipcMain,
     "sessions:observe",

apps/desktop/src/preload/bridge-contract.d.ts

@@ -1009,6 +1009,10 @@ export interface MakaBridge {
       sessionId: string,
       messageIds: readonly string[],
     ): Promise<import('@maka/runtime-host/protocol').TurnMessageQueryResult>;
+    queryMessageExecutions(
+      sessionId: string,
+      messageIds: readonly string[],
+    ): Promise<import('@maka/runtime-host/protocol').TurnMessageExecutionQueryResult>;
     retractQueueEntry(sessionId: string, entryId: string): Promise<void>;
     promoteQueueEntry(sessionId: string, entryId: string): Promise<void>;
     updateQueueEntry(

apps/desktop/src/preload/preload.ts

@@ -1781,6 +1781,9 @@ const makaBridge = {
     queryCancelledMessages(sessionId, messageIds) {
       return invokeSessionRuntimeHost('sessions:queryCancelledMessages', sessionId, messageIds);
     },
+    queryMessageExecutions(sessionId, messageIds) {
+      return invokeSessionRuntimeHost('sessions:queryMessageExecutions', sessionId, messageIds);
+    },
     retractQueueEntry(sessionId: string, entryId: string): Promise<void> {
       return invokeSessionRuntimeHost('sessions:retractQueueEntry', sessionId, entryId);
     },

apps/desktop/src/renderer/workhub-controller.ts

@@ -74,6 +74,8 @@ export type WorkHubDelegationExecutionState =
 export interface WorkHubDelegationReference {
   readonly delegationId: string;
   readonly targetSessionId: string;
+  /** Stable delegated work identity; targetTurnId is only its admission location. */
+  readonly targetMessageId: string;
   readonly targetTurnId: string;
 }
 
@@ -102,6 +104,7 @@ export interface WorkHubCoordinationTurn {
     readonly delegationId: string;
     readonly targetSessionId: string;
     readonly targetSessionName: string;
+    readonly targetMessageId: string;
     readonly targetTurnId: string;
     readonly feedbackState: WorkHubDelegationExecutionState;
   };
@@ -648,6 +651,7 @@ function createWorkHubControllerImplementation(deps: {
             ? [{
                 delegationId: turn.assignment.delegationId,
                 targetSessionId: turn.assignment.targetSessionId,
+                targetMessageId: turn.assignment.targetMessageId,
                 targetTurnId: turn.assignment.targetTurnId,
               }]
             : [],