@masslessai/push-todo 4.1.5 → 4.1.7

package/lib/agent-versions.js

@@ -1,8 +1,9 @@
 /**
- * Agent version detection and tracking for Push daemon.
+ * Agent version detection, tracking, and auto-update for Push daemon.
  *
  * Detects installed versions of Claude Code, OpenAI Codex, and OpenClaw CLIs.
  * Reports version parity with the push-todo CLI and flags outdated agents.
+ * Can auto-update agents via npm when enabled.
  *
  * Pattern: follows heartbeat.js — pure functions, internally throttled, non-fatal.
  */
@@ -11,25 +12,33 @@ import { execFileSync } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { compareSemver } from './self-update.js';
 
 const PUSH_DIR = join(homedir(), '.push');
 const VERSIONS_CACHE_FILE = join(PUSH_DIR, 'agent_versions.json');
+const LAST_AGENT_UPDATE_FILE = join(PUSH_DIR, 'last_agent_update_check');
 const CHECK_INTERVAL = 3600000; // 1 hour
+const AGENT_UPDATE_CHECK_INTERVAL = 3600000; // 1 hour
+const AGENT_VERSION_AGE_GATE = 3600000; // 1 hour — only install versions >1hr old
 
 // ==================== Agent Definitions ====================
 
 /**
- * Agent CLI definitions: command name, version flag, and how to parse output.
+ * Agent CLI definitions: command name, version flag, npm package, and how to parse output.
  *
  * Each agent has:
  * - cmd: the CLI binary name
  * - versionArgs: args to get version string
+ * - npmPackage: the npm package name for install/update
  * - parseVersion: extracts semver from command output
+ * - minVersion: minimum version required for push-todo compatibility (null = no minimum)
  */
 const AGENTS = {
   'claude-code': {
     cmd: 'claude',
     versionArgs: ['--version'],
+    npmPackage: '@anthropic-ai/claude-code',
+    minVersion: '2.0.0', // --worktree support
     parseVersion(output) {
       // "claude v2.1.41" or just "2.1.41"
       const match = output.match(/(\d+\.\d+\.\d+)/);
@@ -39,6 +48,8 @@ const AGENTS = {
   'openai-codex': {
     cmd: 'codex',
     versionArgs: ['--version'],
+    npmPackage: '@openai/codex',
+    minVersion: null,
     parseVersion(output) {
       const match = output.match(/(\d+\.\d+\.\d+)/);
       return match ? match[1] : null;
@@ -47,6 +58,8 @@ const AGENTS = {
   'openclaw': {
     cmd: 'openclaw',
     versionArgs: ['--version'],
+    npmPackage: 'openclaw',
+    minVersion: null,
     parseVersion(output) {
       const match = output.match(/(\d+\.\d+\.\d+)/);
       return match ? match[1] : null;
@@ -202,3 +215,147 @@ export function formatAgentVersionSummary(versions) {
 export function getKnownAgentTypes() {
   return Object.keys(AGENTS);
 }
+
+// ==================== Agent Update ====================
+
+/**
+ * Fetch latest version info for an agent from npm.
+ *
+ * @param {string} agentType
+ * @returns {{ version: string, publishedAt: string|null }|null}
+ */
+function fetchLatestAgentVersion(agentType) {
+  const agent = AGENTS[agentType];
+  if (!agent?.npmPackage) return null;
+
+  try {
+    const result = execFileSync('npm', ['view', agent.npmPackage, '--json'], {
+      timeout: 15000,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const data = JSON.parse(result);
+    const latest = data['dist-tags']?.latest || data.version;
+    return {
+      version: latest,
+      publishedAt: data.time?.[latest] || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if an agent has an update available.
+ *
+ * @param {string} agentType
+ * @returns {{ available: boolean, current: string|null, latest: string|null, reason: string }}
+ */
+export function checkForAgentUpdate(agentType) {
+  const currentInfo = detectAgentVersion(agentType);
+  if (!currentInfo.installed || !currentInfo.version) {
+    return { available: false, current: null, latest: null, reason: 'not_installed' };
+  }
+
+  const latestInfo = fetchLatestAgentVersion(agentType);
+  if (!latestInfo) {
+    return { available: false, current: currentInfo.version, latest: null, reason: 'registry_unreachable' };
+  }
+
+  if (compareSemver(currentInfo.version, latestInfo.version) >= 0) {
+    return { available: false, current: currentInfo.version, latest: latestInfo.version, reason: 'up_to_date' };
+  }
+
+  // Safety: only update to versions published >1 hour ago
+  if (latestInfo.publishedAt) {
+    const publishedAge = Date.now() - new Date(latestInfo.publishedAt).getTime();
+    if (publishedAge < AGENT_VERSION_AGE_GATE) {
+      return { available: false, current: currentInfo.version, latest: latestInfo.version, reason: 'too_recent' };
+    }
+  }
+
+  return { available: true, current: currentInfo.version, latest: latestInfo.version, reason: 'update_available' };
+}
+
+/**
+ * Install a specific version of an agent CLI globally.
+ *
+ * @param {string} agentType
+ * @param {string} targetVersion
+ * @returns {boolean} true if update succeeded
+ */
+export function performAgentUpdate(agentType, targetVersion) {
+  const agent = AGENTS[agentType];
+  if (!agent?.npmPackage) return false;
+
+  try {
+    execFileSync('npm', ['install', '-g', `${agent.npmPackage}@${targetVersion}`], {
+      timeout: 120000,
+      stdio: 'pipe',
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check all installed agents for updates (throttled).
+ * Returns update results or null if throttled.
+ *
+ * @param {{ force?: boolean }} options
+ * @returns {Object.<string, { available: boolean, current: string|null, latest: string|null, reason: string }>|null}
+ */
+export function checkAllAgentUpdates({ force = false } = {}) {
+  // Throttle check
+  if (!force && existsSync(LAST_AGENT_UPDATE_FILE)) {
+    try {
+      const lastCheck = parseInt(readFileSync(LAST_AGENT_UPDATE_FILE, 'utf8').trim(), 10);
+      if (Date.now() - lastCheck < AGENT_UPDATE_CHECK_INTERVAL) {
+        return null;
+      }
+    } catch {}
+  }
+
+  // Record check time
+  try {
+    mkdirSync(PUSH_DIR, { recursive: true });
+    writeFileSync(LAST_AGENT_UPDATE_FILE, String(Date.now()));
+  } catch {}
+
+  const results = {};
+  for (const agentType of Object.keys(AGENTS)) {
+    const info = detectAgentVersion(agentType);
+    if (info.installed) {
+      results[agentType] = checkForAgentUpdate(agentType);
+    }
+  }
+  return results;
+}
+
+// ==================== Version Parity ====================
+
+/**
+ * Check version parity between installed agents and push-todo requirements.
+ * Returns warnings for agents that are below minimum required versions.
+ *
+ * @returns {{ agentType: string, installed: string, required: string }[]}
+ */
+export function checkVersionParity() {
+  const warnings = [];
+  for (const [agentType, agent] of Object.entries(AGENTS)) {
+    if (!agent.minVersion) continue;
+
+    const info = detectAgentVersion(agentType);
+    if (info.installed && info.version) {
+      if (compareSemver(info.version, agent.minVersion) < 0) {
+        warnings.push({
+          agentType,
+          installed: info.version,
+          required: agent.minVersion,
+        });
+      }
+    }
+  }
+  return warnings;
+}

package/lib/config.js

@@ -213,6 +213,27 @@ export function setAutoUpdateEnabled(enabled) {
   return setConfigValue('AUTO_UPDATE', enabled ? 'true' : 'false');
 }
 
+/**
+ * Check if auto-update-agents is enabled for daemon agent CLI updates.
+ * Default: false (agent updates are opt-in since they're third-party CLIs)
+ *
+ * @returns {boolean}
+ */
+export function getAutoUpdateAgentsEnabled() {
+  const value = getConfigValue('AUTO_UPDATE_AGENTS', 'false');
+  return value.toLowerCase() === 'true' || value === '1' || value.toLowerCase() === 'yes';
+}
+
+/**
+ * Set auto-update-agents setting.
+ *
+ * @param {boolean} enabled
+ * @returns {boolean} True if successful
+ */
+export function setAutoUpdateAgentsEnabled(enabled) {
+  return setConfigValue('AUTO_UPDATE_AGENTS', enabled ? 'true' : 'false');
+}
+
 /**
  * Get the maximum batch size for queuing tasks.
  * Default: 5
@@ -292,6 +313,7 @@ export function showSettings() {
   const autoMerge = getAutoMergeEnabled();
   const autoComplete = getAutoCompleteEnabled();
   const autoUpdate = getAutoUpdateEnabled();
+  const autoUpdateAgents = getAutoUpdateAgentsEnabled();
   const batchSize = getMaxBatchSize();
 
   console.log(`  auto-commit:    ${autoCommit ? 'ON' : 'OFF'}`);
@@ -304,7 +326,10 @@ export function showSettings() {
   console.log('                  Mark task completed after successful merge');
   console.log();
   console.log(`  auto-update:    ${autoUpdate ? 'ON' : 'OFF'}`);
-  console.log('                  Daemon auto-updates from npm when idle');
+  console.log('                  Daemon auto-updates push-todo from npm when idle');
+  console.log();
+  console.log(`  auto-update-agents: ${autoUpdateAgents ? 'ON' : 'OFF'}`);
+  console.log('                  Daemon auto-updates agent CLIs (Claude, Codex, OpenClaw)');
   console.log();
   console.log(`  batch-size:     ${batchSize}`);
   console.log('                  Max tasks for batch queue (1-20)');
@@ -387,6 +412,22 @@ export function toggleSetting(settingName) {
     return false;
   }
 
+  if (normalized === 'auto-update-agents') {
+    const current = getAutoUpdateAgentsEnabled();
+    const newValue = !current;
+    if (setAutoUpdateAgentsEnabled(newValue)) {
+      console.log(`Auto-update-agents is now ${newValue ? 'ON' : 'OFF'}`);
+      if (newValue) {
+        console.log('Daemon will auto-update agent CLIs (Claude Code, Codex, OpenClaw) when idle.');
+      } else {
+        console.log('Agent CLIs will NOT be auto-updated. Use "push-todo update" for manual updates.');
+      }
+      return true;
+    }
+    console.error('Failed to update setting');
+    return false;
+  }
+
   if (normalized === 'batch-size') {
     const batchSize = getMaxBatchSize();
     console.log(`Current batch size: ${batchSize}`);
@@ -395,7 +436,7 @@ export function toggleSetting(settingName) {
   }
 
   console.error(`Unknown setting: ${settingName}`);
-  console.error('Available settings: auto-commit, auto-merge, auto-complete, auto-update, batch-size');
+  console.error('Available settings: auto-commit, auto-merge, auto-complete, auto-update, auto-update-agents, batch-size');
   return false;
 }
 

package/lib/daemon.js

@@ -25,7 +25,7 @@ import { getProjectContext, buildSmartPrompt, invalidateCache } from './context-
 import { sendMacNotification } from './utils/notify.js';
 import { checkAndRunDueJobs } from './cron.js';
 import { runHeartbeatChecks } from './heartbeat.js';
-import { getAgentVersions, formatAgentVersionSummary } from './agent-versions.js';
+import { getAgentVersions, formatAgentVersionSummary, checkAllAgentUpdates, performAgentUpdate, checkVersionParity } from './agent-versions.js';
 import { checkAllProjectsFreshness } from './project-freshness.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -115,6 +115,12 @@ const taskStdoutBuffer = new Map(); // displayNumber -> lines[]
 const taskStderrBuffer = new Map(); // displayNumber -> lines[]
 const taskProjectPaths = new Map(); // displayNumber -> projectPath
 const taskLastHeartbeat = new Map(); // displayNumber -> timestamp of last progress heartbeat
+
+// Stream-json state (Phase 1: real-time progress)
+const taskStreamLineBuffer = new Map(); // displayNumber -> partial NDJSON line fragment
+const taskActivityState = new Map(); // displayNumber -> { filesRead: Set, filesEdited: Set, currentTool: string, lastText: string }
+const taskLastStreamProgress = new Map(); // displayNumber -> timestamp of last stream progress sent
+const STREAM_PROGRESS_THROTTLE_MS = 30000; // 30s between stream progress updates to Supabase
 let daemonStartTime = null;
 
 // ==================== Utilities ====================
@@ -282,6 +288,11 @@ function getAutoUpdateEnabled() {
   return v.toLowerCase() === 'true' || v === '1' || v.toLowerCase() === 'yes';
 }
 
+function getAutoUpdateAgentsEnabled() {
+  const v = getConfigValueFromFile('AUTO_UPDATE_AGENTS', 'false');
+  return v.toLowerCase() === 'true' || v === '1' || v.toLowerCase() === 'yes';
+}
+
 // ==================== Capabilities Detection ====================
 
 let cachedCapabilities = null;
@@ -1327,6 +1338,155 @@ function checkStuckPatterns(displayNumber, line) {
   return null;
 }
 
+// ==================== Stream-JSON Parsing (Phase 1) ====================
+
+function parseStreamJsonLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith('{')) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+function extractTextFromContent(content) {
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter(block => block.type === 'text' && block.text)
+    .map(block => block.text)
+    .join('\n');
+}
+
+function extractToolCallsFromContent(content) {
+  if (!Array.isArray(content)) return [];
+  return content
+    .filter(block => block.type === 'tool_use')
+    .map(block => ({ name: block.name, input: block.input || {} }));
+}
+
+function processStreamEvent(displayNumber, event) {
+  if (!event || !event.type) return;
+
+  const activity = taskActivityState.get(displayNumber) || {
+    filesRead: new Set(),
+    filesEdited: new Set(),
+    currentTool: null,
+    lastText: '',
+    sessionId: null
+  };
+
+  // Extract session_id from system init or result messages
+  if (event.type === 'system' && event.session_id) {
+    activity.sessionId = event.session_id;
+  }
+  if (event.type === 'result' && event.session_id) {
+    activity.sessionId = event.session_id;
+  }
+
+  // Extract activity from assistant messages
+  if (event.type === 'assistant') {
+    const content = event.message?.content;
+    if (!content) { taskActivityState.set(displayNumber, activity); return; }
+
+    const text = extractTextFromContent(content);
+    if (text) {
+      activity.lastText = text.slice(0, 200);
+
+      // Run existing text-based checks on extracted content
+      if (text.includes('[push-confirm] Waiting for')) {
+        updateTaskDetail(displayNumber, {
+          phase: 'awaiting_confirmation',
+          detail: 'Waiting for user confirmation on iPhone'
+        });
+      }
+
+      const stuckReason = checkStuckPatterns(displayNumber, text);
+      if (stuckReason) {
+        log(`Task #${displayNumber} may be stuck: ${stuckReason}`);
+        updateTaskDetail(displayNumber, {
+          phase: 'stuck',
+          detail: `Waiting for input: ${stuckReason}`
+        });
+      }
+    }
+
+    const toolCalls = extractToolCallsFromContent(content);
+    for (const tool of toolCalls) {
+      activity.currentTool = tool.name;
+      const filePath = tool.input?.file_path || tool.input?.path;
+      if (filePath) {
+        if (tool.name === 'Read') {
+          activity.filesRead.add(filePath);
+        } else if (tool.name === 'Edit' || tool.name === 'Write') {
+          activity.filesEdited.add(filePath);
+        }
+      }
+    }
+  }
+
+  taskActivityState.set(displayNumber, activity);
+
+  // Throttled progress reporting to Supabase
+  maybesSendStreamProgress(displayNumber, activity);
+}
+
+function maybesSendStreamProgress(displayNumber, activity) {
+  const now = Date.now();
+  const lastSent = taskLastStreamProgress.get(displayNumber) || 0;
+  if (now - lastSent < STREAM_PROGRESS_THROTTLE_MS) return;
+  taskLastStreamProgress.set(displayNumber, now);
+
+  const info = taskDetails.get(displayNumber) || {};
+  const taskId = info.taskId || null;
+  const taskInfo = runningTasks.get(displayNumber);
+  if (!taskInfo) return;
+
+  const elapsedSec = Math.floor((now - taskInfo.startTime) / 1000);
+  const elapsedMin = Math.floor(elapsedSec / 60);
+
+  // Build a meaningful summary from stream activity
+  const parts = [`Running for ${elapsedMin}m.`];
+  if (activity.filesEdited.size > 0) {
+    const editedList = [...activity.filesEdited].map(f => f.split('/').pop()).slice(-5);
+    parts.push(`Edited: ${editedList.join(', ')}`);
+  }
+  if (activity.filesRead.size > 0) {
+    parts.push(`Read ${activity.filesRead.size} files.`);
+  }
+  if (activity.currentTool) {
+    parts.push(`Current: ${activity.currentTool}`);
+  }
+  if (activity.lastText && !activity.currentTool) {
+    parts.push(activity.lastText.slice(0, 80));
+  }
+
+  const eventSummary = parts.join(' ');
+
+  log(`Task #${displayNumber}: stream progress (${eventSummary})`);
+
+  // Also update the existing heartbeat timestamp to prevent duplicate generic heartbeats
+  taskLastHeartbeat.set(displayNumber, now);
+
+  apiRequest('update-task-execution', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      todoId: taskId,
+      displayNumber,
+      event: {
+        type: 'progress',
+        timestamp: new Date().toISOString(),
+        machineName: getMachineName() || undefined,
+        summary: eventSummary,
+        filesEdited: [...activity.filesEdited].slice(-10),
+        filesRead: activity.filesRead.size
+      }
+    })
+  }).catch(err => {
+    log(`Task #${displayNumber}: stream progress failed (non-fatal): ${err.message}`);
+  });
+}
+
 function monitorTaskStdout(displayNumber, proc) {
   if (!proc.stdout) return;
 
@@ -1424,7 +1584,23 @@ async function sendProgressHeartbeats() {
 
     const activityDesc = idleSec < 60 ? 'active' : `idle ${idleMin}m`;
     const phase = info.phase || 'executing';
-    const eventSummary = `Running for ${elapsedMin}m. Last activity: ${activityDesc}. Phase: ${phase}.`;
+
+    // Enrich heartbeat with stream activity data when available
+    const activity = taskActivityState.get(displayNumber);
+    const parts = [`Running for ${elapsedMin}m. Last activity: ${activityDesc}. Phase: ${phase}.`];
+    const eventExtra = {};
+    if (activity) {
+      if (activity.filesEdited.size > 0) {
+        const editedList = [...activity.filesEdited].map(f => f.split('/').pop()).slice(-5);
+        parts.push(`Edited: ${editedList.join(', ')}`);
+        eventExtra.filesEdited = [...activity.filesEdited].slice(-10);
+      }
+      if (activity.filesRead.size > 0) {
+        parts.push(`Read ${activity.filesRead.size} files.`);
+        eventExtra.filesRead = activity.filesRead.size;
+      }
+    }
+    const eventSummary = parts.join(' ');
 
     log(`Task #${displayNumber}: sending progress heartbeat (${eventSummary})`);
 
@@ -1442,7 +1618,8 @@ async function sendProgressHeartbeats() {
           type: 'progress',
           timestamp: new Date().toISOString(),
           machineName: getMachineName() || undefined,
-          summary: eventSummary
+          summary: eventSummary,
+          ...eventExtra
         }
         // No status field — event-only update, won't change execution_status
       })
@@ -1538,6 +1715,9 @@ async function killIdleTasks() {
     taskStderrBuffer.delete(displayNumber);
     taskProjectPaths.delete(displayNumber);
     taskLastHeartbeat.delete(displayNumber);
+    taskStreamLineBuffer.delete(displayNumber);
+    taskActivityState.delete(displayNumber);
+    taskLastStreamProgress.delete(displayNumber);
   }
 
   if (idleTimedOut.length > 0) {
@@ -1547,7 +1727,14 @@ async function killIdleTasks() {
 
 // ==================== Session ID Extraction ====================
 
-function extractSessionIdFromStdout(proc, buffer) {
+function extractSessionIdFromStdout(proc, buffer, displayNumber) {
+  // First: check stream activity state (populated by stream-json parsing)
+  if (displayNumber != null) {
+    const activity = taskActivityState.get(displayNumber);
+    if (activity?.sessionId) return activity.sessionId;
+  }
+
+  // Fallback: drain remaining stdout and scan for session_id in JSON lines
   let remaining = '';
   if (proc.stdout) {
     try {
@@ -1557,7 +1744,6 @@ function extractSessionIdFromStdout(proc, buffer) {
 
   const allOutput = buffer.join('\n') + '\n' + remaining;
 
-  // Try to parse JSON output
   for (const line of allOutput.split('\n')) {
     const trimmed = line.trim();
     if (trimmed.startsWith('{') && trimmed.includes('session_id')) {
@@ -1822,14 +2008,14 @@ async function executeTask(task) {
         '--continue', previousSessionId,
         '-p', prompt,
         '--allowedTools', allowedTools,
-        '--output-format', 'json',
+        '--output-format', 'stream-json',
         '--permission-mode', 'bypassPermissions',
         '--session-id', preAssignedSessionId
       ]
     : [
         '-p', prompt,
         '--allowedTools', allowedTools,
-        '--output-format', 'json',
+        '--output-format', 'stream-json',
         '--permission-mode', 'bypassPermissions',
         '--session-id', preAssignedSessionId
       ];
@@ -1878,25 +2064,44 @@ async function executeTask(task) {
       }
     });
 
-    // Monitor stdout
+    // Monitor stdout (stream-json NDJSON parsing)
+    taskStreamLineBuffer.set(displayNumber, '');
+    taskActivityState.set(displayNumber, {
+      filesRead: new Set(), filesEdited: new Set(),
+      currentTool: null, lastText: '', sessionId: null
+    });
+    taskLastStreamProgress.set(displayNumber, Date.now());
+
     child.stdout.on('data', (data) => {
-      const lines = data.toString().split('\n');
+      taskLastOutput.set(displayNumber, Date.now());
+
+      // NDJSON line buffering: handle chunks that split across line boundaries
+      const pending = (taskStreamLineBuffer.get(displayNumber) || '') + data.toString();
+      const lines = pending.split('\n');
+      // Last element is either empty (chunk ended with \n) or a partial line
+      taskStreamLineBuffer.set(displayNumber, lines.pop() || '');
+
       for (const line of lines) {
-        if (line.trim()) {
-          taskLastOutput.set(displayNumber, Date.now());
-          const buffer = taskStdoutBuffer.get(displayNumber) || [];
-          buffer.push(line);
-          if (buffer.length > 20) buffer.shift();
-          taskStdoutBuffer.set(displayNumber, buffer);
+        if (!line.trim()) continue;
 
-          // Detect confirmation waiting (exempt from timeouts)
+        // Keep raw lines in circular buffer for debugging/fallback
+        const buffer = taskStdoutBuffer.get(displayNumber) || [];
+        buffer.push(line);
+        if (buffer.length > 50) buffer.shift();
+        taskStdoutBuffer.set(displayNumber, buffer);
+
+        // Parse as NDJSON stream event
+        const event = parseStreamJsonLine(line);
+        if (event) {
+          processStreamEvent(displayNumber, event);
+        } else {
+          // Fallback: line isn't valid JSON — run legacy text checks
           if (line.includes('[push-confirm] Waiting for')) {
             updateTaskDetail(displayNumber, {
               phase: 'awaiting_confirmation',
               detail: 'Waiting for user confirmation on iPhone'
             });
           }
-
           const stuckReason = checkStuckPatterns(displayNumber, line);
           if (stuckReason) {
             log(`Task #${displayNumber} may be stuck: ${stuckReason}`);
@@ -1920,6 +2125,9 @@ async function executeTask(task) {
       await updateTaskStatus(displayNumber, 'failed', { error: error.message }, taskId);
       taskDetails.delete(displayNumber);
       taskLastHeartbeat.delete(displayNumber);
+      taskStreamLineBuffer.delete(displayNumber);
+      taskActivityState.delete(displayNumber);
+      taskLastStreamProgress.delete(displayNumber);
       updateStatusFile();
     });
 
@@ -1936,6 +2144,9 @@ async function executeTask(task) {
     logError(`Error starting Claude for task #${displayNumber}: ${error.message}`);
     await updateTaskStatus(displayNumber, 'failed', { error: error.message }, taskId);
     taskDetails.delete(displayNumber);
+    taskStreamLineBuffer.delete(displayNumber);
+    taskActivityState.delete(displayNumber);
+    taskLastStreamProgress.delete(displayNumber);
     return null;
   }
 }
@@ -1954,7 +2165,7 @@ async function handleTaskCompletion(displayNumber, exitCode) {
   log(`Task #${displayNumber} completed with code ${exitCode} (${duration}s)`);
 
   // Session ID: prefer pre-assigned ID (reliable), fall back to stdout extraction
-  const sessionId = taskInfo.sessionId || extractSessionIdFromStdout(taskInfo.process, taskStdoutBuffer.get(displayNumber) || []);
+  const sessionId = taskInfo.sessionId || extractSessionIdFromStdout(taskInfo.process, taskStdoutBuffer.get(displayNumber) || [], displayNumber);
   const worktreePath = getWorktreePath(displayNumber, projectPath);
   const durationStr = duration < 60 ? `${duration}s` : `${Math.floor(duration / 60)}m ${duration % 60}s`;
   const machineName = getMachineName() || 'Mac';
@@ -2296,6 +2507,9 @@ async function checkTimeouts() {
     taskStderrBuffer.delete(displayNumber);
     taskProjectPaths.delete(displayNumber);
     taskLastHeartbeat.delete(displayNumber);
+    taskStreamLineBuffer.delete(displayNumber);
+    taskActivityState.delete(displayNumber);
+    taskLastStreamProgress.delete(displayNumber);
     cleanupWorktree(displayNumber, projectPath);
   }
 
@@ -2355,6 +2569,55 @@ function checkAndApplyUpdate() {
   }
 }
 
+// ==================== Agent Auto-Update ====================
+
+let pendingAgentUpdates = null; // { agentType: targetVersion, ... }
+
+function checkAndApplyAgentUpdates() {
+  // Check for updates (throttled internally to once per hour)
+  if (!pendingAgentUpdates) {
+    const results = checkAllAgentUpdates();
+    if (!results) return; // throttled
+
+    const available = {};
+    for (const [agentType, info] of Object.entries(results)) {
+      if (info.available) {
+        available[agentType] = info.latest;
+        log(`Agent update available: ${agentType} v${info.current} -> v${info.latest}`);
+      }
+    }
+    if (Object.keys(available).length > 0) {
+      pendingAgentUpdates = available;
+    }
+  }
+
+  // Only apply when no tasks are running
+  if (pendingAgentUpdates && runningTasks.size === 0) {
+    for (const [agentType, targetVersion] of Object.entries(pendingAgentUpdates)) {
+      log(`Updating ${agentType} to v${targetVersion}...`);
+      const success = performAgentUpdate(agentType, targetVersion);
+      if (success) {
+        log(`${agentType} updated to v${targetVersion}`);
+        sendMacNotification(
+          'Push: Agent Updated',
+          `${agentType} updated to v${targetVersion}`,
+          'Glass'
+        );
+      } else {
+        logError(`${agentType} update to v${targetVersion} failed`);
+      }
+    }
+    pendingAgentUpdates = null;
+  }
+}
+
+function logVersionParityWarnings() {
+  const warnings = checkVersionParity();
+  for (const w of warnings) {
+    log(`WARNING: ${w.agentType} v${w.installed} is below minimum v${w.required} — some features may not work`);
+  }
+}
+
 // ==================== Main Loop ====================
 
 async function pollAndExecute() {
@@ -2457,10 +2720,12 @@ async function mainLoop() {
   log(`Max concurrent tasks: ${MAX_CONCURRENT_TASKS}`);
   log(`E2EE: ${e2eeAvailable ? 'Available' : 'Not available'}`);
   log(`Auto-update: ${getAutoUpdateEnabled() ? 'Enabled' : 'Disabled'}`);
+  log(`Auto-update-agents: ${getAutoUpdateAgentsEnabled() ? 'Enabled' : 'Disabled'}`);
   const caps = getCapabilities();
   log(`Capabilities: gh=${caps.gh_cli}, auto-merge=${caps.auto_merge}, auto-complete=${caps.auto_complete}`);
   const agentVersions = getAgentVersions({ force: true });
   log(`Agent versions: ${formatAgentVersionSummary(agentVersions)}`);
+  logVersionParityWarnings();
   log(`Log file: ${LOG_FILE}`);
 
   // Show registered projects
@@ -2559,6 +2824,15 @@ async function mainLoop() {
       if (getAutoUpdateEnabled()) {
         checkAndApplyUpdate();
       }
+
+      // Agent CLI auto-update (throttled to once per hour, only applies when idle)
+      if (getAutoUpdateAgentsEnabled()) {
+        try {
+          checkAndApplyAgentUpdates();
+        } catch (error) {
+          logError(`Agent auto-update error: ${error.message}`);
+        }
+      }
     } catch (error) {
       logError(`Poll error: ${error.message}`);
     }

package/lib/self-update.js

@@ -17,12 +17,16 @@ const LAST_UPDATE_CHECK_FILE = join(PUSH_DIR, 'last_update_check');
 const UPDATE_CHECK_INTERVAL = 3600000; // 1 hour
 
 /**
- * Compare semver strings.
+ * Compare semver strings (strips pre-release/build metadata before comparing).
+ * Handles formats like "2.1.41", "2026.2.22-2", "1.0.0+build.123".
  * @returns -1 if a < b, 0 if equal, 1 if a > b
  */
 export function compareSemver(a, b) {
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
+  // Strip pre-release (-beta.1) and build metadata (+build.123)
+  const cleanA = a.split('-')[0].split('+')[0];
+  const cleanB = b.split('-')[0].split('+')[0];
+  const pa = cleanA.split('.').map(Number);
+  const pb = cleanB.split('.').map(Number);
   for (let i = 0; i < 3; i++) {
     if ((pa[i] || 0) < (pb[i] || 0)) return -1;
     if ((pa[i] || 0) > (pb[i] || 0)) return 1;

package/lib/update.js

@@ -1,25 +1,30 @@
 /**
  * Manual update orchestrator for Push CLI.
  *
- * `push-todo update` performs three actions:
+ * `push-todo update` performs four actions:
  * 1. Self-update: check and install latest push-todo from npm
- * 2. Agent versions: detect and display installed agent CLI versions
- * 3. Project freshness: fetch and rebase registered projects that are behind
+ * 2. Agent CLIs: detect versions, check for updates, and install if available
+ * 3. Version parity: warn if agents are below minimum required versions
+ * 4. Project freshness: fetch and rebase registered projects that are behind
  *
  * Separation of concerns:
- * - Daemon: runs all three checks periodically (hourly, throttled, non-interactive)
+ * - Daemon: runs all checks periodically (hourly, throttled, non-interactive)
+ *   - Self-update: always (gated by auto-update setting)
+ *   - Agent updates: opt-in (gated by auto-update-agents setting, default OFF)
+ *   - Project freshness: always (gated by auto-update setting)
  * - This module: runs on explicit user request (immediate, verbose, interactive)
+ *   - Always checks and updates everything, no settings gate
  */
 
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
-import { checkForUpdate, performUpdate, compareSemver } from './self-update.js';
-import { getAgentVersions, getKnownAgentTypes } from './agent-versions.js';
+import { checkForUpdate, performUpdate } from './self-update.js';
+import { getAgentVersions, getKnownAgentTypes, checkForAgentUpdate, performAgentUpdate, checkVersionParity } from './agent-versions.js';
 import { checkProjectFreshness } from './project-freshness.js';
 import { getRegistry } from './project-registry.js';
-import { bold, green, yellow, red, cyan, dim } from './utils/colors.js';
+import { bold, green, yellow, red, dim } from './utils/colors.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -76,7 +81,7 @@ export async function runManualUpdate(values) {
   }
   console.log();
 
-  // ── 2. Agent versions ──────────────────────────────────
+  // ── 2. Agent CLIs ──────────────────────────────────────
   console.log(bold('  Agent CLIs'));
 
   const agentVersions = getAgentVersions({ force: true });
@@ -84,12 +89,41 @@ export async function runManualUpdate(values) {
     const info = agentVersions[type];
     const label = AGENT_LABELS[type] || type;
 
-    if (info.installed && info.version) {
-      console.log(`  ${label}: ${green('v' + info.version)}`);
-    } else if (info.installed) {
+    if (!info.installed) {
+      console.log(`  ${label}: ${dim('not installed')}`);
+      continue;
+    }
+
+    if (!info.version) {
       console.log(`  ${label}: ${yellow('installed')} ${dim('(version unknown)')}`);
+      continue;
+    }
+
+    // Check for update
+    const updateInfo = checkForAgentUpdate(type);
+    if (updateInfo.available) {
+      console.log(`  ${label}: v${info.version} -> ${green('v' + updateInfo.latest)} available`);
+      console.log(`  Updating ${label} to v${updateInfo.latest}...`);
+      const success = performAgentUpdate(type, updateInfo.latest);
+      if (success) {
+        console.log(`  ${green('Updated successfully')}`);
+      } else {
+        console.log(`  ${red('Update failed')}`);
+      }
+    } else if (updateInfo.reason === 'too_recent') {
+      console.log(`  ${label}: ${green('v' + info.version)} ${dim(`(v${updateInfo.latest} published <1hr ago)`)}`);
     } else {
-      console.log(`  ${label}: ${dim('not installed')}`);
+      console.log(`  ${label}: ${green('v' + info.version)}`);
+    }
+  }
+
+  // Version parity warnings
+  const parityWarnings = checkVersionParity();
+  if (parityWarnings.length > 0) {
+    console.log();
+    for (const w of parityWarnings) {
+      const label = AGENT_LABELS[w.agentType] || w.agentType;
+      console.log(`  ${yellow('Warning')}: ${label} v${w.installed} is below minimum v${w.required}`);
     }
   }
   console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masslessai/push-todo",
-  "version": "4.1.5",
+  "version": "4.1.7",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {