teleportation-cli 1.3.0 → 1.4.0

package/lib/daemon/task-executor-v2.js

@@ -22,6 +22,37 @@ const MAX_TURNS = 100;
 // Track running processes for stop functionality (only active processes)
 const runningProcesses = new Map();
 
+/**
+ * Extract Claude's text response from stream-json output
+ * Stream-json format: one JSON object per line, assistant text is in
+ * {"type":"assistant","message":{"content":[{"type":"text","text":"..."}]}}
+ * @param {string} output - Raw stream-json stdout
+ * @returns {string} Extracted text or empty string
+ */
+function extractAssistantText(output) {
+  if (!output) return '';
+  const lines = output.split('\n');
+  // Search from end — the last assistant message is most relevant for display
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event.type === 'assistant' && event.message?.content) {
+        const textBlock = Array.isArray(event.message.content)
+          ? event.message.content.find(c => c.type === 'text')
+          : null;
+        if (textBlock?.text) {
+          return textBlock.text.trim().substring(0, 2000);
+        }
+      }
+    } catch {
+      // Not JSON, skip
+    }
+  }
+  return '';
+}
+
 /**
  * Execute a single turn for a task
  * Stateless - queries timeline to determine what to do
@@ -71,42 +102,58 @@ export async function executeTaskTurn(options) {
   }
 
   // 7. Determine which session to resume
-  // First turn: resume parent session for context
+  // First turn: start fresh (don't resume parent — it's actively in use)
   // Subsequent turns: resume child session from previous turn
-  const resumeSessionId = state.claude_session_id || task.parent_claude_session_id;
-
-  if (!resumeSessionId) {
-    console.error(`[task-v2] No session ID to resume for task ${task_id}`);
-    return { success: false, error: 'No session ID to resume' };
-  }
+  const resumeSessionId = state.claude_session_id || null;
 
   console.log(`[task-v2] Executing turn ${state.turn_count + 1} for task ${task_id.slice(0, 20)}...`);
-  console.log(`[task-v2] Resuming session: ${resumeSessionId}`);
+  if (resumeSessionId) {
+    console.log(`[task-v2] Resuming child session: ${resumeSessionId}`);
+  } else {
+    console.log(`[task-v2] Starting fresh session (first turn)`);
+  }
   console.log(`[task-v2] Prompt: ${prompt.slice(0, 100)}...`);
 
+  // 7.5 Check remaining budget before executing
+  const remainingBudget = (task.budget_usd || 0) - (task.cost_usd || 0);
+  if (remainingBudget <= 0) {
+    console.log(`[task-v2] Budget exhausted: $${task.cost_usd} of $${task.budget_usd} used`);
+    await updateTaskStatus(task_id, session_id, 'stopped', config);
+    return { success: true, stopped: true, reason: 'Budget exhausted' };
+  }
+
   // 8. Execute Claude headless
   try {
     const result = await executeClaudeHeadless({
       prompt,
       cwd: task.cwd || process.cwd(),
       resumeSessionId,
-      budgetUsd: task.budget_usd - task.cost_usd,
+      budgetUsd: remainingBudget,
       taskId: task_id,
       parentSessionId: task.session_id,
+      bypassPermissions: task.bypass_permissions,
     });
 
     // 9. Ingest transcript to timeline
     // This ensures all events (especially assistant responses) are captured
     // even if hooks failed to log them during execution
+    let transcriptIngested = false;
     if (result.session_id) {
       try {
-        await ingestTranscriptToTimeline({
+        const ingestionResult = await ingestTranscriptToTimeline({
           claude_session_id: result.session_id,
           parent_session_id: session_id,
           task_id: task_id,
           cwd: task.cwd || process.cwd(), // Pass cwd for project slug derivation
           config,
         });
+        // Only consider ingested if events were actually pushed to timeline
+        // When transcript isn't found (child session in different project dir),
+        // events_pushed will be 0 and we must fall back to manual POST
+        transcriptIngested = (ingestionResult?.events_pushed || 0) > 0;
+        if (!transcriptIngested) {
+          console.log(`[task-v2] Transcript ingestion returned 0 events — will use fallback POST`);
+        }
       } catch (error) {
         // Don't fail the whole turn if transcript ingestion fails
         console.error(`[task-v2] Failed to ingest transcript:`, error.message);
@@ -116,6 +163,65 @@ export async function executeTaskTurn(options) {
     // 10. Update task in Redis with results
     await updateTaskAfterTurn(task_id, session_id, result, task, config);
 
+    // 11. Log task turn completion to timeline so analyzeTaskState() can track progress
+    // Only emit this fallback marker if transcript ingestion didn't already emit events.
+    // Both paths produce assistant_response events with task_id, so emitting both
+    // would double-count turns in analyzeTaskState().
+    if (!transcriptIngested) {
+      try {
+        const resp = await fetch(`${relayApiUrl}/api/timeline`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            session_id,
+            type: 'assistant_response',
+            data: {
+              task_id,
+              source: 'cli_interactive',
+              claude_session_id: result.session_id,
+              turn: state.turn_count + 1,
+              cost_usd: result.cost_usd,
+              timestamp: Date.now(),
+              message: extractAssistantText(result.output) || 'Turn completed',
+            }
+          })
+        });
+        if (!resp.ok) {
+          console.error(`[task-v2] Turn completion POST failed: ${resp.status}`);
+        } else {
+          console.log(`[task-v2] Logged turn ${state.turn_count + 1} completion to timeline (fallback)`);
+        }
+      } catch (e) {
+        console.error(`[task-v2] Failed to log turn completion:`, e.message);
+      }
+    } else {
+      console.log(`[task-v2] Turn ${state.turn_count + 1} events already ingested via transcript`);
+    }
+
+    // 12. Auto-pause: unless auto_continue is set, pause after each turn
+    // This is the default behavior — user must send a message to continue
+    // CRITICAL: If this fails, the task stays 'running' and re-executes on the next
+    // poll cycle, causing the same infinite loop this PR fixes. Retry once on failure.
+    if (!task.auto_continue) {
+      console.log(`[task-v2] Pausing task after turn ${state.turn_count + 1} (auto_continue not set)`);
+      try {
+        await updateTaskStatus(task_id, session_id, 'paused', config);
+      } catch (pauseError) {
+        console.error(`[task-v2] Failed to pause task (retrying once): ${pauseError.message}`);
+        try {
+          await new Promise(r => setTimeout(r, 1000));
+          await updateTaskStatus(task_id, session_id, 'paused', config);
+        } catch (retryError) {
+          console.error(`[task-v2] CRITICAL: Failed to pause task after retry: ${retryError.message}`);
+          // Return error so daemon doesn't re-execute this turn
+          return { success: false, error: 'Failed to pause task — cannot guarantee no re-execution' };
+        }
+      }
+    }
+
     return {
       success: true,
       executed: true,
@@ -187,11 +293,19 @@ async function updateTaskAfterTurn(task_id, session_id, result, currentTask, con
   const totalCost = (currentTask.cost_usd || 0) + (result.cost_usd || 0);
 
   const updates = {
-    claude_session_id: result.session_id || currentTask.claude_session_id,
     cost_usd: totalCost,
     turn_count: (currentTask.turn_count || 0) + 1,
+    // Clear consumed prompts to prevent re-use on next turn
+    pending_answer: null,
+    pending_redirect: null,
   };
 
+  // Only include claude_session_id if we have a valid one (relay rejects null)
+  const sessionId = result.session_id || currentTask.claude_session_id;
+  if (sessionId) {
+    updates.claude_session_id = sessionId;
+  }
+
   const response = await fetch(
     `${relayApiUrl}/api/sessions/${session_id}/tasks/${task_id}`,
     {
@@ -205,7 +319,8 @@ async function updateTaskAfterTurn(task_id, session_id, result, currentTask, con
   );
 
   if (!response.ok) {
-    throw new Error(`Failed to update task: ${response.status}`);
+    const body = await response.text().catch(() => '');
+    throw new Error(`Failed to update task: ${response.status} ${body}`);
   }
 
   return await response.json();
@@ -241,6 +356,13 @@ async function executeClaudeHeadless(options) {
     args.push('--output-format', 'stream-json');
     args.push('--verbose');
 
+    // Permission mode: configurable per-task or via config
+    // Default: no override (uses hooks → approvals show on mobile UI)
+    // User can set bypass to skip approvals for trusted tasks
+    if (options.bypassPermissions) {
+      args.push('--permission-mode', 'bypassPermissions');
+    }
+
     // Budget control
     if (budgetUsd > 0) {
       args.push('--max-budget-usd', budgetUsd.toFixed(2));
@@ -248,21 +370,25 @@ async function executeClaudeHeadless(options) {
 
     console.log(`[task-v2] Executing: ${CLAUDE_CLI} ${args.join(' ')}`);
 
+    // Build child env: unset CLAUDECODE to allow nested Claude launches
+    const childEnv = {
+      ...process.env,
+      CI: 'true',
+      TELEPORTATION_TASK_MODE: 'true',
+      // Route approvals to parent session timeline
+      ...(parentSessionId && { TELEPORTATION_PARENT_SESSION_ID: parentSessionId }),
+    };
+    delete childEnv.CLAUDECODE;
+
     const proc = spawn(CLAUDE_CLI, args, {
       cwd,
       stdio: 'pipe',
-      env: {
-        ...process.env,
-        CI: 'true',
-        TELEPORTATION_TASK_MODE: 'true',
-        // Route approvals to parent session timeline
-        ...(parentSessionId && { TELEPORTATION_PARENT_SESSION_ID: parentSessionId }),
-      },
+      env: childEnv,
     });
 
-    // Track process for stop functionality
+    // Track process for stop functionality (includes session_id for per-session filtering)
     if (taskId) {
-      runningProcesses.set(taskId, proc);
+      runningProcesses.set(taskId, { proc, session_id: parentSessionId });
     }
 
     // Close stdin
@@ -279,6 +405,7 @@ async function executeClaudeHeadless(options) {
       exit_code: 0,
       session_id: null,
       cost_usd: 0,
+      _costExplicitlySet: false, // Track if total_cost_usd was found
       usage: {
         input_tokens: 0,
         output_tokens: 0,
@@ -311,8 +438,18 @@ async function executeClaudeHeadless(options) {
           }
 
           // Extract cost and usage
+          // stream-json 'result' event has total_cost_usd at top level
+          // e.g. {"type":"result","total_cost_usd":0.72,"usage":{...}}
+          if (event.total_cost_usd != null) {
+            result.cost_usd = event.total_cost_usd;
+            result._costExplicitlySet = true;
+          }
           if (event.usage) {
-            result.cost_usd = event.usage.total_cost || 0;
+            // Fallback: older format had usage.total_cost
+            // Only use fallback if total_cost_usd was never found (not just zero)
+            if (!result._costExplicitlySet && event.usage.total_cost) {
+              result.cost_usd = event.usage.total_cost;
+            }
             result.usage = event.usage;
           }
         } catch (e) {
@@ -337,6 +474,10 @@ async function executeClaudeHeadless(options) {
       result.error = stderr;
       result.success = code === 0;
 
+      if (!result._costExplicitlySet && result.cost_usd === 0 && code === 0) {
+        console.warn(`[task-v2] No cost data found in stream-json output`);
+      }
+
       resolve(result);
     });
 
@@ -356,19 +497,57 @@ async function executeClaudeHeadless(options) {
  * Stop a running task
  */
 export function stopTask(task_id) {
-  const proc = runningProcesses.get(task_id);
-  if (proc) {
+  const entry = runningProcesses.get(task_id);
+  if (entry) {
+    // All entries are {proc, session_id} objects (set in executeClaudeHeadless)
+    const proc = entry.proc;
+    // If process already exited, no need to kill or set timer
+    if (proc.exitCode !== null) {
+      runningProcesses.delete(task_id);
+      return true;
+    }
     proc.kill('SIGTERM');
-    setTimeout(() => {
+    const killTimer = setTimeout(() => {
       if (runningProcesses.has(task_id)) {
-        proc.kill('SIGKILL');
+        try { proc.kill('SIGKILL'); } catch {}
       }
     }, 2000);
+    proc.once('exit', () => clearTimeout(killTimer));
     return true;
   }
   return false;
 }
 
+/**
+ * Stop all running tasks for a specific session
+ * Returns number of processes killed
+ */
+export function stopTasksForSession(session_id) {
+  let killed = 0;
+  for (const [task_id, entry] of runningProcesses) {
+    if (entry.session_id !== session_id) continue;
+    const proc = entry.proc;
+    if (proc.exitCode !== null) {
+      runningProcesses.delete(task_id);
+      continue;
+    }
+    try {
+      proc.kill('SIGTERM');
+      const killTimer = setTimeout(() => {
+        try { proc.kill('SIGKILL'); } catch {}
+      }, 2000);
+      proc.once('exit', () => {
+        clearTimeout(killTimer);
+        runningProcesses.delete(task_id);
+      });
+      killed++;
+    } catch (err) {
+      // Process may already be dead
+    }
+  }
+  return killed;
+}
+
 /**
  * Stop all running tasks
  * Used during daemon shutdown to ensure clean exit
@@ -376,8 +555,10 @@ export function stopTask(task_id) {
 export function stopAllTasks() {
   console.log(`[task-v2] Stopping all tasks (${runningProcesses.size} processes active)`);
 
-  for (const [task_id, proc] of runningProcesses) {
+  for (const [task_id, entry] of runningProcesses) {
     try {
+      // All entries are {proc, session_id} objects (set in executeClaudeHeadless)
+      const proc = entry.proc;
       let killTimer = null;
 
       // Setup exit handler to clear timer

package/lib/daemon/teleportation-daemon.js

@@ -54,6 +54,7 @@ import {
   executeTaskTurn,
   stopTask,
   stopAllTasks,
+  stopTasksForSession,
 } from './task-executor-v2.js';
 
 // Transcript ingestion for timeline completeness
@@ -1144,6 +1145,67 @@ async function handleInboxMessage(session_id, message) {
         return;
       }
 
+      // Check for paused tasks — route message to task instead of spawning new process.
+      // This adds one relay round-trip per inbox message, but only fires for 'command' type
+      // messages (user-initiated from mobile), not for auto-continue or approval messages.
+      // Future optimization: include paused task info in the session polling response.
+      try {
+        const tasksResp = await fetch(
+          `${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/tasks`,
+          { headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }, signal: AbortSignal.timeout(5000) }
+        );
+        if (tasksResp.ok) {
+          const tasks = await tasksResp.json();
+          const pausedTasks = tasks.filter(t => t.status === 'paused' || t.status === 'waiting_input');
+          if (pausedTasks.length > 1) {
+            logWarn(`[daemon] ⚠️  Multiple paused tasks (${pausedTasks.length}) for session ${session_id} — routing to first`);
+          }
+          const pausedTask = pausedTasks[0];
+          if (pausedTask) {
+            logInfo(`[daemon] 📨 Routing message to paused task ${pausedTask.id.slice(0, 20)}... (status: ${pausedTask.status})`);
+
+            let routeResp;
+            if (pausedTask.status === 'waiting_input') {
+              // Task is waiting for user input — use the answer endpoint
+              routeResp = await fetch(
+                `${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/tasks/${encodeURIComponent(pausedTask.id)}/answer`,
+                {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${RELAY_API_KEY}` },
+                  body: JSON.stringify({ answer: commandText })
+                }
+              );
+            } else {
+              // Task is paused — use redirect to set new instructions and resume
+              routeResp = await fetch(
+                `${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/tasks/${encodeURIComponent(pausedTask.id)}/redirect`,
+                {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${RELAY_API_KEY}` },
+                  body: JSON.stringify({ instruction: commandText })
+                }
+              );
+            }
+
+            if (routeResp.ok) {
+              logInfo(`[daemon] ✅ Message routed to task, will resume on next poll cycle`);
+              // Acknowledge the inbox message
+              await fetch(`${RELAY_API_URL}/api/messages/${encodeURIComponent(message.id)}/ack`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${RELAY_API_KEY}` },
+                body: JSON.stringify({ session_id })
+              }).catch(() => {});
+              return; // Don't spawn a new process
+            }
+            // If route failed (e.g. wrong status), fall through to normal execution
+            logWarn(`[daemon] Failed to route message to task (${routeResp.status}), falling back to normal execution`);
+          }
+        }
+      } catch (taskCheckError) {
+        // Non-critical — fall through to normal execution
+        logWarn(`[daemon] Task check failed: ${taskCheckError.message}`);
+      }
+
       // Invalidate pending approvals BEFORE executing new command
       // This prevents race conditions where stale approvals could be acted upon
       try {
@@ -1494,6 +1556,77 @@ async function pollRelayAPI() {
       // Update activity timestamp for cleanup tracking
       sessionActivity.set(session_id, Date.now());
 
+      // 0) Check for stop_requested flag (mobile stop button)
+      // Uses daemon-state endpoint (lightweight) instead of full session fetch
+      try {
+        const stopCheckResponse = await fetch(
+          `${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/daemon-state`,
+          {
+            headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` },
+            signal: AbortSignal.timeout(5000)
+          }
+        );
+
+        if (stopCheckResponse.ok) {
+          const daemonState = await stopCheckResponse.json();
+
+          if (daemonState.stop_requested) {
+            logInfo(`[daemon] 🛑 Stop requested for session ${session_id} — killing running processes`);
+
+            // Kill any running approval execution processes for this session
+            let killedExecution = false;
+            for (const [approval_id, exec] of executions) {
+              if (exec.session_id === session_id && exec.status === 'executing' && exec.child_process) {
+                try {
+                  const child = exec.child_process;
+                  child.kill('SIGTERM');
+                  // Track SIGKILL timer so it can be cancelled if process exits cleanly
+                  const killTimer = setTimeout(() => {
+                    try { child.kill('SIGKILL'); } catch {}
+                  }, 2000);
+                  child.once('exit', () => clearTimeout(killTimer));
+                  killedExecution = true;
+                  logInfo(`[daemon] Killed execution process for approval ${approval_id}`);
+                } catch (killErr) {
+                  logWarn(`[daemon] Failed to kill execution ${approval_id}: ${killErr.message}`);
+                }
+              }
+            }
+
+            // Kill any running task processes for this session
+            const killedTaskCount = stopTasksForSession(session_id);
+            const killedTask = killedTaskCount > 0;
+            if (killedTask) {
+              logInfo(`[daemon] Killed ${killedTaskCount} task process(es) for session ${session_id}`);
+            }
+
+            // Clear stop_requested flag
+            try {
+              await fetch(`${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/daemon-state`, {
+                method: 'PATCH',
+                headers: {
+                  'Content-Type': 'application/json',
+                  'Authorization': `Bearer ${RELAY_API_KEY}`
+                },
+                body: JSON.stringify({ stop_requested: false })
+              });
+              logInfo(`[daemon] Cleared stop_requested flag for session ${session_id}`);
+            } catch (clearErr) {
+              logWarn(`[daemon] Failed to clear stop_requested: ${clearErr.message}`);
+            }
+
+            if (!killedExecution && !killedTask) {
+              logInfo(`[daemon] No running processes found to stop for session ${session_id}`);
+            }
+          }
+        }
+      } catch (stopCheckError) {
+        // Don't block polling if stop check fails
+        if (stopCheckError.name !== 'AbortError') {
+          logWarn(`[daemon] Stop check error for ${session_id}: ${stopCheckError.message}`);
+        }
+      }
+
       // 1) Approvals polling (existing behavior)
       try {
         const response = await fetch(
@@ -1603,8 +1736,8 @@ async function pollRelayAPI() {
 
           // Process each task (stateless - queries timeline each time)
           for (const task of tasks) {
-            // Skip stopped/completed tasks
-            if (task.status === 'stopped' || task.status === 'completed') {
+            // Skip non-runnable tasks (paused tasks wait for user message to resume)
+            if (task.status === 'stopped' || task.status === 'completed' || task.status === 'paused') {
               continue;
             }
 
@@ -1643,11 +1776,21 @@ async function pollRelayAPI() {
       const claude_session_id = sessionData.claude_session_id || session_id;
       const cwd = sessionData.cwd || process.cwd();
 
+      // 4) Heartbeat - send periodically to keep session alive
+      // Must run before ingestion throttle check — ingestion `continue` must not skip heartbeats
+      const now = Date.now();
+      const sessionHeartbeat = heartbeatState.get(session_id);
+      const lastSent = sessionHeartbeat?.lastSent || 0;
+      if (now - lastSent >= SESSION_HEARTBEAT_INTERVAL_MS) {
+        await sendHeartbeat(session_id);
+      }
+
+      // 5) Transcript ingestion - backup to stop hook for timeline completeness
       // Throttling: Check if ingestion is already in progress for this session
       // Prevents concurrent ingestion runs that could cause race conditions
       if (ingestionInProgress.has(session_id)) {
         debugLog('daemon-transcript-debug.log', `Ingestion already in progress for ${session_id}, skipping`);
-        // Skip this polling cycle for this session
+        // Skip ingestion this cycle (heartbeat already sent above)
         continue;
       }
 
@@ -1680,15 +1823,6 @@ async function pollRelayAPI() {
 
       // Track the promise (but don't await - fire-and-forget)
       ingestionInProgress.set(session_id, ingestionPromise);
-
-      // 5) Heartbeat - send periodically to keep session alive
-      // Only send heartbeat if enough time has passed since last one (throttled per session)
-      const now = Date.now();
-      const sessionHeartbeat = heartbeatState.get(session_id);
-      const lastSent = sessionHeartbeat?.lastSent || 0;
-      if (now - lastSent >= SESSION_HEARTBEAT_INTERVAL_MS) {
-        await sendHeartbeat(session_id);
-      }
     }
 
     // Process approval queue
@@ -1823,6 +1957,7 @@ async function processQueue() {
   // Mark as executing (child_process will be set when spawnClaudeProcess is called)
   executions.set(approval_id, {
     approval_id,
+    session_id,
     status: 'executing',
     started_at: Date.now(),
     completed_at: null,
@@ -2890,6 +3025,41 @@ async function main() {
           });
           if (!hbResponse.ok) {
             const errMsg = `HTTP ${hbResponse.status}`;
+
+            // 404 means session expired from Redis — try to re-register it.
+            // The relay heartbeat endpoint also attempts recovery from mech-storage,
+            // but if that fails (e.g., session never persisted), daemon-side re-registration
+            // ensures the session is recreated with correct metadata.
+            if (hbResponse.status === 404) {
+              const sessionData = sessions.get(sessionId);
+              try {
+                const regResponse = await fetch(`${RELAY_API_URL}/api/sessions/register`, {
+                  method: 'POST',
+                  headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${RELAY_API_KEY}`
+                  },
+                  body: JSON.stringify({
+                    session_id: sessionId,
+                    claude_session_id: sessionData?.claude_session_id || undefined,
+                    cwd: sessionData?.cwd || process.cwd(),
+                    meta: sessionData?.meta || {}
+                  }),
+                  signal: AbortSignal.timeout(5000)
+                });
+                if (regResponse.ok) {
+                  console.log(`[daemon] Re-registered expired session ${sessionId} after heartbeat 404`);
+                  // Clear failure tracking so next heartbeat is treated fresh
+                  heartbeatFailureLogged.delete(sessionId);
+                  continue; // Skip failure logging — session recovered
+                } else {
+                  console.warn(`[daemon] Failed to re-register session ${sessionId}: HTTP ${regResponse.status}`);
+                }
+              } catch (regErr) {
+                console.warn(`[daemon] Re-registration attempt failed for ${sessionId}: ${regErr.message}`);
+              }
+            }
+
             if (!heartbeatFailureLogged.has(sessionId)) {
               heartbeatFailureLogged.add(sessionId);
               console.warn(`[daemon] Heartbeat rejected for ${sessionId}: ${errMsg} (further failures for this session suppressed unless DEBUG is set)`);