@masslessai/push-todo 3.7.7 → 3.7.9

package/lib/daemon.js

@@ -439,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;
@@ -678,15 +686,13 @@ Automated PR from Push daemon for task #${displayNumber}.
 }
 
 /**
- * Merge a PR into main and update local main branch.
- * Uses `gh pr merge` for clean remote merge, then pulls locally.
+ * Attempt to merge a PR. If merge conflicts, use Claude to resolve them.
  *
  * @returns {boolean} True if merge succeeded
  */
 function mergePRForTask(displayNumber, prUrl, projectPath) {
   const gitCwd = projectPath || process.cwd();
 
-  // Extract PR number from URL (e.g., https://github.com/user/repo/pull/42)
   const prMatch = prUrl.match(/\/pull\/(\d+)/);
   if (!prMatch) {
     logError(`Could not extract PR number from: ${prUrl}`);
@@ -694,6 +700,26 @@ function mergePRForTask(displayNumber, prUrl, projectPath) {
   }
   const prNumber = prMatch[1];
 
+  // First attempt: direct merge
+  const firstResult = attemptPRMerge(prNumber, displayNumber, gitCwd);
+  if (firstResult === 'success') return true;
+  if (firstResult !== 'conflict') return false;  // non-conflict failure
+
+  // Conflict detected — try to resolve with Claude
+  const suffix = getWorktreeSuffix();
+  const branch = `push-${displayNumber}-${suffix}`;
+  const resolved = resolveConflictsWithClaude(displayNumber, branch, gitCwd);
+  if (!resolved) return false;
+
+  // Second attempt after conflict resolution
+  log(`Retrying merge for PR #${prNumber} after conflict resolution`);
+  return attemptPRMerge(prNumber, displayNumber, gitCwd) === 'success';
+}
+
+/**
+ * Try gh pr merge. Returns 'success', 'conflict', or 'error'.
+ */
+function attemptPRMerge(prNumber, displayNumber, gitCwd) {
   try {
     execFileSync('gh', ['pr', 'merge', prNumber, '--merge', '--delete-branch'], {
       cwd: gitCwd,
@@ -714,16 +740,132 @@ function mergePRForTask(displayNumber, prUrl, projectPath) {
       log('Could not pull main (may not be checked out), skipping local update');
     }
 
-    return true;
+    return 'success';
   } catch (e) {
     const stderr = e.stderr?.toString() || e.message || '';
-    if (stderr.includes('merge conflict') || stderr.includes('conflict')) {
-      logError(`PR #${prNumber} has merge conflicts, skipping auto-merge`);
-    } else if (stderr.includes('not found') || stderr.includes('ENOENT')) {
+    if (stderr.includes('not found') || stderr.includes('ENOENT')) {
       log('GitHub CLI (gh) not installed, skipping merge');
-    } else {
-      logError(`Failed to merge PR #${prNumber}: ${stderr.slice(0, 200)}`);
+      return 'error';
+    }
+    if (stderr.includes('merge conflict') || stderr.includes('conflict')) {
+      log(`PR #${prNumber} has merge conflicts, will attempt resolution`);
+      return 'conflict';
+    }
+    logError(`PR merge failed for #${displayNumber}: ${stderr.slice(0, 200)}`);
+    return 'error';
+  }
+}
+
+/**
+ * Resolve merge conflicts by creating a worktree, merging main, using Claude
+ * to fix conflicts, then committing and pushing the resolution.
+ *
+ * @returns {boolean} True if conflicts were resolved and pushed
+ */
+function resolveConflictsWithClaude(displayNumber, branch, projectPath) {
+  log(`Attempting conflict resolution for task #${displayNumber}`);
+
+  const worktreePath = getWorktreePath(displayNumber, projectPath);
+
+  // Recreate worktree from the existing branch
+  try {
+    if (!existsSync(worktreePath)) {
+      execFileSync('git', ['worktree', 'add', worktreePath, branch], {
+        cwd: projectPath,
+        timeout: 30000,
+        stdio: 'pipe'
+      });
+    }
+  } catch (e) {
+    logError(`Could not create worktree for conflict resolution: ${e.message}`);
+    return false;
+  }
+
+  try {
+    // Fetch latest main
+    execFileSync('git', ['fetch', 'origin'], {
+      cwd: worktreePath,
+      timeout: 30000,
+      stdio: 'pipe'
+    });
+
+    // Attempt merge — this will create conflict markers if conflicts exist
+    try {
+      execFileSync('git', ['merge', 'origin/main', '--no-edit'], {
+        cwd: worktreePath,
+        timeout: 30000,
+        stdio: 'pipe'
+      });
+      // No conflicts — merge succeeded cleanly
+      log(`No actual conflicts for #${displayNumber}, merge succeeded locally`);
+      execFileSync('git', ['push', 'origin', branch], {
+        cwd: worktreePath,
+        timeout: 30000,
+        stdio: 'pipe'
+      });
+      cleanupWorktree(displayNumber, projectPath);
+      return true;
+    } catch {
+      // Expected: merge conflicts exist, continue to resolution
+      log(`Conflicts detected for #${displayNumber}, invoking Claude to resolve`);
+    }
+
+    // Use Claude to resolve the conflicts
+    const prompt = [
+      'There are merge conflicts in this repository from merging origin/main.',
+      'Run `git diff` to see the conflict markers.',
+      'Resolve ALL conflicts by choosing the correct code for each one.',
+      'After resolving, stage the files with `git add` and commit with:',
+      `git commit -m "Resolve merge conflicts for task #${displayNumber}"`,
+      'Do NOT push. Just resolve and commit.'
+    ].join(' ');
+
+    execFileSync('claude', [
+      '-p', prompt,
+      '--allowedTools', 'Bash(git *),Read,Edit,Write,Glob,Grep',
+      '--output-format', 'json',
+      '--permission-mode', 'bypassPermissions'
+    ], {
+      cwd: worktreePath,
+      timeout: 120000,  // 2 min for conflict resolution
+      stdio: 'pipe'
+    });
+
+    // Verify the merge completed (no unmerged files remaining)
+    try {
+      const status = execFileSync('git', ['status', '--porcelain'], {
+        cwd: worktreePath,
+        timeout: 10000,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      }).toString();
+
+      if (status.includes('UU ') || status.includes('AA ') || status.includes('DD ')) {
+        logError(`Conflicts not fully resolved for #${displayNumber}`);
+        try { execFileSync('git', ['merge', '--abort'], { cwd: worktreePath, stdio: 'pipe' }); } catch {}
+        cleanupWorktree(displayNumber, projectPath);
+        return false;
+      }
+    } catch {
+      try { execFileSync('git', ['merge', '--abort'], { cwd: worktreePath, stdio: 'pipe' }); } catch {}
+      cleanupWorktree(displayNumber, projectPath);
+      return false;
     }
+
+    // Push the resolved branch
+    execFileSync('git', ['push', 'origin', branch], {
+      cwd: worktreePath,
+      timeout: 30000,
+      stdio: 'pipe'
+    });
+
+    log(`Conflict resolution pushed for task #${displayNumber}`);
+    cleanupWorktree(displayNumber, projectPath);
+    return true;
+  } catch (e) {
+    logError(`Conflict resolution failed for #${displayNumber}: ${e.message}`);
+    try { execFileSync('git', ['merge', '--abort'], { cwd: worktreePath, stdio: 'pipe' }); } catch {}
+    cleanupWorktree(displayNumber, projectPath);
     return false;
   }
 }
@@ -754,6 +896,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) {
@@ -914,7 +1160,7 @@ function updateTaskDetail(displayNumber, updates) {
   updateStatusFile();
 }
 
-function executeTask(task) {
+async function executeTask(task) {
   // Decrypt E2EE fields
   task = decryptTaskFields(task);
 
@@ -951,7 +1197,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;
@@ -960,8 +1206,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;
   }
 
@@ -981,7 +1235,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;
   }
@@ -998,15 +1252,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 = [
@@ -1075,10 +1322,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();
     });
@@ -1094,13 +1341,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;
 
@@ -1130,9 +1377,14 @@ function handleTaskCompletion(displayNumber, exitCode) {
     // Auto-create PR first so we can include it in the summary
     const prUrl = createPRForTask(displayNumber, summary, projectPath);
 
-    // Ask Claude to summarize what it accomplished
+    // Ask Claude to summarize what it accomplished (needs worktree path)
     const semanticSummary = extractSemanticSummary(worktreePath, sessionId);
 
+    // Clean up worktree BEFORE merge — gh pr merge --delete-branch fails if
+    // the local branch is still referenced by a worktree. The branch itself
+    // is preserved (only the worktree checkout is removed).
+    cleanupWorktree(displayNumber, projectPath);
+
     // Combine: semantic summary first (what), then machine metadata (how)
     let executionSummary = '';
     if (semanticSummary) {
@@ -1143,11 +1395,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.' : '';
@@ -1170,7 +1429,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({
@@ -1185,13 +1447,17 @@ function handleTaskCompletion(displayNumber, exitCode) {
   } else {
     const stderr = taskInfo.process.stderr?.read()?.toString() || '';
 
-    // Ask Claude to explain what went wrong (if session exists)
+    // Ask Claude to explain what went wrong (needs worktree path)
     const failureSummary = extractSemanticSummary(worktreePath, sessionId);
+
+    // Clean up worktree after summary extraction
+    cleanupWorktree(displayNumber, projectPath);
+
     const errorMsg = failureSummary
       ? `${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(
@@ -1215,10 +1481,6 @@ function handleTaskCompletion(displayNumber, exitCode) {
   taskLastOutput.delete(displayNumber);
   taskStdoutBuffer.delete(displayNumber);
   taskProjectPaths.delete(displayNumber);
-
-  // Always clean up worktree — the branch preserves all committed work.
-  // On re-run, createWorktree() recreates from the existing branch.
-  cleanupWorktree(displayNumber, projectPath);
   updateStatusFile();
 }
 
@@ -1442,7 +1704,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();
@@ -1517,10 +1785,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 {
@@ -1528,19 +1797,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 {}
 
@@ -1555,11 +1835,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/fetch.js

@@ -11,7 +11,7 @@ import { getGitRemote, isGitRepo } from './utils/git.js';
 import { formatTaskForDisplay, formatSearchResult } from './utils/format.js';
 import { bold, green, yellow, red, cyan, dim, muted } from './utils/colors.js';
 import { decryptTodoField, isE2EEAvailable } from './encryption.js';
-import { getAutoCommitEnabled, getMaxBatchSize } from './config.js';
+import { getAutoCommitEnabled, getAutoMergeEnabled, getAutoCompleteEnabled, getAutoUpdateEnabled, getMaxBatchSize } from './config.js';
 import { writeFileSync, mkdirSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
@@ -333,6 +333,9 @@ export async function showStatus(options = {}) {
   const registry = getRegistry();
   const [e2eeAvailable, e2eeMessage] = isE2EEAvailable();
   const autoCommit = getAutoCommitEnabled();
+  const autoMerge = getAutoMergeEnabled();
+  const autoComplete = getAutoCompleteEnabled();
+  const autoUpdate = getAutoUpdateEnabled();
   const maxBatch = getMaxBatchSize();
 
   // Validate API key
@@ -358,6 +361,9 @@ export async function showStatus(options = {}) {
     },
     settings: {
       autoCommit,
+      autoMerge,
+      autoComplete,
+      autoUpdate,
       maxBatchSize: maxBatch
     },
     registeredProjects: registry.projectCount()
@@ -401,6 +407,9 @@ export async function showStatus(options = {}) {
 
   // Settings
   console.log(`${bold('Auto-commit:')} ${autoCommit ? 'Enabled' : 'Disabled'}`);
+  console.log(`${bold('Auto-merge:')} ${autoMerge ? 'Enabled' : 'Disabled'}`);
+  console.log(`${bold('Auto-complete:')} ${autoComplete ? 'Enabled' : 'Disabled'}`);
+  console.log(`${bold('Auto-update:')} ${autoUpdate ? 'Enabled' : 'Disabled'}`);
   console.log(`${bold('Max batch size:')} ${maxBatch}`);
   console.log(`${bold('Registered projects:')} ${status.registeredProjects}`);
 }

package/package.json

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