@swarmclawai/swarmclaw 1.5.65 → 1.5.67

package/README.md

@@ -399,6 +399,22 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.5.67 Highlights
+
+Three chatroom-focused fixes from a community contribution by [@borislavnnikolov](https://github.com/borislavnnikolov). Thanks Borislav!
+
+- **Inspect a chatroom member mid-turn.** Clicking a member avatar in a chatroom while that agent is busy now opens a bottom sheet with the agent's synthetic chatroom session: recent messages, execution-log entries, and counts. Previously the click jumped to the agent detail page, which lost the chatroom context. The synthetic session-id convention (`chatroom-<roomId>-<agentId>`) is now centralized in `src/lib/chatroom-sessions.ts` and shared between the UI and `chatroom-helpers.ts` so the two halves can never drift.
+- **Continue a specific session, not just the agent's main thread.** The store now exposes an `activeSessionIdOverride` on the session slice. Selecting a chat from the Chat List or a specific session row from the Agent Inspector sets the override, so the chat surface opens that exact session instead of the agent's primary thread session. The override clears automatically when the agent changes or the session is removed, with regression tests in `session-slice.test.ts` covering the override-preferred, override-stale, and fallback cases.
+- **Caret stays aligned with mention highlights in the chatroom composer.** The mention-highlight `<span>` had `px-0.5` padding that pushed the mirrored caret out of position at line ends. Padding is removed and the soft-accent background lightened slightly so the highlight still reads without nudging the layout.
+
+### v1.5.66 Highlights
+
+Fixes a runaway-token-burn bug in the orchestrator-wake and heartbeat loops. The root cause was hidden in the success/failure classification: a session run can resolve its promise successfully while still carrying an `error` on the result (e.g. a provider 429 swallowed into persisted output), and the wake trackers only incremented their failure counters on a rejected promise. So the backoff never engaged, the auto-disable-after-N-failures gate never tripped, and the wake kept firing at its configured interval indefinitely — every firing spending tokens on a full prompt against a provider that was already cooling down.
+
+- **`classifyWakeOutcome` (`src/lib/server/runtime/heartbeat-service.ts`)** — new pure helper, extracted for unit testing, that maps a resolved run result into `null` (success) or a short failure reason. A run counts as a failure when `result.error` is a non-empty string, *or* when `result.text` is empty/whitespace-only. Both the orchestrator-wake and heartbeat outcome handlers now feed through this helper, so silent-failure runs tick the failure counter and the exponential backoff (10s → 5min) kicks in normally.
+- **Auto-disable gate now trips for provider 429 / silent-wake loops.** The existing `MAX_CONSECUTIVE_FAILURES = 10` threshold was already in place but unreachable for the most common failure mode (429 errors that still persisted a run). After the fix, ten consecutive dud wakes auto-disable the orchestrator/heartbeat for that agent/session and post an explicit notification instead of grinding indefinitely.
+- **Regression coverage.** `heartbeat-service.test.ts` now has 5 targeted cases on `classifyWakeOutcome` — the 429 regression, empty-output detection, non-string error fields, whitespace-only errors, and the happy path. `test:runtime` now runs 104 cases.
+
 ### v1.5.65 Highlights
 
 Follow-up hardening on the v1.5.64 work after live-testing the chat-header flows, the MCP connection pool, and the MCP Registry browser. Six concrete bugs fixed in the clear/undo, MCP pool eviction, and registry-browser code paths.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.5.65",
+  "version": "1.5.67",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",

package/src/components/agents/inspector-panel.tsx

@@ -903,6 +903,8 @@ function SessionsSection({ agent }: { agent: Agent }) {
   const connectors = useAppStore((s) => s.connectors)
   const agents = useAppStore((s) => s.agents)
   const setCurrentAgent = useAppStore((s) => s.setCurrentAgent)
+  const setActiveSessionIdOverride = useAppStore((s) => s.setActiveSessionIdOverride)
+  const setInspectorOpen = useAppStore((s) => s.setInspectorOpen)
 
   const agentSessions = useMemo(() => {
     return Object.values(sessions).filter((s) => s.agentId === agent.id)
@@ -922,7 +924,15 @@ function SessionsSection({ agent }: { agent: Agent }) {
             <button
               key={s.id}
               type="button"
-              onClick={() => void setCurrentAgent(agent.id)}
+              onClick={() => {
+                void setCurrentAgent(agent.id).then(() => {
+                  setActiveSessionIdOverride(s.id)
+                  setInspectorOpen(false)
+                  if (typeof window !== 'undefined') {
+                    window.dispatchEvent(new CustomEvent('swarmclaw:scroll-bottom'))
+                  }
+                }).catch(() => {})
+              }}
               className="flex items-center gap-2 w-full py-1.5 px-2 rounded-[8px] bg-transparent border-none cursor-pointer hover:bg-white/[0.04] transition-colors text-left"
             >
               {connector ? (

package/src/components/chat/chat-list.tsx

@@ -26,6 +26,7 @@ export function ChatList({ inSidebar, onSelect }: Props) {
   const currentUser = useAppStore((s) => s.currentUser)
   const currentSessionId = useAppStore(selectActiveSessionId)
   const setCurrentAgent = useAppStore((s) => s.setCurrentAgent)
+  const setActiveSessionIdOverride = useAppStore((s) => s.setActiveSessionIdOverride)
   const loadConnectors = useAppStore((s) => s.loadConnectors)
   const setAgentSheetOpen = useAppStore((s) => s.setAgentSheetOpen)
   const clearSessions = useAppStore((s) => s.clearSessions)
@@ -117,7 +118,10 @@ export function ChatList({ inSidebar, onSelect }: Props) {
 
   const handleSelect = async (id: string) => {
     const agentId = sessions[id]?.agentId
-    if (agentId) void setCurrentAgent(agentId)
+    if (agentId) {
+      await setCurrentAgent(agentId)
+      setActiveSessionIdOverride(id)
+    }
     markChatRead(id)
     if (typeof window !== 'undefined') {
       window.dispatchEvent(new CustomEvent('swarmclaw:scroll-bottom'))

package/src/components/chatrooms/chatroom-input.tsx

@@ -176,7 +176,7 @@ export function ChatroomInput({ agents, onSend, disabled, onBreakoutRequest }: P
         parts.push(text.slice(lastIndex, match.index))
       }
       parts.push(
-        <span key={match.index} className="bg-accent-soft/50 text-accent-bright rounded px-0.5">
+        <span key={match.index} className="bg-accent-soft/45 text-accent-bright rounded">
           {match[0]}
         </span>
       )

package/src/components/chatrooms/chatroom-view.tsx

@@ -9,6 +9,7 @@ import { useNavigate } from '@/lib/app/navigation'
 import { useNow } from '@/hooks/use-now'
 import { useWs } from '@/hooks/use-ws'
 import { api } from '@/lib/app/api-client'
+import { resolveChatroomSyntheticSessionId } from '@/lib/chatroom-sessions'
 import { ChatroomMessageBubble } from './chatroom-message'
 import { ChatroomInput } from './chatroom-input'
 import { ChatroomTypingBar } from './chatroom-typing-bar'
@@ -20,7 +21,7 @@ import {
   StructuredSessionLauncher,
   type StructuredSessionLaunchContext,
 } from '@/components/protocols/structured-session-launcher'
-import type { Chatroom, ChatroomMessage, ChatroomMember, Agent, ProtocolRun } from '@/types'
+import type { Chatroom, ChatroomMessage, ChatroomMember, Agent, ProtocolRun, Session, Message } from '@/types'
 
 function getRoleBadge(role: string) {
   if (role === 'admin') return { label: 'Admin', className: 'bg-purple-500/20 text-purple-400 border-purple-500/30' }
@@ -45,6 +46,13 @@ function isAgentMuted(chatroom: Chatroom, agentId: string, now: number | null):
 }
 
 type MomentType = { kind: 'heartbeat' } | { kind: 'tool'; name: string; input: string }
+type SessionExecLogEntry = {
+  id: string
+  category: string
+  summary: string
+  detail: Record<string, unknown> | null
+  ts: number
+}
 
 function useAgentHeartbeat(agentId: string, onPulse: (id: string) => void) {
   const topic = agentId ? `heartbeat:agent:${agentId}` : ''
@@ -120,6 +128,13 @@ export function ChatroomView() {
   const [injectError, setInjectError] = useState<string | null>(null)
   const [linkedRun, setLinkedRun] = useState<ProtocolRun | null>(null)
   const [activeParentRun, setActiveParentRun] = useState<ProtocolRun | null>(null)
+  const [inspectSessionOpen, setInspectSessionOpen] = useState(false)
+  const [inspectedAgent, setInspectedAgent] = useState<Agent | null>(null)
+  const [inspectedSessionId, setInspectedSessionId] = useState<string | null>(null)
+  const [inspectedMessages, setInspectedMessages] = useState<Message[]>([])
+  const [inspectedExecLogs, setInspectedExecLogs] = useState<SessionExecLogEntry[]>([])
+  const [inspectLoading, setInspectLoading] = useState(false)
+  const [inspectError, setInspectError] = useState<string | null>(null)
 
   const handleHeartbeatPulse = useCallback((agentId: string) => {
     setAgentMoments((prev) => ({ ...prev, [agentId]: { kind: 'heartbeat' } }))
@@ -227,6 +242,8 @@ export function ChatroomView() {
 
   useEffect(() => {
     setDetailsOpen(false)
+    setInspectSessionOpen(false)
+    setInspectError(null)
   }, [chatroomId])
 
   const refreshLinkedRun = useCallback(() => {
@@ -330,6 +347,29 @@ export function ChatroomView() {
     }
   }
 
+  const handleInspectAgentSession = async (agent: Agent) => {
+    if (!chatroom) return
+    const sessionId = resolveChatroomSyntheticSessionId(chatroom.id, agent.id)
+    setInspectSessionOpen(true)
+    setInspectedAgent(agent)
+    setInspectedSessionId(sessionId)
+    setInspectLoading(true)
+    setInspectError(null)
+
+    try {
+      const session = await api<Session>('GET', `/chats/${encodeURIComponent(sessionId)}`)
+      setInspectedMessages(Array.isArray(session?.messages) ? session.messages : [])
+      const logs = await api<SessionExecLogEntry[]>('GET', `/chats/${encodeURIComponent(sessionId)}/execution-log?limit=200`)
+      setInspectedExecLogs(Array.isArray(logs) ? logs : [])
+    } catch (error) {
+      setInspectedMessages([])
+      setInspectedExecLogs([])
+      setInspectError(error instanceof Error ? error.message : 'Unable to load this agent session yet.')
+    } finally {
+      setInspectLoading(false)
+    }
+  }
+
   return (
     <div className="flex-1 flex min-h-0 min-w-0">
       <div className="min-w-0 flex-1 flex flex-col h-full">
@@ -379,7 +419,13 @@ export function ChatroomView() {
                 <Tooltip key={agent.id}>
                   <TooltipTrigger asChild>
                     <button
-                      onClick={() => navigateToAgent(agent.id)}
+                      onClick={() => {
+                        if (streamingAgents.has(agent.id)) {
+                          void handleInspectAgentSession(agent)
+                          return
+                        }
+                        navigateToAgent(agent.id)
+                      }}
                       className={`relative transition-all duration-200 hover:scale-110 hover:z-10 hover:-translate-y-0.5 cursor-pointer bg-transparent border-none p-0 ${muted ? 'opacity-40' : ''}`}
                     >
                       <AgentAvatar seed={agent.avatarSeed} avatarUrl={agent.avatarUrl} name={agent.name} size={22} status={streamingAgents.has(agent.id) ? 'busy' : 'online'} />
@@ -393,6 +439,7 @@ export function ChatroomView() {
                   <TooltipContent side="bottom" sideOffset={6}>
                     <div className="flex items-center gap-1.5">
                       <span>{agent.name}</span>
+                      {streamingAgents.has(agent.id) && <span className="text-[9px] text-sky-300">Click to inspect</span>}
                       {badge && <span className={`text-[9px] font-600 px-1 py-0.5 rounded border ${badge.className}`}>{badge.label}</span>}
                       {muted && <span className="text-[9px] text-red-400">Muted</span>}
                     </div>
@@ -635,6 +682,7 @@ export function ChatroomView() {
           now={now}
           onFocusMessage={focusMessage}
           onNavigateToAgent={navigateToAgent}
+          onInspectAgentSession={handleInspectAgentSession}
         />
       </aside>
 
@@ -652,9 +700,95 @@ export function ChatroomView() {
             setTimeout(() => focusMessage(messageId), 50)
           }}
           onNavigateToAgent={navigateToAgent}
+          onInspectAgentSession={handleInspectAgentSession}
           compact
         />
       </BottomSheet>
+      <BottomSheet
+        open={inspectSessionOpen}
+        onClose={() => {
+          setInspectSessionOpen(false)
+          setInspectError(null)
+        }}
+        title={inspectedAgent ? `${inspectedAgent.name} session` : 'Agent session'}
+        description={inspectedSessionId ? `Inspecting ${inspectedSessionId}` : 'Inspecting active chatroom member session'}
+      >
+        {inspectLoading ? (
+          <div className="rounded-[12px] border border-white/[0.06] bg-white/[0.02] px-4 py-6 text-[13px] text-text-3">
+            Loading session activity…
+          </div>
+        ) : inspectError ? (
+          <div className="rounded-[12px] border border-red-500/20 bg-red-500/10 px-4 py-3 text-[13px] text-red-200">
+            {inspectError}
+          </div>
+        ) : (
+          <div className="space-y-4">
+            <div className="grid grid-cols-3 gap-2">
+              <div className="rounded-[10px] border border-white/[0.06] bg-white/[0.02] px-3 py-2.5">
+                <div className="text-[16px] font-display font-700 text-text">{inspectedMessages.length}</div>
+                <div className="mt-0.5 text-[10px] uppercase tracking-[0.08em] text-text-3/50">Messages</div>
+              </div>
+              <div className="rounded-[10px] border border-white/[0.06] bg-white/[0.02] px-3 py-2.5">
+                <div className="text-[16px] font-display font-700 text-sky-300">{inspectedExecLogs.length}</div>
+                <div className="mt-0.5 text-[10px] uppercase tracking-[0.08em] text-text-3/50">Events</div>
+              </div>
+              <div className="rounded-[10px] border border-white/[0.06] bg-white/[0.02] px-3 py-2.5">
+                <div className="text-[12px] font-mono text-text-2 truncate" title={inspectedSessionId || undefined}>
+                  {inspectedSessionId || '—'}
+                </div>
+                <div className="mt-0.5 text-[10px] uppercase tracking-[0.08em] text-text-3/50">Session ID</div>
+              </div>
+            </div>
+
+            <section>
+              <h4 className="mb-2 text-[12px] font-700 uppercase tracking-[0.08em] text-text-3/60">Recent Messages</h4>
+              <div className="max-h-[220px] space-y-2 overflow-y-auto rounded-[12px] border border-white/[0.06] bg-white/[0.02] p-3">
+                {inspectedMessages.length === 0 ? (
+                  <p className="text-[12px] text-text-3">No messages yet for this session.</p>
+                ) : (
+                  inspectedMessages.slice(-12).map((message, index) => (
+                    <div key={`${message.time}-${message.role}-${index}`} className="rounded-[10px] border border-white/[0.05] bg-black/20 px-3 py-2">
+                      <div className="flex items-center gap-2 text-[10px] uppercase tracking-[0.08em] text-text-3/60">
+                        <span>{message.role}</span>
+                        <span>·</span>
+                        <span>{new Date(message.time).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' })}</span>
+                      </div>
+                      <p className="mt-1 text-[12px] leading-[1.5] text-text-2 whitespace-pre-wrap break-words">
+                        {message.text || '(empty)'}
+                      </p>
+                    </div>
+                  ))
+                )}
+              </div>
+            </section>
+
+            <section>
+              <h4 className="mb-2 text-[12px] font-700 uppercase tracking-[0.08em] text-text-3/60">Execution Log</h4>
+              <div className="max-h-[220px] space-y-2 overflow-y-auto rounded-[12px] border border-white/[0.06] bg-white/[0.02] p-3">
+                {inspectedExecLogs.length === 0 ? (
+                  <p className="text-[12px] text-text-3">No execution log entries yet.</p>
+                ) : (
+                  inspectedExecLogs
+                    .slice()
+                    .sort((a, b) => b.ts - a.ts)
+                    .map((entry) => (
+                      <div key={entry.id} className="rounded-[10px] border border-white/[0.05] bg-black/20 px-3 py-2">
+                        <div className="flex items-center gap-2 text-[10px] uppercase tracking-[0.08em] text-text-3/60">
+                          <span>{entry.category}</span>
+                          <span>·</span>
+                          <span>{new Date(entry.ts).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' })}</span>
+                        </div>
+                        <p className="mt-1 text-[12px] leading-[1.5] text-text-2 whitespace-pre-wrap break-words">
+                          {entry.summary}
+                        </p>
+                      </div>
+                    ))
+                )}
+              </div>
+            </section>
+          </div>
+        )}
+      </BottomSheet>
       <StructuredSessionLauncher
         open={structuredSessionOpen}
         onClose={() => {
@@ -721,6 +855,7 @@ function RoomDetailsPanel({
   now,
   onFocusMessage,
   onNavigateToAgent,
+  onInspectAgentSession,
   compact = false,
 }: {
   chatroom: Chatroom
@@ -732,6 +867,7 @@ function RoomDetailsPanel({
   now: number | null
   onFocusMessage: (messageId: string) => void
   onNavigateToAgent: (agentId: string) => void
+  onInspectAgentSession: (agent: Agent) => Promise<void>
   compact?: boolean
 }) {
   return (
@@ -771,7 +907,13 @@ function RoomDetailsPanel({
               return (
                 <button
                   key={agent.id}
-                  onClick={() => onNavigateToAgent(agent.id)}
+                  onClick={() => {
+                    if (streamingAgents.has(agent.id)) {
+                      void onInspectAgentSession(agent)
+                      return
+                    }
+                    onNavigateToAgent(agent.id)
+                  }}
                   className="w-full rounded-[12px] border border-white/[0.06] bg-white/[0.02] px-3 py-2.5 text-left hover:bg-white/[0.05] transition-all cursor-pointer"
                   style={{ fontFamily: 'inherit' }}
                 >

package/src/lib/chatroom-sessions.ts

@@ -0,0 +1,4 @@
+export function resolveChatroomSyntheticSessionId(chatroomId: string, agentId: string): string {
+  return `chatroom-${chatroomId}-${agentId}`
+}
+

package/src/lib/server/chatrooms/chatroom-helpers.test.ts

@@ -10,10 +10,12 @@ import {
   buildHistoryForAgent,
   buildSyntheticSession,
   resolveChatroomWorkspaceDir,
+  resolveSyntheticSessionId,
   resolveAgentApiEndpoint,
   resolveReplyTargetAgentId,
   buildAgentSystemPromptForChatroom,
 } from '@/lib/server/chatrooms/chatroom-helpers'
+import { resolveChatroomSyntheticSessionId } from '@/lib/chatroom-sessions'
 
 function makeAgents(): Record<string, Agent> {
   const now = Date.now()
@@ -234,6 +236,11 @@ describe('chatroom-helpers', () => {
     assert.match(cwd, /chatrooms[\/\\]room-safe$/)
   })
 
+  it('uses a stable synthetic session id convention shared with the UI', () => {
+    assert.equal(resolveChatroomSyntheticSessionId('room-1', 'agent-1'), 'chatroom-room-1-agent-1')
+    assert.equal(resolveSyntheticSessionId('room-1', 'agent-1'), 'chatroom-room-1-agent-1')
+  })
+
   it('matches multi-word agent name over shorter prefix', () => {
     const agents = makeMultiWordAgents()
     const memberIds = ['hal2k', 'hal2k-openai', 'code-monkey']

package/src/lib/server/chatrooms/chatroom-helpers.ts

@@ -13,6 +13,7 @@ import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/serve
 import { loadSkills } from '@/lib/server/skills/skill-repository'
 import { loadSession, patchSession, saveSession } from '@/lib/server/sessions/session-repository'
 import { appendMessage } from '@/lib/server/messages/message-repository'
+import { resolveChatroomSyntheticSessionId } from '@/lib/chatroom-sessions'
 import type { Chatroom, ChatroomMember, Agent, Session, Message, ChatroomMessage } from '@/types'
 import { getEnabledCapabilityIds, getEnabledToolIds } from '@/lib/capability-selection'
 
@@ -272,7 +273,7 @@ export function resolveChatroomWorkspaceDir(chatroomId: string): string {
 }
 
 export function resolveSyntheticSessionId(chatroomId: string, agentId: string): string {
-  return `chatroom-${chatroomId}-${agentId}`
+  return resolveChatroomSyntheticSessionId(chatroomId, agentId)
 }
 
 function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']> {

package/src/lib/server/runtime/heartbeat-service.test.ts

@@ -450,3 +450,35 @@ describe('heartbeatConfigForSession lightContext', () => {
     assert.equal(cfg.lightContext, false)
   })
 })
+
+describe('classifyWakeOutcome (runaway-loop guard)', () => {
+  it('returns null for a run with visible text and no error', () => {
+    assert.equal(mod.classifyWakeOutcome({ text: 'all good', error: null }), null)
+    assert.equal(mod.classifyWakeOutcome({ text: 'ORCHESTRATOR_OK' }), null)
+  })
+
+  it('treats a resolved-but-errored result as failure (the 429 regression)', () => {
+    const out = mod.classifyWakeOutcome({
+      text: '',
+      error: '429 All credentials for model gpt-5.4 are cooling down via provider codex',
+    })
+    assert.equal(out, '429 All credentials for model gpt-5.4 are cooling down via provider codex')
+  })
+
+  it('counts empty visible output as failure so silent wakes trigger backoff', () => {
+    assert.equal(mod.classifyWakeOutcome({ text: '' }), 'empty wake response')
+    assert.equal(mod.classifyWakeOutcome({ text: '   \n\t' }), 'empty wake response')
+    assert.equal(mod.classifyWakeOutcome({}), 'empty wake response')
+    assert.equal(mod.classifyWakeOutcome(null), 'empty wake response')
+    assert.equal(mod.classifyWakeOutcome(undefined), 'empty wake response')
+  })
+
+  it('ignores a non-string error field and falls back to text check', () => {
+    assert.equal(mod.classifyWakeOutcome({ text: 'hi', error: 42 }), null)
+    assert.equal(mod.classifyWakeOutcome({ text: '', error: 42 }), 'empty wake response')
+  })
+
+  it('ignores an empty-string error so whitespace errors do not double-count', () => {
+    assert.equal(mod.classifyWakeOutcome({ text: 'fine', error: '   ' }), null)
+  })
+})

package/src/lib/server/runtime/heartbeat-service.ts

@@ -54,6 +54,23 @@ const ORCHESTRATOR_MIN_INTERVAL_SEC = 60
 const ORCHESTRATOR_MAX_INTERVAL_SEC = 86400    // 24h
 const ORCHESTRATOR_MAX_PROMPT_CHARS = 4000
 
+/**
+ * Classify a resolved session-run result as success or failure for the
+ * heartbeat/orchestrator outcome tracker. A resolved promise can still
+ * carry an error on `result.error` (e.g. a provider 429 that was swallowed
+ * into persisted output) or resolve with empty text, and both cases must
+ * count as failures — otherwise a stuck wake loop never ticks the
+ * failure counter, never backs off, and never auto-disables.
+ */
+export function classifyWakeOutcome(result: unknown): string | null {
+  if (!result || typeof result !== 'object') return 'empty wake response'
+  const obj = result as { error?: unknown; text?: unknown }
+  if (typeof obj.error === 'string' && obj.error.trim()) return obj.error
+  const text = typeof obj.text === 'string' ? obj.text : ''
+  if (!text.trim()) return 'empty wake response'
+  return null
+}
+
 interface FailureRecord {
   count: number
   lastFailedAt: number
@@ -782,24 +799,28 @@ export async function tickHeartbeats() {
     state.lastBySession.set(session.id, now)
 
     const sid = session.id as string
-    enqueue.promise.then(() => {
-      const prev = state.failures.get(sid)
-      if (prev?.recoveryAttempts) {
-        log.info('heartbeat', `Recovery successful for session ${sid} after ${prev.recoveryAttempts} attempt(s)`)
+    // A session run can "resolve" with an error in result.error (e.g. provider
+    // 429 swallowed into the persisted failure) or with empty text. Treat both
+    // as failures so backoff and auto-disable trigger, otherwise a stuck
+    // heartbeat keeps re-firing at the configured interval and burning tokens.
+    const handleHeartbeatOutcome = (failure: string | null) => {
+      if (!failure) {
+        const prev = state.failures.get(sid)
+        if (prev?.recoveryAttempts) {
+          log.info('heartbeat', `Recovery successful for session ${sid} after ${prev.recoveryAttempts} attempt(s)`)
+        }
+        state.failures.delete(sid)
+        patchSession(sid, (s) => {
+          if (!s) return s
+          s.lastDeliveryStatus = 'ok'
+          s.lastDeliveredAt = Date.now()
+          return s
+        })
+        return
       }
-      state.failures.delete(sid)
-      // Track successful delivery
-      patchSession(sid, (s) => {
-        if (!s) return s
-        s.lastDeliveryStatus = 'ok'
-        s.lastDeliveredAt = Date.now()
-        return s
-      })
-    }).catch((err: unknown) => {
       const prev = state.failures.get(sid)
       const newCount = (prev?.count ?? 0) + 1
       const record: FailureRecord = { count: newCount, lastFailedAt: Date.now() }
-      // Auto-disable heartbeat after too many consecutive failures to prevent resource waste
       if (newCount >= MAX_CONSECUTIVE_FAILURES) {
         record.autoDisabledAt = Date.now()
         log.warn('heartbeat', `Auto-disabling heartbeat for session ${sid} after ${newCount} consecutive failures`)
@@ -821,17 +842,20 @@ export async function tickHeartbeats() {
         })
       }
       state.failures.set(sid, record)
-      const msg = errorMessage(err)
-      log.warn('heartbeat', `Heartbeat run failed for session ${sid} (${newCount}/${MAX_CONSECUTIVE_FAILURES})`, msg)
-      // Track failed delivery
+      log.warn('heartbeat', `Heartbeat run failed for session ${sid} (${newCount}/${MAX_CONSECUTIVE_FAILURES})`, failure)
       patchSession(sid, (s) => {
         if (!s) return s
         s.lastDeliveryStatus = 'error'
-        s.lastDeliveryError = msg
+        s.lastDeliveryError = failure
         s.lastDeliveredAt = Date.now()
         return s
       })
-    })
+    }
+    enqueue.promise
+      .then((result) => handleHeartbeatOutcome(classifyWakeOutcome(result)))
+      .catch((err: unknown) => {
+        handleHeartbeatOutcome(errorMessage(err) || 'heartbeat rejected')
+      })
   }
 }
 
@@ -1118,10 +1142,15 @@ export async function tickOrchestratorAgents() {
 
       log.info('orchestrator', `Woke orchestrator agent ${agent.name} (${agent.id}), cycle #${(agent.orchestratorCycleCount || 0) + 1}`)
 
-      // Track success/failure
-      enqueue.promise.then(() => {
-        orchestratorState.failures.delete(agent.id)
-      }).catch((err: unknown) => {
+      // Track success/failure. A run can "resolve" but still carry an error
+      // on the result (e.g. provider 429 that was caught and persisted), so we
+      // inspect the resolved result as well as the rejected path — otherwise
+      // a stuck wake loop never ticks the failure counter and never backs off.
+      const handleWakeOutcome = (failure: string | null) => {
+        if (!failure) {
+          orchestratorState.failures.delete(agent.id)
+          return
+        }
         const prev = orchestratorState.failures.get(agent.id)
         const newCount = (prev?.count ?? 0) + 1
         const record: FailureRecord = { count: newCount, lastFailedAt: Date.now() }
@@ -1146,8 +1175,13 @@ export async function tickOrchestratorAgents() {
           })
         }
         orchestratorState.failures.set(agent.id, record)
-        log.warn('orchestrator', `Orchestrator wake failed for agent ${agent.id} (${newCount}/${MAX_CONSECUTIVE_FAILURES})`, errorMessage(err))
-      })
+        log.warn('orchestrator', `Orchestrator wake failed for agent ${agent.id} (${newCount}/${MAX_CONSECUTIVE_FAILURES})`, failure)
+      }
+      enqueue.promise
+        .then((result) => handleWakeOutcome(classifyWakeOutcome(result)))
+        .catch((err: unknown) => {
+          handleWakeOutcome(errorMessage(err) || 'wake rejected')
+        })
     } catch (err) {
       log.warn('orchestrator', `Error ticking orchestrator agent ${agent.id}:`, errorMessage(err))
     }

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

@@ -27,14 +27,15 @@ export const createAgentSlice: StateCreator<AppState, [], [], AgentSlice> = (set
   currentAgentId: null,
   setCurrentAgent: async (id) => {
     if (!id) {
-      set({ currentAgentId: null })
+      set({ currentAgentId: null, activeSessionIdOverride: null })
       safeStorageRemove('sc_agent')
       return
     }
     if (get().currentAgentId === id && get().agents[id]?.threadSessionId) {
+      set({ activeSessionIdOverride: null })
       return
     }
-    set({ currentAgentId: id })
+    set({ currentAgentId: id, activeSessionIdOverride: null })
     safeStorageSet('sc_agent', id)
 
     await agentThreadDedup.dedup(id, async () => {

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

@@ -0,0 +1,52 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import type { Agent, Session } from '../../types'
+import type { AppState } from '../use-app-store'
+import { selectActiveSessionId } from './session-slice'
+
+function makeState(overrides: Partial<AppState>): AppState {
+  return {
+    currentAgentId: null,
+    agents: {},
+    sessions: {},
+    activeSessionIdOverride: null,
+    ...overrides,
+  } as AppState
+}
+
+function makeAgent(id: string, threadSessionId: string): Agent {
+  return { id, threadSessionId } as unknown as Agent
+}
+
+function makeSession(id: string): Session {
+  return { id } as unknown as Session
+}
+
+test('selectActiveSessionId prefers override when present', () => {
+  const state = makeState({
+    currentAgentId: 'agent-1',
+    agents: { 'agent-1': makeAgent('agent-1', 'thread-1') },
+    sessions: { 'thread-1': makeSession('thread-1'), 'task-1': makeSession('task-1') },
+    activeSessionIdOverride: 'task-1',
+  })
+  assert.equal(selectActiveSessionId(state), 'task-1')
+})
+
+test('selectActiveSessionId falls back to agent thread session', () => {
+  const state = makeState({
+    currentAgentId: 'agent-1',
+    agents: { 'agent-1': makeAgent('agent-1', 'thread-1') },
+    sessions: { 'thread-1': makeSession('thread-1') },
+  })
+  assert.equal(selectActiveSessionId(state), 'thread-1')
+})
+
+test('selectActiveSessionId ignores stale override ids', () => {
+  const state = makeState({
+    currentAgentId: 'agent-1',
+    agents: { 'agent-1': makeAgent('agent-1', 'thread-1') },
+    sessions: { 'thread-1': makeSession('thread-1') },
+    activeSessionIdOverride: 'missing-session',
+  })
+  assert.equal(selectActiveSessionId(state), 'thread-1')
+})

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

@@ -10,6 +10,9 @@ const sessionRefreshDedup = createInflightDeduplicator('sessionSlice_inflightRef
 
 /** 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]) {
+    return s.activeSessionIdOverride
+  }
   if (!s.currentAgentId) return null
   const agent = s.agents[s.currentAgentId]
   return agent?.threadSessionId ?? null
@@ -17,6 +20,8 @@ export function selectActiveSessionId(s: AppState): string | null {
 
 export interface SessionSlice {
   sessions: Sessions
+  activeSessionIdOverride: string | null
+  setActiveSessionIdOverride: (id: string | null) => void
   loadSessions: () => Promise<void>
   refreshSession: (id: string) => Promise<void>
   removeSession: (id: string) => void
@@ -27,6 +32,8 @@ export interface SessionSlice {
 
 export const createSessionSlice: StateCreator<AppState, [], [], SessionSlice> = (set, get) => ({
   sessions: {},
+  activeSessionIdOverride: null,
+  setActiveSessionIdOverride: (id) => set({ activeSessionIdOverride: id }),
   loadSessions: createLoader<AppState>(set, 'sessions', () => fetchChats()),
   refreshSession: async (id) => {
     if (!id) return
@@ -51,9 +58,10 @@ export const createSessionSlice: StateCreator<AppState, [], [], SessionSlice> =
     invalidateFingerprint('sessions')
     const activeSessionId = selectActiveSessionId(get())
     if (activeSessionId === id) {
-      set({ sessions, currentAgentId: null })
+      set({ sessions, currentAgentId: null, activeSessionIdOverride: null })
     } else {
-      set({ sessions })
+      const overrideId = get().activeSessionIdOverride
+      set({ sessions, activeSessionIdOverride: overrideId === id ? null : overrideId })
     }
   },
   clearSessions: async (ids) => {
@@ -64,9 +72,13 @@ export const createSessionSlice: StateCreator<AppState, [], [], SessionSlice> =
     invalidateFingerprint('sessions')
     const activeSessionId = selectActiveSessionId(get())
     if (activeSessionId && ids.includes(activeSessionId)) {
-      set({ sessions, currentAgentId: null })
+      set({ sessions, currentAgentId: null, activeSessionIdOverride: null })
     } else {
-      set({ sessions })
+      const overrideId = get().activeSessionIdOverride
+      set({
+        sessions,
+        activeSessionIdOverride: overrideId && ids.includes(overrideId) ? null : overrideId,
+      })
     }
   },
   togglePinSession: async (id) => {