fix(side-chat): replay durable steering admission

Generated-by: Codex

Author: Astro-Han

packages/runtime-host/src/__tests__/session-projector.test.ts

@@ -307,6 +307,44 @@ test('reseeds the Host admission fact for a message already in the active Turn',
   );
 });
 
+test('reseeds the Host admission fact after an active Turn message leaves the queue', () => {
+  const current = snapshot();
+  const projector = new RuntimeHostSessionProjector(
+    current,
+    createRuntimeHostSessionProjectionSeed(
+      [
+        {
+          type: 'user',
+          id: 'ticket-1',
+          turnId: 'turn-1',
+          ts: 1,
+          text: 'continue here',
+          steeringEventId: 'steering-event-1',
+        },
+      ],
+      current,
+    ),
+    () => 10,
+    [],
+    true,
+  );
+
+  assert.deepEqual(
+    projector
+      .seedActive(false)
+      .filter(
+        (event): event is Extract<SessionEvent, { type: 'message_admission' }> =>
+          event.type === 'message_admission',
+      )
+      .map((event) => ({
+        outcome: event.outcome,
+        turnId: event.turnId,
+        messageId: event.messageId,
+      })),
+    [{ outcome: 'admitted', turnId: 'turn-1', messageId: 'ticket-1' }],
+  );
+});
+
 test('reseeds the latest provider retry when the active Turn still carries one', () => {
   const retry = {
     phase: 'scheduled' as const,

packages/runtime-host/src/adapter/session-projector.ts

@@ -42,21 +42,24 @@ interface AssistantAccumulator {
 }
 
 export interface RuntimeHostSessionProjectionSeed {
-  readonly durableInFlightMessageIds: readonly string[];
+  readonly durableSteeringMessages: readonly {
+    readonly messageId: string;
+    readonly turnId: string;
+  }[];
   readonly activeAssistantMessages: readonly Extract<StoredMessage, { type: 'assistant' }>[];
 }
 
 export function createRuntimeHostSessionProjectionSeed(
   transcript: readonly StoredMessage[],
   snapshot: SessionContinuitySnapshot,
 ): RuntimeHostSessionProjectionSeed {
-  const inFlightMessageIds = new Set(
-    rootQueueInFlight(snapshot.queue).map((entry) => entry.messageId),
-  );
   return {
-    durableInFlightMessageIds: transcript
-      .filter((message) => inFlightMessageIds.has(message.id))
-      .map((message) => message.id),
+    durableSteeringMessages: transcript
+      .filter(
+        (message): message is Extract<StoredMessage, { type: 'user' }> =>
+          message.type === 'user' && message.steeringEventId !== undefined,
+      )
+      .map((message) => ({ messageId: message.id, turnId: message.turnId })),
     activeAssistantMessages:
       snapshot.rootTurn === null
         ? []
@@ -84,6 +87,7 @@ export class RuntimeHostSessionProjector {
   #snapshot: SessionContinuitySnapshot;
   readonly #now: () => number;
   readonly #transcriptIds: Set<string>;
+  readonly #durableSteeringTurnByMessage: ReadonlyMap<string, string>;
   readonly #accumulators = new Map<string, AssistantAccumulator>();
   #projectMessageAdmissions: boolean;
 
@@ -96,7 +100,10 @@ export class RuntimeHostSessionProjector {
   ) {
     this.#snapshot = structuredClone(snapshot);
     this.#now = now;
-    this.#transcriptIds = new Set(seed.durableInFlightMessageIds);
+    this.#durableSteeringTurnByMessage = new Map(
+      seed.durableSteeringMessages.map(({ messageId, turnId }) => [messageId, turnId]),
+    );
+    this.#transcriptIds = new Set(this.#durableSteeringTurnByMessage.keys());
     this.#projectMessageAdmissions = projectMessageAdmissions;
     const root = snapshot.rootTurn;
     if (!root) return;
@@ -158,6 +165,9 @@ export class RuntimeHostSessionProjector {
             ...new Set([
               ...this.#snapshot.rootTurnSourceMessageIds,
               ...rootQueueInFlight(this.#snapshot.queue).map((entry) => entry.messageId),
+              ...[...this.#durableSteeringTurnByMessage]
+                .filter(([, turnId]) => turnId === root.turnId)
+                .map(([messageId]) => messageId),
             ]),
           ],
           this.#now(),