fix(hub): restore inactive-session guard on /archive except split-brain

Addresses post-rebase bot review Major on tiann#923: dropping requireActive
entirely let normal inactive non-archived rows (completed stubs, UI
Delete/Reopen targets) fall through to archiveSession, which could stamp
archivedBy=hub on sessions that were never active.

Restore the 409 for inactive rows unless metadata.lifecycleState is
still 'running' (hub-restart split-brain cleanup case from tiann#916).
Two route tests cover the guard and the exception.

Refs tiann#916.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: heavygee

hub/src/web/routes/sessions.test.ts

@@ -1099,6 +1099,42 @@ describe('sessions routes', () => {
             expect(response.status).toBe(404)
             expect(await response.json()).toEqual({ error: 'Session not found' })
         })
+
+        it('returns 409 for an inactive non-archived row whose lifecycle is not running', async () => {
+            let called = false
+            const session = createSession({ active: false })
+            const { app } = createApp(session, {
+                archiveSession: async () => { called = true }
+            })
+
+            const response = await app.request('/api/sessions/session-1/archive', { method: 'POST' })
+
+            expect(response.status).toBe(409)
+            expect(await response.json()).toEqual({ error: 'Session is inactive' })
+            expect(called).toBe(false)
+        })
+
+        it('returns 2xx for an inactive split-brain row still marked lifecycleState=running', async () => {
+            const calls: string[] = []
+            const session = createSession({
+                active: false,
+                metadata: {
+                    path: '/tmp/project',
+                    host: 'localhost',
+                    flavor: 'codex',
+                    lifecycleState: 'running'
+                }
+            })
+            const { app } = createApp(session, {
+                archiveSession: async (sessionId: string) => { calls.push(sessionId) }
+            })
+
+            const response = await app.request('/api/sessions/session-1/archive', { method: 'POST' })
+
+            expect(response.status).toBe(200)
+            expect(await response.json()).toEqual({ ok: true })
+            expect(calls).toEqual(['session-1'])
+        })
     })
 
 })

hub/src/web/routes/sessions.ts

@@ -291,11 +291,12 @@ export function createSessionsRoutes(getSyncEngine: () => SyncEngine | null): Ho
     })
 
     app.post('/sessions/:id/archive', async (c) => {
-        // tiann/hapi#916: drop `requireActive: true` so the endpoint is
-        // idempotent for already-archived rows AND for live-in-cache /
-        // dead-on-cli split-brain rows that the operator wants to clean up
-        // after a hub-restart cascade. We still 404 on unknown ids via
-        // requireSessionFromParam, and 5xx on real RPC failures.
+        // tiann/hapi#916: relax the blanket `requireActive: true` guard so
+        // the endpoint is idempotent for already-archived rows AND can clean
+        // up split-brain rows after a hub-restart cascade (inactive in cache
+        // but metadata.lifecycleState still 'running'). Normal inactive rows
+        // that are not archived (completed stubs, UI Delete/Reopen targets)
+        // keep the old 409 contract.
         const engine = requireSyncEngine(c, getSyncEngine)
         if (engine instanceof Response) {
             return engine
@@ -306,10 +307,15 @@ export function createSessionsRoutes(getSyncEngine: () => SyncEngine | null): Ho
             return sessionResult
         }
 
-        if (sessionResult.session.metadata?.lifecycleState === 'archived') {
+        const lifecycleState = sessionResult.session.metadata?.lifecycleState
+        if (lifecycleState === 'archived') {
             return c.json({ ok: true, alreadyArchived: true })
         }
 
+        if (!sessionResult.session.active && lifecycleState !== 'running') {
+            return c.json({ error: 'Session is inactive' }, 409)
+        }
+
         await engine.archiveSession(sessionResult.sessionId)
         return c.json({ ok: true })
     })