@masslessai/push-todo 4.1.4 → 4.1.6

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

@@ -15,7 +15,7 @@
 
 import { randomUUID } from 'crypto';
 import { spawn, execSync, execFileSync } from 'child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync, unlinkSync, statSync, renameSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync, unlinkSync, statSync, renameSync, readdirSync } from 'fs';
 import { homedir, hostname, platform } from 'os';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -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);
@@ -48,6 +48,10 @@ const RETRY_BACKOFF_FACTOR = 2;
 const CERTAINTY_HIGH_THRESHOLD = 0.7;
 const CERTAINTY_LOW_THRESHOLD = 0.4;
 
+// Idle auto-recovery (Level B)
+const IDLE_TIMEOUT_MS = 900000; // 15 min no stdout → kill (smarter than absolute timeout)
+const HEARTBEAT_INTERVAL_MS = 300000; // 5 min progress heartbeat to Supabase (Level A)
+
 // Stuck detection
 const STUCK_IDLE_THRESHOLD = 600000; // 10 min
 const STUCK_WARNING_THRESHOLD = 300000; // 5 min
@@ -110,6 +114,7 @@ const taskLastOutput = new Map(); // displayNumber -> timestamp
 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
 let daemonStartTime = null;
 
 // ==================== Utilities ====================
@@ -277,12 +282,70 @@ 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;
 let lastCapabilityCheck = 0;
 const CAPABILITY_CHECK_INTERVAL = 3600000; // 1 hour
 
