@masslessai/push-todo 3.7.6 → 3.7.8

package/lib/config.js

@@ -192,6 +192,27 @@ export function setAutoCompleteEnabled(enabled) {
   return setConfigValue('AUTO_COMPLETE', enabled ? 'true' : 'false');
 }
 
+/**
+ * Check if auto-update is enabled for daemon self-updates.
+ * Default: true (daemon checks npm hourly and updates when idle)
+ *
+ * @returns {boolean}
+ */
+export function getAutoUpdateEnabled() {
+  const value = getConfigValue('AUTO_UPDATE', 'true');
+  return value.toLowerCase() === 'true' || value === '1' || value.toLowerCase() === 'yes';
+}
+
+/**
+ * Set auto-update setting.
+ *
+ * @param {boolean} enabled
+ * @returns {boolean} True if successful
+ */
+export function setAutoUpdateEnabled(enabled) {
+  return setConfigValue('AUTO_UPDATE', enabled ? 'true' : 'false');
+}
+
 /**
  * Get the maximum batch size for queuing tasks.
  * Default: 5
@@ -270,6 +291,7 @@ export function showSettings() {
   const autoCommit = getAutoCommitEnabled();
   const autoMerge = getAutoMergeEnabled();
   const autoComplete = getAutoCompleteEnabled();
+  const autoUpdate = getAutoUpdateEnabled();
   const batchSize = getMaxBatchSize();
 
   console.log(`  auto-commit:    ${autoCommit ? 'ON' : 'OFF'}`);
@@ -281,6 +303,9 @@ export function showSettings() {
   console.log(`  auto-complete:  ${autoComplete ? 'ON' : 'OFF'}`);
   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();
   console.log(`  batch-size:     ${batchSize}`);
   console.log('                  Max tasks for batch queue (1-20)');
   console.log();
@@ -346,6 +371,22 @@ export function toggleSetting(settingName) {
     return false;
   }
 
+  if (normalized === 'auto-update') {
+    const current = getAutoUpdateEnabled();
+    const newValue = !current;
+    if (setAutoUpdateEnabled(newValue)) {
+      console.log(`Auto-update is now ${newValue ? 'ON' : 'OFF'}`);
+      if (newValue) {
+        console.log('Daemon will auto-update from npm when idle (hourly check).');
+      } else {
+        console.log('Daemon will NOT auto-update. Manual updates required.');
+      }
+      return true;
+    }
+    console.error('Failed to update setting');
+    return false;
+  }
+
   if (normalized === 'batch-size') {
     const batchSize = getMaxBatchSize();
     console.log(`Current batch size: ${batchSize}`);
@@ -354,7 +395,7 @@ export function toggleSetting(settingName) {
   }
 
   console.error(`Unknown setting: ${settingName}`);
-  console.error('Available settings: auto-commit, auto-merge, auto-complete, batch-size');
+  console.error('Available settings: auto-commit, auto-merge, auto-complete, auto-update, batch-size');
   return false;
 }
 

package/lib/daemon.js

@@ -19,6 +19,8 @@ import { homedir, hostname, platform } from 'os';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
+import { checkForUpdate, performUpdate } from './self-update.js';
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
@@ -230,6 +232,48 @@ function getAutoCompleteEnabled() {
   return v.toLowerCase() === 'true' || v === '1' || v.toLowerCase() === 'yes';
 }
 
+function getAutoUpdateEnabled() {
+  const v = getConfigValueFromFile('AUTO_UPDATE', 'true');
+  return v.toLowerCase() === 'true' || v === '1' || v.toLowerCase() === 'yes';
+}
+
+// ==================== Capabilities Detection ====================
+
+let cachedCapabilities = null;
+let lastCapabilityCheck = 0;
+const CAPABILITY_CHECK_INTERVAL = 3600000; // 1 hour
+
+function detectCapabilities() {
+  const caps = {
+    auto_merge: getAutoMergeEnabled(),
+    auto_complete: getAutoCompleteEnabled(),
+    auto_update: getAutoUpdateEnabled(),
+  };
+
+  try {
+    execFileSync('gh', ['--version'], { timeout: 5000, stdio: 'pipe' });
+    try {
+      execFileSync('gh', ['auth', 'status'], { timeout: 5000, stdio: 'pipe' });
+      caps.gh_cli = 'authenticated';
+    } catch {
+      caps.gh_cli = 'installed_not_authenticated';
+    }
+  } catch {
+    caps.gh_cli = 'not_installed';
+  }
+
+  return caps;
+}
+
+function getCapabilities() {
+  const now = Date.now();
+  if (!cachedCapabilities || now - lastCapabilityCheck > CAPABILITY_CHECK_INTERVAL) {
+    cachedCapabilities = detectCapabilities();
+    lastCapabilityCheck = now;
+  }
+  return cachedCapabilities;
+}
+
 // ==================== E2EE Decryption ====================
 
 let decryptTodoField = null;
@@ -335,6 +379,8 @@ async function fetchQueuedTasks() {
       heartbeatHeaders['X-Machine-Id'] = machineId;
       heartbeatHeaders['X-Machine-Name'] = machineName || 'Unknown Mac';
       heartbeatHeaders['X-Git-Remotes'] = gitRemotes.join(',');
+      heartbeatHeaders['X-Daemon-Version'] = getVersion();
+      heartbeatHeaders['X-Capabilities'] = JSON.stringify(getCapabilities());
     }
 
     const response = await apiRequest(`synced-todos?${params}`, {
@@ -393,7 +439,15 @@ async function updateTaskStatus(displayNumber, status, extra = {}) {
     });
 
     const result = await response.json().catch(() => null);
-    return response.ok && result?.success !== false;
+    if (!response.ok) {
+      logError(`Task status update failed: HTTP ${response.status} for #${displayNumber} -> ${status}`);
+      return false;
+    }
+    if (result?.success === false) {
+      logError(`Task status update rejected for #${displayNumber} -> ${status}: ${JSON.stringify(result)}`);
+      return false;
+    }
+    return true;
   } catch (error) {
     logError(`Failed to update task status: ${error.message}`);
     return false;
@@ -708,6 +762,110 @@ async function markTaskAsCompleted(displayNumber, taskId, comment) {
   }
 }
 
+/**
+ * Auto-heal: detect if a previous execution already completed work for this task.
+ * Checks for existing branch commits and PRs to avoid redundant re-execution.
+ * Returns true if the task was healed (status updated, no re-execution needed).
+ */
+async function autoHealExistingWork(displayNumber, summary, projectPath) {
+  const suffix = getWorktreeSuffix();
+  const branch = `push-${displayNumber}-${suffix}`;
+  const gitCwd = projectPath || process.cwd();
+
+  try {
+    // Check if branch has commits ahead of main
+    let hasCommits = false;
+    try {
+      const logResult = execSync(
+        `git log HEAD..origin/${branch} --oneline 2>/dev/null || git log HEAD..${branch} --oneline 2>/dev/null`,
+        { cwd: gitCwd, timeout: 10000, stdio: ['ignore', 'pipe', 'pipe'] }
+      ).toString().trim();
+      hasCommits = logResult.length > 0;
+    } catch {
+      // Branch doesn't exist — no previous work
+      return false;
+    }
+
+    if (!hasCommits) {
+      return false;
+    }
+
+    log(`Task #${displayNumber}: found existing commits on branch ${branch}`);
+
+    // Check for existing PR
+    let prUrl = null;
+    let prState = null;
+    try {
+      const prResult = execSync(
+        `gh pr list --head ${branch} --json url,state --jq '.[0]' 2>/dev/null`,
+        { cwd: gitCwd, timeout: 15000, stdio: ['ignore', 'pipe', 'pipe'] }
+      ).toString().trim();
+      if (prResult) {
+        const pr = JSON.parse(prResult);
+        prUrl = pr.url;
+        prState = pr.state; // OPEN or MERGED
+      }
+    } catch {
+      // gh not available or no PR found
+    }
+
+    if (prUrl && prState === 'MERGED') {
+      // PR already merged — task is fully done
+      log(`Task #${displayNumber}: PR already merged (${prUrl}), updating status`);
+      const executionSummary = `Auto-healed: previous execution completed and PR merged. PR: ${prUrl}`;
+      await updateTaskStatus(displayNumber, 'session_finished', {
+        summary: executionSummary
+      });
+      completedToday.push({
+        displayNumber, summary,
+        completedAt: new Date().toISOString(),
+        duration: 0, status: 'session_finished', prUrl
+      });
+      return true;
+    }
+
+    if (prUrl && prState === 'OPEN') {
+      // PR is open — work is done, just needs review
+      log(`Task #${displayNumber}: PR already open (${prUrl}), updating status`);
+      const executionSummary = `Auto-healed: previous execution completed. PR pending review: ${prUrl}`;
+      await updateTaskStatus(displayNumber, 'session_finished', {
+        summary: executionSummary
+      });
+      completedToday.push({
+        displayNumber, summary,
+        completedAt: new Date().toISOString(),
+        duration: 0, status: 'session_finished', prUrl
+      });
+      return true;
+    }
+
+    if (!prUrl) {
+      // Commits exist but no PR — create one and update status
+      log(`Task #${displayNumber}: commits exist but no PR, creating PR`);
+      const newPrUrl = createPRForTask(displayNumber, summary, projectPath);
+      if (newPrUrl) {
+        const executionSummary = `Auto-healed: previous execution had uncommitted PR. Created PR: ${newPrUrl}`;
+        await updateTaskStatus(displayNumber, 'session_finished', {
+          summary: executionSummary
+        });
+        completedToday.push({
+          displayNumber, summary,
+          completedAt: new Date().toISOString(),
+          duration: 0, status: 'session_finished', prUrl: newPrUrl
+        });
+        return true;
+      }
+      // PR creation failed — fall through to re-execute
+      log(`Task #${displayNumber}: PR creation failed, will re-execute`);
+    }
+
+    return false;
+  } catch (error) {
+    log(`Task #${displayNumber}: auto-heal check failed: ${error.message}`);
+    return false;
+  }
+}
+
 // ==================== Stuck Detection ====================
 
 function checkStuckPatterns(displayNumber, line) {
@@ -868,7 +1026,7 @@ function updateTaskDetail(displayNumber, updates) {
   updateStatusFile();
 }
 
-function executeTask(task) {
+async function executeTask(task) {
   // Decrypt E2EE fields
   task = decryptTaskFields(task);
 
@@ -905,7 +1063,7 @@ function executeTask(task) {
 
     if (!existsSync(projectPath)) {
       logError(`Task #${displayNumber}: Project path does not exist: ${projectPath}`);
-      updateTaskStatus(displayNumber, 'failed', {
+      await updateTaskStatus(displayNumber, 'failed', {
         error: `Project path not found: ${projectPath}`
       });
       return null;
@@ -914,8 +1072,16 @@ function executeTask(task) {
     log(`Task #${displayNumber}: Project ${gitRemote} -> ${projectPath}`);
   }
 
-  // Atomic task claiming
-  if (!claimTask(displayNumber)) {
+  // Atomic task claiming - must await to actually check the result
+  if (!(await claimTask(displayNumber))) {
+    log(`Task #${displayNumber}: claim failed, skipping`);
+    return null;
+  }
+
+  // Auto-heal: check if previous execution already completed work for this task
+  const healed = await autoHealExistingWork(displayNumber, summary, projectPath);
+  if (healed) {
+    log(`Task #${displayNumber}: auto-healed from previous execution, skipping re-execution`);
     return null;
   }
 
@@ -935,7 +1101,7 @@ function executeTask(task) {
   // Create worktree
   const worktreePath = createWorktree(displayNumber, projectPath);
   if (!worktreePath) {
-    updateTaskStatus(displayNumber, 'failed', { error: 'Failed to create git worktree' });
+    await updateTaskStatus(displayNumber, 'failed', { error: 'Failed to create git worktree' });
     taskDetails.delete(displayNumber);
     return null;
   }
@@ -952,15 +1118,8 @@ IMPORTANT:
 2. ALWAYS commit your changes before finishing. Use a descriptive commit message summarizing what you did. This is critical — uncommitted changes will be lost when the worktree is cleaned up.
 3. When you're done, the SessionEnd hook will automatically report completion to Supabase.`;
 
-  // Update status to running (auto-generates 'started' event)
-  updateTaskStatus(displayNumber, 'running', {
-    event: {
-      type: 'started',
-      timestamp: new Date().toISOString(),
-      machineName: getMachineName() || undefined,
-      summary: summary.slice(0, 100),
-    }
-  });
+  // Note: claimTask() already set status to 'running' with atomic: true
+  // No duplicate status update needed here (was causing race conditions)
 
   // Build Claude command
   const allowedTools = [
@@ -1029,10 +1188,10 @@ IMPORTANT:
       handleTaskCompletion(displayNumber, code);
     });
 
-    child.on('error', (error) => {
+    child.on('error', async (error) => {
       logError(`Task #${displayNumber} error: ${error.message}`);
       runningTasks.delete(displayNumber);
-      updateTaskStatus(displayNumber, 'failed', { error: error.message });
+      await updateTaskStatus(displayNumber, 'failed', { error: error.message });
       taskDetails.delete(displayNumber);
       updateStatusFile();
     });
@@ -1048,13 +1207,13 @@ IMPORTANT:
     return taskInfo;
   } catch (error) {
     logError(`Error starting Claude for task #${displayNumber}: ${error.message}`);
-    updateTaskStatus(displayNumber, 'failed', { error: error.message });
+    await updateTaskStatus(displayNumber, 'failed', { error: error.message });
     taskDetails.delete(displayNumber);
     return null;
   }
 }
 
-function handleTaskCompletion(displayNumber, exitCode) {
+async function handleTaskCompletion(displayNumber, exitCode) {
   const taskInfo = runningTasks.get(displayNumber);
   if (!taskInfo) return;
 
@@ -1097,11 +1256,18 @@ function handleTaskCompletion(displayNumber, exitCode) {
       executionSummary += ` PR: ${prUrl}`;
     }
 
-    updateTaskStatus(displayNumber, 'session_finished', {
+    const statusUpdated = await updateTaskStatus(displayNumber, 'session_finished', {
       duration,
       sessionId,
       summary: executionSummary
     });
+    if (!statusUpdated) {
+      logError(`Task #${displayNumber}: Failed to update status to session_finished — will retry`);
+      // Retry once
+      await updateTaskStatus(displayNumber, 'session_finished', {
+        duration, sessionId, summary: executionSummary
+      });
+    }
 
     if (NOTIFY_ON_COMPLETE) {
       const prNote = prUrl ? ' PR ready for review.' : '';
@@ -1124,7 +1290,10 @@ function handleTaskCompletion(displayNumber, exitCode) {
       const comment = semanticSummary
         ? `${semanticSummary} (${durationStr} on ${machineName})`
         : `Completed in ${durationStr} on ${machineName}`;
-      markTaskAsCompleted(displayNumber, taskId, comment);
+      const completed = await markTaskAsCompleted(displayNumber, taskId, comment);
+      if (!completed) {
+        logError(`Task #${displayNumber}: Failed to mark as completed — status is session_finished but not completed`);
+      }
     }
 
     completedToday.push({
@@ -1145,7 +1314,7 @@ function handleTaskCompletion(displayNumber, exitCode) {
       ? `${failureSummary}\nExit code ${exitCode}. Ran for ${durationStr} on ${machineName}.`
       : `Exit code ${exitCode}: ${stderr.slice(0, 200)}`;
 
-    updateTaskStatus(displayNumber, 'failed', { error: errorMsg });
+    await updateTaskStatus(displayNumber, 'failed', { error: errorMsg });
 
     if (NOTIFY_ON_FAILURE) {
       sendMacNotification(
@@ -1317,6 +1486,54 @@ async function checkTimeouts() {
   }
 }
 
+// ==================== Self-Update ====================
+
+let pendingUpdateVersion = null;
+
+function checkAndApplyUpdate() {
+  const currentVersion = getVersion();
+
+  // Check for update (throttled internally to once per hour)
+  if (!pendingUpdateVersion) {
+    const result = checkForUpdate(currentVersion);
+    if (result.available) {
+      log(`Update available: v${currentVersion} -> v${result.version}`);
+      pendingUpdateVersion = result.version;
+    }
+  }
+
+  // Only apply when no tasks are running
+  if (pendingUpdateVersion && runningTasks.size === 0) {
+    log(`Applying update to v${pendingUpdateVersion}...`);
+    sendMacNotification(
+      'Push Daemon Updating',
+      `v${currentVersion} → v${pendingUpdateVersion}`,
+      'Glass'
+    );
+
+    const success = performUpdate(pendingUpdateVersion);
+    if (success) {
+      log(`Update to v${pendingUpdateVersion} successful. Restarting daemon...`);
+
+      // Spawn new daemon from updated code, then exit
+      const daemonScript = join(__dirname, 'daemon.js');
+      const child = spawn(process.execPath, [daemonScript], {
+        detached: true,
+        stdio: ['ignore', 'ignore', 'ignore'],
+        env: { ...process.env, PUSH_DAEMON: '1' }
+      });
+      writeFileSync(PID_FILE, String(child.pid));
+      child.unref();
+
+      log(`New daemon spawned (PID: ${child.pid}). Old daemon exiting.`);
+      process.exit(0);
+    } else {
+      logError(`Update to v${pendingUpdateVersion} failed, will retry next hour`);
+      pendingUpdateVersion = null;
+    }
+  }
+}
+
 // ==================== Main Loop ====================
 
 async function pollAndExecute() {
@@ -1348,7 +1565,13 @@ async function pollAndExecute() {
       continue;
     }
 
-    executeTask(task);
+    // Skip tasks already completed this daemon session (prevents re-execution loop)
+    if (completedToday.some(c => c.displayNumber === displayNumber)) {
+      log(`Task #${displayNumber} already completed this session, skipping`);
+      continue;
+    }
+
+    await executeTask(task);
   }
 
   updateStatusFile();
@@ -1364,6 +1587,9 @@ async function mainLoop() {
   log(`Polling interval: ${POLL_INTERVAL / 1000}s`);
   log(`Max concurrent tasks: ${MAX_CONCURRENT_TASKS}`);
   log(`E2EE: ${e2eeAvailable ? 'Available' : 'Not available'}`);
+  log(`Auto-update: ${getAutoUpdateEnabled() ? 'Enabled' : 'Disabled'}`);
+  const caps = getCapabilities();
+  log(`Capabilities: gh=${caps.gh_cli}, auto-merge=${caps.auto_merge}, auto-complete=${caps.auto_complete}`);
   log(`Log file: ${LOG_FILE}`);
 
   // Show registered projects
@@ -1399,6 +1625,11 @@ async function mainLoop() {
     try {
       await checkTimeouts();
       await pollAndExecute();
+
+      // Self-update check (throttled to once per hour, only applies when idle)
+      if (getAutoUpdateEnabled()) {
+        checkAndApplyUpdate();
+      }
     } catch (error) {
       logError(`Poll error: ${error.message}`);
     }
@@ -1415,10 +1646,11 @@ async function mainLoop() {
 
 // ==================== Signal Handling ====================
 
-function cleanup() {
+async function cleanup() {
   log('Daemon shutting down...');
 
-  // Kill running tasks and mark them as failed in Supabase
+  // Kill running tasks and collect status update promises
+  const statusPromises = [];
   for (const [displayNumber, taskInfo] of runningTasks) {
     log(`Killing task #${displayNumber}`);
     try {
@@ -1426,19 +1658,30 @@ function cleanup() {
     } catch {}
     // Mark as failed so the task doesn't stay as 'running' forever
     const duration = Math.floor((Date.now() - taskInfo.startTime) / 1000);
-    updateTaskStatus(displayNumber, 'failed', {
-      error: `Daemon shutdown after ${duration}s`,
-      event: {
-        type: 'daemon_shutdown',
-        timestamp: new Date().toISOString(),
-        machineName: getMachineName() || undefined,
-        summary: `Daemon restarted after ${duration}s`,
-      }
-    });
+    statusPromises.push(
+      updateTaskStatus(displayNumber, 'failed', {
+        error: `Daemon shutdown after ${duration}s`,
+        event: {
+          type: 'daemon_shutdown',
+          timestamp: new Date().toISOString(),
+          machineName: getMachineName() || undefined,
+          summary: `Daemon restarted after ${duration}s`,
+        }
+      })
+    );
     const projectPath = taskProjectPaths.get(displayNumber);
     cleanupWorktree(displayNumber, projectPath);
   }
 
+  // Wait for all status updates to land (max 5s timeout)
+  if (statusPromises.length > 0) {
+    log(`Waiting for ${statusPromises.length} status update(s) to complete...`);
+    await Promise.race([
+      Promise.allSettled(statusPromises),
+      new Promise(resolve => setTimeout(resolve, 5000))
+    ]);
+  }
+
   // Clean up files
   try { unlinkSync(PID_FILE); } catch {}
 
@@ -1453,11 +1696,11 @@ function cleanup() {
   process.exit(0);
 }
 
-process.on('SIGTERM', cleanup);
-process.on('SIGINT', cleanup);
+process.on('SIGTERM', () => cleanup().catch(() => process.exit(1)));
+process.on('SIGINT', () => cleanup().catch(() => process.exit(1)));
 process.on('uncaughtException', (error) => {
   logError(`Uncaught exception: ${error.message}`);
-  cleanup();
+  cleanup().catch(() => process.exit(1));
 });
 
 // ==================== Entry Point ====================

package/lib/self-update.js

@@ -0,0 +1,115 @@
+/**
+ * Self-update module for Push daemon.
+ *
+ * Checks npm registry for newer versions and auto-updates.
+ * Safety: Only updates to versions published >1 hour ago.
+ * Throttle: Checks at most once per hour.
+ * Config: PUSH_AUTO_UPDATE (default true)
+ */
+
+import { execFileSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const PUSH_DIR = join(homedir(), '.push');
+const LAST_UPDATE_CHECK_FILE = join(PUSH_DIR, 'last_update_check');
+const UPDATE_CHECK_INTERVAL = 3600000; // 1 hour
+
+/**
+ * Compare semver strings.
+ * @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);
+  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;
+  }
+  return 0;
+}
+
+/**
+ * Fetch latest version info from npm registry.
+ * @returns {{ version: string, publishedAt: string | null }} or null on failure
+ */
+function fetchLatestVersionInfo() {
+  try {
+    const result = execFileSync('npm', ['view', '@masslessai/push-todo', '--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 update is available and safe to install.
+ * Throttled to once per hour. Enforces 1-hour age gate on new versions.
+ *
+ * @param {string} currentVersion
+ * @returns {{ available: boolean, version?: string, reason?: string }}
+ */
+export function checkForUpdate(currentVersion) {
+  // Throttle: check at most once per hour
+  if (existsSync(LAST_UPDATE_CHECK_FILE)) {
+    try {
+      const lastCheck = parseInt(readFileSync(LAST_UPDATE_CHECK_FILE, 'utf8').trim(), 10);
+      if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL) {
+        return { available: false, reason: 'throttled' };
+      }
+    } catch {}
+  }
+
+  // Record check time
+  try {
+    mkdirSync(PUSH_DIR, { recursive: true });
+    writeFileSync(LAST_UPDATE_CHECK_FILE, String(Date.now()));
+  } catch {}
+
+  const info = fetchLatestVersionInfo();
+  if (!info) {
+    return { available: false, reason: 'registry_unreachable' };
+  }
+
+  // Already up to date
+  if (compareSemver(currentVersion, info.version) >= 0) {
+    return { available: false, reason: 'up_to_date' };
+  }
+
+  // Safety: only update to versions published >1 hour ago
+  if (info.publishedAt) {
+    const publishedAge = Date.now() - new Date(info.publishedAt).getTime();
+    if (publishedAge < UPDATE_CHECK_INTERVAL) {
+      return { available: false, reason: 'too_recent', version: info.version };
+    }
+  }
+
+  return { available: true, version: info.version };
+}
+
+/**
+ * Install a specific version globally.
+ * @param {string} targetVersion
+ * @returns {boolean} true if update succeeded
+ */
+export function performUpdate(targetVersion) {
+  try {
+    execFileSync('npm', ['install', '-g', `@masslessai/push-todo@${targetVersion}`], {
+      timeout: 120000,
+      stdio: 'pipe'
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/package.json

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