fix(mship): retain attempt records for a day regardless of status

The 15m resolved cutoff was still short enough to pull a record out from
under a mounted row. A chip recomputes itself from storage on every attempt
event, and on the reconnect path connectedFromWorkspaceChange is forced false,
so connected collapses to exactly the stored status. Any connect click 15m
after a reconnect swept that record -- via the CustomEvent in the same tab or
the storage event these removals now fire in others -- and reverted the row
from Connected. Non-reconnect rows kept the label but silently lost their lock.

OAUTH_CHAT_ATTEMPT_MAX_AGE_MS governs what a lookup honours, not how long a
record has readers. Retention is now one flat window measured from last
activity, which also drops the status branch.

Author: waleedlatif1

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

@@ -165,7 +165,7 @@ describe('OAuth chat attempts', () => {
     baselineCredentialIds: [],
   }
   const SWEEP_LATEST_KEY = 'sim.oauth-chat-latest.workspace-1.slack.message-1%3A0%3A0.'
-  const PENDING_GRACE_MS = 24 * 60 * 60 * 1000
+  const RETENTION_MS = 24 * 60 * 60 * 1000
 
   /** Storage is index-addressed and its keys are not own-enumerable in jsdom. */
   function storageKeysWithPrefix(prefix: string): string[] {
@@ -190,16 +190,27 @@ describe('OAuth chat attempts', () => {
     createOAuthChatAttempt({ ...SWEEP_INPUT, controlId: 'message-1:9:9' })
   }
 
-  it('sweeps resolved expired attempts and their latest-pointers when a new one starts', () => {
+  it('sweeps resolved attempts and their latest-pointers past the retention window', () => {
     const stale = createOAuthChatAttempt(SWEEP_INPUT)
     expect(window.localStorage.getItem(SWEEP_LATEST_KEY)).toBe(stale.id)
 
-    ageAttemptThenSweep(stale, OAUTH_CHAT_ATTEMPT_MAX_AGE_MS + 1, 'connected')
+    ageAttemptThenSweep(stale, RETENTION_MS + 1, 'connected')
 
     expect(window.localStorage.getItem(`sim.oauth-chat-attempt.${stale.id}`)).toBeNull()
     expect(window.localStorage.getItem(SWEEP_LATEST_KEY)).toBeNull()
   })
 
+  it('keeps a resolved attempt a mounted row still reads past the lookup cutoff', () => {
+    const settled = createOAuthChatAttempt(SWEEP_INPUT)
+
+    ageAttemptThenSweep(settled, OAUTH_CHAT_ATTEMPT_MAX_AGE_MS + 1, 'connected')
+
+    // A chip recomputes itself from storage on every attempt event, and on the
+    // reconnect path the record is its only source of connected state — so
+    // sweeping at the lookup cutoff would revert a row that is still on screen.
+    expect(readOAuthChatAttempt(settled.id)?.status).toBe('connected')
+  })
+
   it('keeps a pending attempt past the read cutoff so a late verdict still lands', () => {
     const parked = createOAuthChatAttempt(SWEEP_INPUT)
 
@@ -211,7 +222,7 @@ 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', () => {
+  it('keeps a late verdict alive after it lands on a long-parked attempt', () => {
     const parked = createOAuthChatAttempt(SWEEP_INPUT)
     ageAttemptThenSweep(parked, OAUTH_CHAT_ATTEMPT_MAX_AGE_MS + 1, 'pending')
 
@@ -235,7 +246,7 @@ describe('OAuth chat attempts', () => {
           ...template,
           id: staleId,
           status: 'connected',
-          resolvedAt: template.requestedAt - OAUTH_CHAT_ATTEMPT_MAX_AGE_MS - 1,
+          resolvedAt: template.requestedAt - RETENTION_MS - 1,
         })
       )
     }
@@ -247,10 +258,10 @@ describe('OAuth chat attempts', () => {
     expect(storageKeysWithPrefix('sim.oauth-chat-attempt.stale-attempt-')).toEqual([])
   })
 
-  it('sweeps a pending attempt once it is past the abandoned grace period', () => {
+  it('sweeps a pending attempt once it is past the retention window', () => {
     const abandoned = createOAuthChatAttempt(SWEEP_INPUT)
 
-    ageAttemptThenSweep(abandoned, PENDING_GRACE_MS + 1, 'pending')
+    ageAttemptThenSweep(abandoned, RETENTION_MS + 1, 'pending')
 
     expect(window.localStorage.getItem(`sim.oauth-chat-attempt.${abandoned.id}`)).toBeNull()
     expect(window.localStorage.getItem(SWEEP_LATEST_KEY)).toBeNull()

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

@@ -161,15 +161,23 @@ function writeOAuthChatAttempt(attempt: OAuthChatAttempt): void {
 }
 
 /**
- * Grace period before a still-pending attempt is collected. A pending record is
- * a flow whose window may yet return: {@link readOAuthChatAttempt} applies no
- * age gate, so a popup parked past the read cutoff can still publish a verdict
- * through {@link setOAuthChatAttemptStatus}. Sweeping on age alone — as the
- * common OIDC client implementations do — would drop that record and strand the
- * row on 'pending' with no event to correct it. A day is far past any live
- * consent flow while still bounding what an abandoned one can leave behind.
+ * How long a record is kept after its last meaningful activity, whatever its
+ * status. Deliberately far longer than {@link OAUTH_CHAT_ATTEMPT_MAX_AGE_MS},
+ * which only governs what a *lookup* will honour — a record still has readers
+ * after that cutoff, and removing one out from under them is visible:
+ *
+ * - A pending record is a flow whose window may yet return.
+ *   {@link readOAuthChatAttempt} applies no age gate, so a parked popup can
+ *   still publish a verdict through {@link setOAuthChatAttemptStatus}.
+ * - A resolved record still backs a mounted chip. That row recomputes itself
+ *   from storage on every attempt event, and for a reconnect its connected
+ *   state has no other source, so sweeping the record reverts the row.
+ *
+ * Sweeping on the lookup cutoff — as the common OIDC client implementations do
+ * — breaks both. A day is past any live consent flow or session in which a row
+ * is still on screen, while still bounding what abandoned flows leave behind.
  */
-const OAUTH_CHAT_ATTEMPT_PENDING_GRACE_MS = 24 * 60 * 60 * 1000
+const OAUTH_CHAT_ATTEMPT_RETENTION_MS = 24 * 60 * 60 * 1000
 
 /**
  * Drops attempt records that can no longer inform a reader, along with the
@@ -194,20 +202,11 @@ 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) {
-      // 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
-          : OAUTH_CHAT_ATTEMPT_MAX_AGE_MS
-      if (age <= maxAge) continue
+      // Age from the last thing that happened to the record. Measuring a
+      // resolved one from `requestedAt` would make a verdict that landed late
+      // sweepable the instant it arrived.
+      const lastActivityAt = attempt.resolvedAt ?? attempt.requestedAt
+      if (now - lastActivityAt <= OAUTH_CHAT_ATTEMPT_RETENTION_MS) continue
     }
     expiredAttemptIds.add(attemptId)
     staleKeys.push(key)