+/**
+ * Discover skills for all registered projects.
+ * Scans ~/.claude/skills/ (global) and <projectPath>/.claude/skills/ (per-project).
+ * Returns: { "github.com/user/repo": ["skill1", "skill2"], ... }
+ */
+function discoverProjectSkills() {
+  const globalSkillsDir = join(homedir(), '.claude', 'skills');
+  const globalSkills = [];
+
+  // Enumerate global skills
+  if (existsSync(globalSkillsDir)) {
+    try {
+      for (const entry of readdirSync(globalSkillsDir, { withFileTypes: true })) {
+        if (entry.isDirectory() || entry.isSymbolicLink()) {
+          globalSkills.push(entry.name);
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  // For each registered project, enumerate project-local skills and merge with global
+  const result = {};
+  if (!existsSync(REGISTRY_FILE)) return result;
+
+  try {
+    const data = JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
+    for (const [, info] of Object.entries(data.projects || {})) {
+      const remote = info.gitRemote;
+      const localPath = info.localPath || info.local_path;
+      if (!remote || !localPath) continue;
+
+      const projectSkillsDir = join(localPath, '.claude', 'skills');
+      const projectSkills = new Set(globalSkills);
+
+      if (existsSync(projectSkillsDir)) {
+        try {
+          for (const entry of readdirSync(projectSkillsDir, { withFileTypes: true })) {
+            if (entry.isDirectory() || entry.isSymbolicLink()) {
+              projectSkills.add(entry.name);
+            }
+          }
+        } catch { /* ignore */ }
+      }
+
+      if (projectSkills.size > 0) {
+        result[remote] = [...projectSkills].sort();
+      }
+    }
+  } catch { /* ignore */ }
+
+  return result;
+}
+
 function detectCapabilities() {
   const caps = {
     auto_merge: getAutoMergeEnabled(),
@@ -302,6 +365,8 @@ function detectCapabilities() {
     caps.gh_cli = 'not_installed';
   }
 
+  caps.project_skills = discoverProjectSkills();
+
   return caps;
 }
 
@@ -1340,6 +1405,151 @@ function checkTaskIdle(displayNumber) {
   return false;
 }
 
+// ==================== Progress Heartbeat (Level A) ====================
+
+async function sendProgressHeartbeats() {
+  const now = Date.now();
+
+  for (const [displayNumber, taskInfo] of runningTasks) {
+    const info = taskDetails.get(displayNumber) || {};
+
+    // Skip tasks awaiting user confirmation (not truly hanging)
+    if (info.phase === 'awaiting_confirmation') continue;
+
+    // Throttle: only send every HEARTBEAT_INTERVAL_MS
+    const lastHeartbeat = taskLastHeartbeat.get(displayNumber) || taskInfo.startTime;
+    if (now - lastHeartbeat < HEARTBEAT_INTERVAL_MS) continue;
+
+    // Compute metrics
+    const elapsedSec = Math.floor((now - taskInfo.startTime) / 1000);
+    const elapsedMin = Math.floor(elapsedSec / 60);
+    const lastOutputTs = taskLastOutput.get(displayNumber);
+    const idleSec = lastOutputTs ? Math.floor((now - lastOutputTs) / 1000) : elapsedSec;
+    const idleMin = Math.floor(idleSec / 60);
+
+    const activityDesc = idleSec < 60 ? 'active' : `idle ${idleMin}m`;
+    const phase = info.phase || 'executing';
+    const eventSummary = `Running for ${elapsedMin}m. Last activity: ${activityDesc}. Phase: ${phase}.`;
+
+    log(`Task #${displayNumber}: sending progress heartbeat (${eventSummary})`);
+
+    // Update throttle timestamp BEFORE the async call to prevent concurrent sends
+    taskLastHeartbeat.set(displayNumber, now);
+
+    // Send event-only update (no status field) — non-fatal if it fails
+    const taskId = info.taskId || null;
+    apiRequest('update-task-execution', {
+      method: 'PATCH',
+      body: JSON.stringify({
+        todoId: taskId,
+        displayNumber,
+        event: {
+          type: 'progress',
+          timestamp: new Date().toISOString(),
+          machineName: getMachineName() || undefined,
+          summary: eventSummary
+        }
+        // No status field — event-only update, won't change execution_status
+      })
+    }).catch(err => {
+      log(`Task #${displayNumber}: heartbeat failed (non-fatal): ${err.message}`);
+    });
+    // NOTE: intentionally not awaited — heartbeats are fire-and-forget
+    // to avoid blocking the poll loop when Supabase is slow
+  }
+}
+
+// ==================== Idle Auto-Recovery (Level B) ====================
+
+async function killIdleTasks() {
+  const now = Date.now();
+  const idleTimedOut = [];
+
+  for (const [displayNumber, taskInfo] of runningTasks) {
+    const info = taskDetails.get(displayNumber) || {};
+
+    // Exempt: tasks awaiting user confirmation
+    if (info.phase === 'awaiting_confirmation') continue;
+
+    const lastOutput = taskLastOutput.get(displayNumber);
+    if (!lastOutput) continue; // No output tracking yet — not idle, just starting
+
+    const idleMs = now - lastOutput;
+    if (idleMs > IDLE_TIMEOUT_MS) {
+      log(`Task #${displayNumber} IDLE TIMEOUT: ${Math.floor(idleMs / 1000)}s since last output`);
+      idleTimedOut.push(displayNumber);
+    }
+  }
+
+  for (const displayNumber of idleTimedOut) {
+    const taskInfo = runningTasks.get(displayNumber);
+    if (!taskInfo) continue;
+
+    const info = taskDetails.get(displayNumber) || {};
+    const projectPath = taskProjectPaths.get(displayNumber);
+    const elapsedSec = Math.floor((now - taskInfo.startTime) / 1000);
+    const idleSec = Math.floor((now - (taskLastOutput.get(displayNumber) || taskInfo.startTime)) / 1000);
+    const durationStr = elapsedSec < 60 ? `${elapsedSec}s` : `${Math.floor(elapsedSec / 60)}m ${elapsedSec % 60}s`;
+    const machineName = getMachineName() || 'Mac';
+
+    // Extract semantic summary WHILE session is still alive
+    // (a live session produces a better "what have you done so far" answer)
+    const sessionId = taskInfo.sessionId;
+    const worktreePath = getWorktreePath(displayNumber, projectPath);
+    const summaryPath = existsSync(worktreePath) ? worktreePath : (projectPath || process.cwd());
+    log(`Task #${displayNumber}: extracting pre-kill summary...`);
+    const idleSummary = extractSemanticSummary(summaryPath, sessionId);
+
+    // Now kill the process
+    log(`Task #${displayNumber}: killing idle process (PID: ${taskInfo.process.pid})`);
+    try {
+      taskInfo.process.kill('SIGTERM');
+      await new Promise(r => setTimeout(r, 5000));
+      taskInfo.process.kill('SIGKILL');
+    } catch {}
+
+    runningTasks.delete(displayNumber);
+    cleanupWorktree(displayNumber, projectPath);
+
+    const idleError = idleSummary
+      ? `${idleSummary}\nSession went idle for ${Math.floor(idleSec / 60)}m with no output. Killed after ${durationStr} on ${machineName}.`
+      : `Session went idle for ${Math.floor(idleSec / 60)}m with no output (limit: ${IDLE_TIMEOUT_MS / 60000}m). Killed after ${durationStr} on ${machineName}.`;
+
+    await updateTaskStatus(displayNumber, 'failed', {
+      error: idleError,
+      sessionId
+    }, info.taskId);
+
+    if (NOTIFY_ON_FAILURE) {
+      sendMacNotification(
+        `Task #${displayNumber} idle timeout`,
+        `${(info.summary || 'Unknown').slice(0, 40)}... idle ${Math.floor(idleSec / 60)}m`,
+        'Basso'
+      );
+    }
+
+    trackCompleted({
+      displayNumber,
+      summary: info.summary || 'Unknown task',
+      completedAt: new Date().toISOString(),
+      duration: elapsedSec,
+      status: 'idle_timeout'
+    });
+
+    // Full cleanup of all tracking Maps
+    taskDetails.delete(displayNumber);
+    taskLastOutput.delete(displayNumber);
+    taskStdoutBuffer.delete(displayNumber);
+    taskStderrBuffer.delete(displayNumber);
+    taskProjectPaths.delete(displayNumber);
+    taskLastHeartbeat.delete(displayNumber);
+  }
+
+  if (idleTimedOut.length > 0) {
+    updateStatusFile();
+  }
+}
+
 // ==================== Session ID Extraction ====================
 
 function extractSessionIdFromStdout(proc, buffer) {
@@ -1616,7 +1826,6 @@ async function executeTask(task) {
     ? [
         '--continue', previousSessionId,
         '-p', prompt,
-        '--worktree', worktreeName,
         '--allowedTools', allowedTools,
         '--output-format', 'json',
         '--permission-mode', 'bypassPermissions',
@@ -1624,7 +1833,6 @@ async function executeTask(task) {
       ]
     : [
         '-p', prompt,
-        '--worktree', worktreeName,
         '--allowedTools', allowedTools,
         '--output-format', 'json',
         '--permission-mode', 'bypassPermissions',
@@ -1660,6 +1868,7 @@ async function executeTask(task) {
     taskLastOutput.set(displayNumber, Date.now());
     taskStdoutBuffer.set(displayNumber, []);
     taskStderrBuffer.set(displayNumber, []);
+    taskLastHeartbeat.set(displayNumber, Date.now());
 
     // Monitor stderr (critical for diagnosing fast exits)
     child.stderr.on('data', (data) => {
@@ -1715,6 +1924,7 @@ async function executeTask(task) {
       runningTasks.delete(displayNumber);
       await updateTaskStatus(displayNumber, 'failed', { error: error.message }, taskId);
       taskDetails.delete(displayNumber);
+      taskLastHeartbeat.delete(displayNumber);
       updateStatusFile();
     });
 
@@ -1938,6 +2148,7 @@ async function handleTaskCompletion(displayNumber, exitCode) {
   taskStdoutBuffer.delete(displayNumber);
   taskStderrBuffer.delete(displayNumber);
   taskProjectPaths.delete(displayNumber);
+  taskLastHeartbeat.delete(displayNumber);
   updateStatusFile();
 }
 
@@ -2016,6 +2227,13 @@ function updateStatusFile() {
 // ==================== Task Checking ====================
 
 async function checkTimeouts() {
+  // Level A: Send progress heartbeats for long-running tasks
+  await sendProgressHeartbeats();
+
+  // Level B: Kill tasks that have been idle too long (fires at 15 min, before 60 min absolute)
+  await killIdleTasks();
+
+  // Absolute timeout (safety net — 60 min wall clock)
   const now = Date.now();
   const timedOut = [];
 
@@ -2082,6 +2300,7 @@ async function checkTimeouts() {
     taskStdoutBuffer.delete(displayNumber);
     taskStderrBuffer.delete(displayNumber);
     taskProjectPaths.delete(displayNumber);
+    taskLastHeartbeat.delete(displayNumber);
     cleanupWorktree(displayNumber, projectPath);
   }
 
@@ -2141,6 +2360,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() {
@@ -2243,10 +2511,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
@@ -2345,6 +2615,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.4",
+  "version": "4.1.6",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {