@swarmclawai/swarmclaw 1.7.0 → 1.7.1

package/src/lib/server/chat-execution/chat-turn-finalization.ts

@@ -435,18 +435,25 @@ export async function finalizeChatTurn(params: {
         ;(current as unknown as Record<string, unknown>)[key] = normalized
       }
     }
+    const preferRunValue = (runValue: unknown, fallbackValue: unknown) => (
+      runValue !== undefined ? runValue : fallbackValue
+    )
 
-    persistField('claudeSessionId', session.claudeSessionId)
-    persistField('codexThreadId', session.codexThreadId)
-    persistField('opencodeSessionId', session.opencodeSessionId)
-    persistField('geminiSessionId', session.geminiSessionId)
-    persistField('copilotSessionId', session.copilotSessionId)
-    persistField('droidSessionId', session.droidSessionId)
-    persistField('cursorSessionId', session.cursorSessionId)
-    persistField('qwenSessionId', session.qwenSessionId)
-    persistField('acpSessionId', session.acpSessionId)
-
-    const sourceResume = session.delegateResumeIds
+    // Provider handlers receive `sessionForRun` and may mutate CLI resume IDs there.
+    // Persist from run-session first, allowing null to intentionally clear IDs.
+    persistField('claudeSessionId', preferRunValue(sessionForRun.claudeSessionId, session.claudeSessionId))
+    persistField('codexThreadId', preferRunValue(sessionForRun.codexThreadId, session.codexThreadId))
+    persistField('opencodeSessionId', preferRunValue(sessionForRun.opencodeSessionId, session.opencodeSessionId))
+    persistField('geminiSessionId', preferRunValue(sessionForRun.geminiSessionId, session.geminiSessionId))
+    persistField('copilotSessionId', preferRunValue(sessionForRun.copilotSessionId, session.copilotSessionId))
+    persistField('droidSessionId', preferRunValue(sessionForRun.droidSessionId, session.droidSessionId))
+    persistField('cursorSessionId', preferRunValue(sessionForRun.cursorSessionId, session.cursorSessionId))
+    persistField('qwenSessionId', preferRunValue(sessionForRun.qwenSessionId, session.qwenSessionId))
+    persistField('acpSessionId', preferRunValue(sessionForRun.acpSessionId, session.acpSessionId))
+
+    const sourceResume = (sessionForRun.delegateResumeIds && typeof sessionForRun.delegateResumeIds === 'object')
+      ? sessionForRun.delegateResumeIds
+      : session.delegateResumeIds
     if (sourceResume && typeof sourceResume === 'object') {
       const currentResume = (current.delegateResumeIds && typeof current.delegateResumeIds === 'object')
         ? current.delegateResumeIds
@@ -454,14 +461,14 @@ export async function finalizeChatTurn(params: {
       const sr = sourceResume as Record<string, unknown>
       const cr = currentResume as Record<string, unknown>
       const nextResume = {
-        claudeCode: normalizeResumeId(sr.claudeCode ?? cr.claudeCode),
-        codex: normalizeResumeId(sr.codex ?? cr.codex),
-        opencode: normalizeResumeId(sr.opencode ?? cr.opencode),
-        gemini: normalizeResumeId(sr.gemini ?? cr.gemini),
-        copilot: normalizeResumeId(sr.copilot ?? cr.copilot),
-        droid: normalizeResumeId(sr.droid ?? cr.droid),
-        cursor: normalizeResumeId(sr.cursor ?? cr.cursor),
-        qwen: normalizeResumeId(sr.qwen ?? cr.qwen),
+        claudeCode: normalizeResumeId(preferRunValue(sr.claudeCode, cr.claudeCode)),
+        codex: normalizeResumeId(preferRunValue(sr.codex, cr.codex)),
+        opencode: normalizeResumeId(preferRunValue(sr.opencode, cr.opencode)),
+        gemini: normalizeResumeId(preferRunValue(sr.gemini, cr.gemini)),
+        copilot: normalizeResumeId(preferRunValue(sr.copilot, cr.copilot)),
+        droid: normalizeResumeId(preferRunValue(sr.droid, cr.droid)),
+        cursor: normalizeResumeId(preferRunValue(sr.cursor, cr.cursor)),
+        qwen: normalizeResumeId(preferRunValue(sr.qwen, cr.qwen)),
       }
       if (JSON.stringify(currentResume) !== JSON.stringify(nextResume)) {
         current.delegateResumeIds = nextResume

package/src/stores/slices/session-slice.test.ts

@@ -32,11 +32,49 @@ test('selectActiveSessionId prefers override when present', () => {
   assert.equal(selectActiveSessionId(state), 'task-1')
 })
 
-test('selectActiveSessionId falls back to agent thread session', () => {
+test('selectActiveSessionId chooses most recently active session for current agent', () => {
   const state = makeState({
     currentAgentId: 'agent-1',
     agents: { 'agent-1': makeAgent('agent-1', 'thread-1') },
-    sessions: { 'thread-1': makeSession('thread-1') },
+    sessions: {
+      'thread-1': { ...makeSession('thread-1'), agentId: 'agent-1', lastActiveAt: 100 } as unknown as Session,
+      'old-1': { ...makeSession('old-1'), agentId: 'agent-1', lastActiveAt: 90 } as unknown as Session,
+      'latest-1': { ...makeSession('latest-1'), agentId: 'agent-1', lastActiveAt: 200, messageCount: 1 } as unknown as Session,
+      'other-agent': { ...makeSession('other-agent'), agentId: 'agent-2', lastActiveAt: 999 } as unknown as Session,
+    },
+  })
+  assert.equal(selectActiveSessionId(state), 'latest-1')
+})
+
+test('selectActiveSessionId prefers most recent session with content over newer empty thread session', () => {
+  const state = makeState({
+    currentAgentId: 'agent-1',
+    agents: { 'agent-1': makeAgent('agent-1', 'thread-1') },
+    sessions: {
+      'thread-1': { ...makeSession('thread-1'), agentId: 'agent-1', lastActiveAt: 300 } as unknown as Session,
+      'work-1': { ...makeSession('work-1'), agentId: 'agent-1', lastActiveAt: 200, messageCount: 2 } as unknown as Session,
+    },
+  })
+  assert.equal(selectActiveSessionId(state), 'work-1')
+})
+
+test('selectActiveSessionId falls back to thread session when agent has no loaded sessions', () => {
+  const state = makeState({
+    currentAgentId: 'agent-1',
+    agents: { 'agent-1': makeAgent('agent-1', 'thread-1') },
+    sessions: { 'unrelated': { ...makeSession('unrelated'), agentId: 'agent-2' } as unknown as Session },
+  })
+  assert.equal(selectActiveSessionId(state), 'thread-1')
+})
+
+test('selectActiveSessionId falls back to thread session when all loaded sessions are empty', () => {
+  const state = makeState({
+    currentAgentId: 'agent-1',
+    agents: { 'agent-1': makeAgent('agent-1', 'thread-1') },
+    sessions: {
+      'thread-1': { ...makeSession('thread-1'), agentId: 'agent-1', lastActiveAt: 120 } as unknown as Session,
+      'empty-newer': { ...makeSession('empty-newer'), agentId: 'agent-1', lastActiveAt: 220 } as unknown as Session,
+    },
   })
   assert.equal(selectActiveSessionId(state), 'thread-1')
 })

package/src/stores/slices/session-slice.ts

@@ -8,6 +8,46 @@ import { createLoader, createInflightDeduplicator } from '../store-utils'
 
 const sessionRefreshDedup = createInflightDeduplicator('sessionSlice_inflightRefreshes')
 
+function getSessionSortScore(session: Session): number {
+  return session.lastAssistantAt
+    || session.lastActiveAt
+    || session.updatedAt
+    || session.createdAt
+    || 0
+}
+
+function hasSessionContent(session: Session): boolean {
+  if (typeof session.messageCount === 'number' && Number.isFinite(session.messageCount) && session.messageCount > 0) {
+    return true
+  }
+  if (session.lastMessageSummary) return true
+  return Array.isArray(session.messages) && session.messages.length > 0
+}
+
+function getLatestAgentSessionId(s: AppState, agentId: string, threadSessionId?: string | null): string | null {
+  let bestAnyId: string | null = null
+  let bestAnyScore = Number.NEGATIVE_INFINITY
+  let bestWithContentId: string | null = null
+  let bestWithContentScore = Number.NEGATIVE_INFINITY
+
+  for (const [sessionId, session] of Object.entries(s.sessions)) {
+    if (session.agentId !== agentId) continue
+    const score = getSessionSortScore(session)
+    if (score > bestAnyScore) {
+      bestAnyScore = score
+      bestAnyId = sessionId
+    }
+    if (hasSessionContent(session) && score > bestWithContentScore) {
+      bestWithContentScore = score
+      bestWithContentId = sessionId
+    }
+  }
+
+  if (bestWithContentId) return bestWithContentId
+  if (threadSessionId && s.sessions[threadSessionId]?.agentId === agentId) return threadSessionId
+  return bestAnyId
+}
+
 /** Derive the active session ID from the current agent — no stored `currentSessionId`. */
 export function selectActiveSessionId(s: AppState): string | null {
   if (s.activeSessionIdOverride && s.sessions[s.activeSessionIdOverride]) {
@@ -15,7 +55,7 @@ export function selectActiveSessionId(s: AppState): string | null {
   }
   if (!s.currentAgentId) return null
   const agent = s.agents[s.currentAgentId]
-  return agent?.threadSessionId ?? null
+  return getLatestAgentSessionId(s, s.currentAgentId, agent?.threadSessionId) || agent?.threadSessionId || null
 }
 
 export interface SessionSlice {