fix(chat): keep a steered message restored past the age limit truthful

Restoring a steered entry past the age limit marked it not delivered without reading, so a message its turn had applied showed as undelivered and invited a resend. It now stays steered so its turn's marker or a disposition read settles it; only the auto-send is blocked, and Retry lifts that.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/hooks/outgoing-state.test.ts

@@ -346,12 +346,67 @@ describe('a journal restored past the age limit', () => {
       NOW
     ).status
 
-  it('shows a message on its way as not delivered', () => {
+  it('shows a message that never reached a turn as not delivered', () => {
     expect(restore('pending', ORPHAN_AUTO_SEND_MAX_AGE_MS)).toBe('failed')
-    expect(restore('steered', ORPHAN_AUTO_SEND_MAX_AGE_MS)).toBe('failed')
     expect(restore('sending', ORPHAN_AUTO_SEND_MAX_AGE_MS)).toBe('failed')
   })
 
+  it('keeps one steered as steered, since its turn may have applied it', () => {
+    expect(restore('steered', ORPHAN_AUTO_SEND_MAX_AGE_MS)).toBe('steered')
+    const aged = fromJournaled(
+      'chat',
+      toJournaled(
+        entry('a', {
+          status: 'steered',
+          streamId: 'turn',
+          writtenAt: NOW - ORPHAN_AUTO_SEND_MAX_AGE_MS,
+        })
+      ),
+      NOW
+    )
+    const context = { streamId: 'turn', turnErrored: false, now: NOW }
+    expect(afterDispositionRead(aged, { status: 'applied', textOffset: 3 }, context).status).toBe(
+      'applied'
+    )
+    expect(afterDispositionRead(aged, { status: 'not_applied' }, context).status).toBe('failed')
+  })
+
+  it('lets the user send it once they ask, after no turn took it', () => {
+    const aged = fromJournaled(
+      'chat',
+      toJournaled(
+        entry('a', {
+          status: 'steered',
+          streamId: 'turn',
+          writtenAt: NOW - ORPHAN_AUTO_SEND_MAX_AGE_MS,
+        })
+      ),
+      NOW
+    )
+    const retried = { ...aged, ...afterRetry(aged) }
+    const read = afterDispositionRead(
+      retried,
+      { status: 'not_applied' },
+      { streamId: 'turn', turnErrored: false, now: NOW }
+    )
+    expect(read.status).toBe('pending')
+  })
+
+  it('sends a recent steered message no turn took on its own', () => {
+    const recent = fromJournaled(
+      'chat',
+      toJournaled(entry('a', { status: 'steered', streamId: 'turn', writtenAt: NOW - 1 })),
+      NOW
+    )
+    expect(
+      afterDispositionRead(
+        recent,
+        { status: 'not_applied' },
+        { streamId: 'turn', turnErrored: false, now: NOW }
+      ).status
+    ).toBe('pending')
+  })
+
   it('resumes a recent one where it stood, and leaves one already applied alone', () => {
     expect(restore('pending', ORPHAN_AUTO_SEND_MAX_AGE_MS - 1)).toBe('pending')
     expect(restore('steered', ORPHAN_AUTO_SEND_MAX_AGE_MS - 1)).toBe('steered')

apps/sim/app/workspace/[workspaceId]/home/hooks/outgoing-state.ts

@@ -78,6 +78,8 @@ export interface OutgoingMessage {
   writtenAt: number
   /** Epoch ms before which it is not tried again. */
   notBefore?: number
+  /** Restored past the age limit: if no turn took it, it waits for the user rather than going out. */
+  noAutoSend?: boolean
 }
 
 /** What became of a steer, as the client reads it; `unknown`: no answer, so it may be held. */
@@ -152,21 +154,21 @@ export function toJournaled(message: OutgoingMessage): JournaledOutgoing {
 }
 
 /**
- * The entry a journal restores. One on its way that has sat past the age limit (a
- * browser session restored days later) shows as not delivered, with no network call
- * and nothing going out until the user asks.
+ * The entry a journal restores. Past the age limit (a browser session restored days
+ * later) nothing goes out until the user asks: one that never reached a turn shows as
+ * not delivered, with no network call. One steered stays steered, because its turn may
+ * well have applied it, and only a read saying no turn took it shows it as not delivered.
  */
 export function fromJournaled(
   chatKey: string,
   entry: JournaledOutgoing,
   now: number
 ): OutgoingMessage {
-  const stillOnItsWay = entry.status === 'pending' || entry.status === 'steered'
+  const pastAgeLimit = now - entry.writtenAt >= ORPHAN_AUTO_SEND_MAX_AGE_MS
   return {
     ...entry,
-    ...(stillOnItsWay && now - entry.writtenAt >= ORPHAN_AUTO_SEND_MAX_AGE_MS
-      ? { status: 'failed' as const }
-      : {}),
+    ...(pastAgeLimit && entry.status === 'pending' ? { status: 'failed' as const } : {}),
+    ...(pastAgeLimit && entry.status === 'steered' ? { noAutoSend: true } : {}),
     chatKey,
     display: optimisticUserMessageFor(entry.id, entry.payload),
     attempts: 0,
@@ -307,7 +309,7 @@ export function afterDispositionRead(
   }
   if (outcome.status === 'not_applied') {
     return {
-      ...notSteered(context.streamId, context.turnErrored),
+      ...notSteered(context.streamId, context.turnErrored || message.noAutoSend === true),
       ...(message.attempts > 0
         ? { notBefore: context.now + outgoingRetryDelay(message.attempts) }
         : {}),
@@ -336,6 +338,7 @@ export function afterRetry(message: OutgoingMessage): Partial<OutgoingMessage> {
     attempts: 0,
     reads: 0,
     notBefore: undefined,
+    noAutoSend: undefined,
   }
 }
 

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.dom.test.tsx

@@ -3556,28 +3556,44 @@ describe('useChat remount send recovery', () => {
       }
     )
 
-    it.each([
-      ['steered', { status: 'steered', streamId: 'earlier-turn' }],
-      ['pending', { status: 'pending' }],
-    ] as const)(
-      'shows a %s entry a session restore brought back days later as not delivered',
-      async (_name, standing) => {
-        const id = '6f1e2d3c-4b5a-4978-8695-a4b3c2d1e0f7'
-        state.steerDispositions = ['not_applied']
-        const view = await restoredChat([
-          {
-            id,
-            payload: { content: 'from days ago' },
-            writtenAt: Date.now() - 3 * 24 * 60 * 60_000,
-            ...standing,
-          },
-        ])
+    const restoredDaysLater = (standing: { status: 'steered' | 'pending'; streamId?: string }) =>
+      restoredChat([
+        {
+          id: '6f1e2d3c-4b5a-4978-8695-a4b3c2d1e0f7',
+          payload: { content: 'from days ago' },
+          writtenAt: Date.now() - 3 * 24 * 60 * 60_000,
+          ...standing,
+        },
+      ])
 
-        expect(deliveryOf(view, id)).toBe('failed')
-        expect(state.steerBodies).toEqual([])
-        expect(state.postBodies).toEqual([])
-      }
-    )
+    it('shows a pending entry a session restore brought back days later as not delivered, with no call', async () => {
+      const view = await restoredDaysLater({ status: 'pending' })
+
+      expect(deliveryOf(view, '6f1e2d3c-4b5a-4978-8695-a4b3c2d1e0f7')).toBe('failed')
+      expect(state.steerBodies).toEqual([])
+      expect(state.postBodies).toEqual([])
+    })
+
+    it('never sends a steered entry a session restore brought back days later when no turn took it', async () => {
+      state.steerDispositions = ['not_applied']
+      const view = await restoredDaysLater({ status: 'steered', streamId: 'earlier-turn' })
+
+      await vi.waitFor(() =>
+        expect(deliveryOf(view, '6f1e2d3c-4b5a-4978-8695-a4b3c2d1e0f7')).toBe('failed')
+      )
+      expect(state.postBodies).toEqual([])
+    })
+
+    it('does not call a steered entry restored days later undelivered when its turn applied it', async () => {
+      state.steerDispositions = ['applied']
+      const view = await restoredDaysLater({ status: 'steered', streamId: 'earlier-turn' })
+
+      await vi.waitFor(() => expect(state.steerBodies.length).toBeGreaterThan(0))
+      await vi.waitFor(() =>
+        expect(deliveryOf(view, '6f1e2d3c-4b5a-4978-8695-a4b3c2d1e0f7')).toBeUndefined()
+      )
+      expect(state.postBodies).toEqual([])
+    })
 
     it('does not let a message not delivered hold back a later plain send', async () => {
       const id = '6f1e2d3c-4b5a-4978-8695-a4b3c2d1e0f9'