@masslessai/push-todo 3.8.1 → 3.8.3

package/lib/daemon.js

@@ -901,7 +901,7 @@ async function markTaskAsCompleted(displayNumber, taskId, comment) {
  * 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) {
+async function autoHealExistingWork(displayNumber, summary, projectPath, taskId) {
   const suffix = getWorktreeSuffix();
   const branch = `push-${displayNumber}-${suffix}`;
   const gitCwd = projectPath || process.cwd();
@@ -931,7 +931,7 @@ async function autoHealExistingWork(displayNumber, summary, projectPath) {
     let prState = null;
     try {
       const prResult = execSync(
-        `gh pr list --head ${branch} --json url,state --jq '.[0]' 2>/dev/null`,
+        `gh pr list --head ${branch} --state all --json url,state --jq '.[0]' 2>/dev/null`,
         { cwd: gitCwd, timeout: 15000, stdio: ['ignore', 'pipe', 'pipe'] }
       ).toString().trim();
       if (prResult) {
@@ -950,25 +950,59 @@ async function autoHealExistingWork(displayNumber, summary, projectPath) {
       await updateTaskStatus(displayNumber, 'session_finished', {
         summary: executionSummary
       });
+
+      // Auto-complete since PR is already merged
+      let status = 'session_finished';
+      if (getAutoCompleteEnabled() && taskId) {
+        const comment = `Auto-healed: PR already merged. ${prUrl}`;
+        const completed = await markTaskAsCompleted(displayNumber, taskId, comment);
+        if (completed) {
+          log(`Task #${displayNumber}: auto-completed (PR was already merged)`);
+          status = 'completed';
+        }
+      }
+
       completedToday.push({
         displayNumber, summary,
         completedAt: new Date().toISOString(),
-        duration: 0, status: 'session_finished', prUrl
+        duration: 0, status, 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}`;
+      log(`Task #${displayNumber}: PR already open (${prUrl}), attempting merge`);
+
+      // Try to merge the existing PR
+      let merged = false;
+      if (getAutoMergeEnabled()) {
+        // Clean up worktree first so gh pr merge --delete-branch can delete the local branch
+        cleanupWorktree(displayNumber, projectPath);
+        merged = mergePRForTask(displayNumber, prUrl, projectPath);
+      }
+
+      const executionSummary = merged
+        ? `Auto-healed: previous PR merged. ${prUrl}`
+        : `Auto-healed: previous execution completed. PR pending review: ${prUrl}`;
       await updateTaskStatus(displayNumber, 'session_finished', {
         summary: executionSummary
       });
+
+      // Auto-complete if merge succeeded
+      let status = 'session_finished';
+      if (getAutoCompleteEnabled() && merged && taskId) {
+        const comment = `Auto-healed and merged. ${prUrl}`;
+        const completed = await markTaskAsCompleted(displayNumber, taskId, comment);
+        if (completed) {
+          log(`Task #${displayNumber}: auto-completed after auto-heal merge`);
+          status = 'completed';
+        }
+      }
+
       completedToday.push({
         displayNumber, summary,
         completedAt: new Date().toISOString(),
-        duration: 0, status: 'session_finished', prUrl
+        duration: 0, status, prUrl
       });
       return true;
     }
@@ -1213,7 +1247,8 @@ async function executeTask(task) {
   }
 
   // Auto-heal: check if previous execution already completed work for this task
-  const healed = await autoHealExistingWork(displayNumber, summary, projectPath);
+  const taskId = task.id || task.todo_id || '';
+  const healed = await autoHealExistingWork(displayNumber, summary, projectPath, taskId);
   if (healed) {
     log(`Task #${displayNumber}: auto-healed from previous execution, skipping re-execution`);
     return null;
@@ -1423,6 +1458,30 @@ async function handleTaskCompletion(displayNumber, exitCode) {
       merged = mergePRForTask(displayNumber, prUrl, projectPath);
     }
 
+    // Safety net: if no new PR was created (Claude found work already done),
+    // check if a previous PR for this branch was already merged.
+    // See: docs/20260211_auto_complete_failure_investigation.md (Fix D)
+    if (!prUrl && !merged) {
+      const suffix = getWorktreeSuffix();
+      const branch = `push-${displayNumber}-${suffix}`;
+      try {
+        const prCheck = execFileSync('gh', [
+          'pr', 'list', '--head', branch, '--state', 'merged',
+          '--json', 'url', '--jq', '.[0].url'
+        ], {
+          cwd: projectPath || process.cwd(),
+          timeout: 15000,
+          stdio: ['ignore', 'pipe', 'pipe']
+        }).toString().trim();
+        if (prCheck) {
+          log(`Task #${displayNumber}: found previously merged PR: ${prCheck}`);
+          merged = true;
+        }
+      } catch {
+        // gh not available or no merged PR found
+      }
+    }
+
     // Auto-complete task after successful merge (configurable, default ON)
     const taskId = info.taskId;
     if (getAutoCompleteEnabled() && merged && taskId) {
@@ -1716,6 +1775,53 @@ async function pollAndExecute() {
   updateStatusFile();
 }
 
+/**
+ * Recover tasks orphaned by a previous daemon instance.
+ * When the daemon restarts, tasks claimed by this machine may be stuck in 'running'
+ * with no process working on them. Reset them to 'queued' so the normal poll cycle
+ * picks them up and autoHeal detects prior work.
+ */
+async function recoverOrphanedTasks() {
+  const suffix = getWorktreeSuffix();
+  if (!suffix) return;
+
+  try {
+    const params = new URLSearchParams();
+    params.set('execution_status', 'running');
+
+    const response = await apiRequest(`synced-todos?${params}`);
+    if (!response.ok) return;
+
+    const data = await response.json();
+    const tasks = data.todos || [];
+
+    // Filter to tasks owned by THIS machine (branch contains our suffix)
+    const orphaned = tasks.filter(t => {
+      const branch = t.executionBranch || t.execution_branch || '';
+      return branch.endsWith(suffix);
+    });
+
+    if (orphaned.length === 0) return;
+
+    log(`Recovering ${orphaned.length} orphaned task(s) from previous daemon instance`);
+
+    for (const task of orphaned) {
+      const dn = task.displayNumber || task.display_number;
+      log(`Task #${dn}: resetting from 'running' to 'queued' (orphaned by restart)`);
+      await updateTaskStatus(dn, 'queued', {
+        event: {
+          type: 'requeued',
+          timestamp: new Date().toISOString(),
+          machineName: getMachineName() || undefined,
+          summary: 'Daemon restarted — re-queuing for auto-heal'
+        }
+      });
+    }
+  } catch (error) {
+    log(`Orphaned task recovery failed (non-fatal): ${error.message}`);
+  }
+}
+
 async function mainLoop() {
   daemonStartTime = new Date().toISOString();
 
@@ -1756,6 +1862,13 @@ async function mainLoop() {
     writeFileSync(VERSION_FILE, getVersion());
   } catch {}
 
+  // Recover orphaned tasks from previous daemon instance
+  // When the daemon restarts (self-update, crash, reboot), tasks may be stuck
+  // in 'running' with no process actually working on them. Reset them to 'queued'
+  // so the normal poll cycle picks them up and autoHeal handles the rest.
+  // See: docs/20260211_auto_complete_failure_investigation.md
+  await recoverOrphanedTasks();
+
   // Initial status
   updateStatusFile();
 

package/package.json

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