fix(mship): age a resolved attempt from when it resolved, not when it was requested

Review round 1 findings.

A pending attempt held by the 24h grace is by definition older than the 15m
cutoff, so the moment a late verdict landed on it the record became instantly
sweepable and the next create erased it. Every chip re-reads its row on the
event create dispatches, so a connected chip dropped straight back to unset --
the grace period was defeating its own purpose.

Resolved records now age from resolvedAt, giving the UI the full window to
observe a verdict however late it arrives. Legacy records without the field
fall back to requestedAt.

Also makes the multi-record sweep test a real guard: its records are written
directly so they occupy consecutive storage slots. The earlier version
interleaved latest-pointers between them, which masked the index shift -- a
remove-during-scan regression passed it.

Author: waleedlatif1

apps/sim/lib/credentials/oauth-chat-attempt.test.ts

@@ -167,6 +167,16 @@ describe('OAuth chat attempts', () => {
   const SWEEP_LATEST_KEY = 'sim.oauth-chat-latest.workspace-1.slack.message-1%3A0%3A0.'
   const PENDING_GRACE_MS = 24 * 60 * 60 * 1000
 
+  /** Storage is index-addressed and its keys are not own-enumerable in jsdom. */
+  function storageKeysWithPrefix(prefix: string): string[] {
+    const keys: string[] = []
+    for (let index = 0; index < window.localStorage.length; index++) {
+      const key = window.localStorage.key(index)
+      if (key?.startsWith(prefix)) keys.push(key)
+    }
+    return keys.sort()
+  }
+
   /** Backdates a stored attempt, then starts an unrelated one to trigger the sweep. */
   function ageAttemptThenSweep(
     attempt: OAuthChatAttempt,
@@ -201,6 +211,42 @@ describe('OAuth chat attempts', () => {
     expect(setOAuthChatAttemptStatus(parked.id, 'connected')?.status).toBe('connected')
   })
 
+  it('keeps a late verdict alive after it lands on a grace-preserved attempt', () => {
+    const parked = createOAuthChatAttempt(SWEEP_INPUT)
+    ageAttemptThenSweep(parked, OAUTH_CHAT_ATTEMPT_MAX_AGE_MS + 1, 'pending')
+
+    // The verdict arrives long after the request, so the record is only young
+    // by resolution. Aging it from requestedAt would make it sweepable at once.
+    expect(setOAuthChatAttemptStatus(parked.id, 'connected')?.status).toBe('connected')
+    createOAuthChatAttempt({ ...SWEEP_INPUT, controlId: 'message-1:8:8' })
+
+    expect(readOAuthChatAttempt(parked.id)?.status).toBe('connected')
+  })
+
+  it('sweeps many adjacent stale records in one pass', () => {
+    const template = createOAuthChatAttempt(SWEEP_INPUT)
+    const staleIds = [0, 1, 2, 3, 4, 5].map((slot) => `stale-attempt-${slot}`)
+    // Written directly, so the records land in consecutive storage slots with
+    // no latest-pointer between them — interleaved keys would mask the skip.
+    for (const staleId of staleIds) {
+      window.localStorage.setItem(
+        `sim.oauth-chat-attempt.${staleId}`,
+        JSON.stringify({
+          ...template,
+          id: staleId,
+          status: 'connected',
+          resolvedAt: template.requestedAt - OAUTH_CHAT_ATTEMPT_MAX_AGE_MS - 1,
+        })
+      )
+    }
+
+    createOAuthChatAttempt({ ...SWEEP_INPUT, controlId: 'message-1:9:9' })
+
+    // Removing entries mid-scan would shift every later key down a slot and
+    // skip the next one, leaving about half of these behind.
+    expect(storageKeysWithPrefix('sim.oauth-chat-attempt.stale-attempt-')).toEqual([])
+  })
+
   it('sweeps a pending attempt once it is past the abandoned grace period', () => {
     const abandoned = createOAuthChatAttempt(SWEEP_INPUT)
 

apps/sim/lib/credentials/oauth-chat-attempt.ts

@@ -43,6 +43,8 @@ export interface OAuthChatAttempt {
   baselineCredentialUpdatedAt?: string
   requestedAt: number
   status: OAuthChatAttemptStatus
+  /** When {@link status} last left 'pending'. Absent on records written before this was tracked. */
+  resolvedAt?: number
 }
 
 interface CreateOAuthChatAttemptInput {
@@ -136,6 +138,7 @@ function isOAuthChatAttempt(value: unknown): value is OAuthChatAttempt {
       candidate.status === 'connected' ||
       candidate.status === 'failed') &&
     (candidate.credentialId === undefined || typeof candidate.credentialId === 'string') &&
+    (candidate.resolvedAt === undefined || typeof candidate.resolvedAt === 'number') &&
     Array.isArray(candidate.baselineCredentialIds) &&
     candidate.baselineCredentialIds.every((credentialId) => typeof credentialId === 'string') &&
     (candidate.baselineCredentialUpdatedAt === undefined ||
@@ -191,7 +194,15 @@ function pruneExpiredOAuthChatAttempts(now: number): void {
     // An unparseable or malformed record can never be read back, so it is
     // collected too rather than left behind forever.
     if (attempt) {
-      const age = now - attempt.requestedAt
+      // A resolved record ages from when it was resolved, not from when it was
+      // requested. Aging it from `requestedAt` would make the verdict on a
+      // grace-preserved pending record sweepable the instant it landed, and the
+      // next create would erase it — every chip re-reads its row on the event
+      // that create dispatches, so the row would drop straight back to unset.
+      const age =
+        attempt.status === 'pending'
+          ? now - attempt.requestedAt
+          : now - (attempt.resolvedAt ?? attempt.requestedAt)
       const maxAge =
         attempt.status === 'pending'
           ? OAUTH_CHAT_ATTEMPT_PENDING_GRACE_MS
@@ -267,7 +278,11 @@ export function setOAuthChatAttemptStatus(
 ): OAuthChatAttempt | null {
   const attempt = readOAuthChatAttempt(attemptId)
   if (!attempt) return null
-  const updated = { ...attempt, status }
+  const updated: OAuthChatAttempt = {
+    ...attempt,
+    status,
+    resolvedAt: status === 'pending' ? undefined : Date.now(),
+  }
   writeOAuthChatAttempt(updated)
   return updated
 }