@jojonax/codex-copilot 1.4.1 → 1.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jojonax/codex-copilot",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "PRD-driven automated development orchestrator for CodeX / Cursor",
   "bin": {
     "codex-copilot": "./bin/cli.js"

package/src/commands/run.js

@@ -95,8 +95,8 @@ export async function run(projectDir) {
 
   // ===== Auto-retry blocked tasks =====
   // On each run, reset blocked tasks to pending so they're retried in order.
-  // Per-task checkpoint steps are cleared so the task starts fresh.
-  // The main checkpoint position (current_task) is preserved.
+  // Branches and checkpoint steps are PRESERVED — the task resumes from where
+  // it left off, keeping all previously developed code.
   const blockedTasks = tasks.tasks.filter(t => t.status === 'blocked');
   if (blockedTasks.length > 0) {
     log.blank();
@@ -105,30 +105,8 @@ export async function run(projectDir) {
       bt.status = 'pending';
       bt.retry_count = (bt.retry_count || 0) + 1;
       bt._retrying = true; // Flag: don't skip even if below checkpoint
-
-      // Clear per-task checkpoint steps — the task needs a fresh start
-      // (The main checkpoint.current_task is NOT affected)
-      checkpoint.clearTask(bt.id);
-
-      // Clean up old branch to avoid "branch already exists" errors
-      try {
-        git.resetBranch(projectDir, bt.branch, baseBranch);
-        log.dim(`   ↳ Task #${bt.id}: ${bt.title.substring(0, 50)} (attempt ${bt.retry_count + 1}, branch reset)`);
-      } catch {
-        // If branch cleanup fails, still let the task try
-        log.dim(`   ↳ Task #${bt.id}: ${bt.title.substring(0, 50)} (attempt ${bt.retry_count + 1})`);
-      }
-
-      // Close any existing PR for this task (stale from previous attempt)
-      if (bt.pr_number) {
-        try {
-          github.closePR(projectDir, bt.pr_number);
-          delete bt.pr_number;
-        } catch { /* ignore */ }
-      }
+      log.dim(`   ↳ Task #${bt.id}: ${bt.title.substring(0, 50)} (attempt ${bt.retry_count + 1})`);
     }
-    // Switch back to base branch after all resets
-    git.checkoutMain(projectDir, baseBranch);
     writeJSON(tasksPath, tasks);
   }
 
@@ -178,6 +156,8 @@ export async function run(projectDir) {
 
     // Mark task as in_progress
     task.status = 'in_progress';
+    const isRetry = (task.retry_count || 0) > 0;
+    const retryStartedAt = isRetry ? new Date().toISOString() : null;
     writeJSON(tasksPath, tasks);
 
     // ===== Phase 1: Develop =====
@@ -207,10 +187,19 @@ export async function run(projectDir) {
 
     // ===== Phase 3: Review loop =====
     if (!checkpoint.isStepDone(task.id, 'merge', 'merged')) {
+      // On retry: request fresh re-review since old reviews may be stale
+      if (isRetry && prInfo?.number) {
+        log.info('🔄 Retry: requesting fresh re-review on existing PR...');
+        try {
+          github.requestReReview(projectDir, prInfo.number);
+        } catch { /* ignore — review bots may not be configured */ }
+      }
+
       await reviewLoop(projectDir, task, prInfo, {
         maxRounds: maxReviewRounds,
         pollInterval,
         waitTimeout,
+        retryStartedAt, // Only count reviews after this timestamp
       }, checkpoint, providerId, isPrivate);
     } else {
       log.dim('⏩ Skipping review phase (already completed)');
@@ -220,7 +209,18 @@ export async function run(projectDir) {
     if (!checkpoint.isStepDone(task.id, 'merge', 'merged')) {
       await mergePhase(projectDir, task, prInfo, baseBranch, checkpoint);
     } else {
-      log.dim('⏩ Skipping merge phase (already merged)');
+      // Checkpoint says merged — verify against GitHub
+      if (prInfo?.number) {
+        const prState = github.getPRState(projectDir, prInfo.number);
+        if (prState !== 'merged') {
+          log.warn(`⚠ Checkpoint says merged but PR #${prInfo.number} is ${prState} — re-entering merge`);
+          await mergePhase(projectDir, task, prInfo, baseBranch, checkpoint);
+        } else {
+          log.dim('⏩ Skipping merge phase (PR confirmed merged on GitHub)');
+        }
+      } else {
+        log.dim('⏩ Skipping merge phase (already merged)');
+      }
     }
 
     // Check if task was blocked during review/merge
@@ -379,7 +379,7 @@ async function prPhase(projectDir, task, baseBranch, checkpoint, isPrivate) {
 // ──────────────────────────────────────────────
 // Phase 3: Review loop
 // ──────────────────────────────────────────────
-async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pollInterval, waitTimeout }, checkpoint, providerId, isPrivate) {
+async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pollInterval, waitTimeout, retryStartedAt }, checkpoint, providerId, isPrivate) {
   const HARD_MAX_ROUNDS = 5;
   const MAX_POLL_RETRIES = 3;
   let maxRounds = Math.min(_maxRounds, HARD_MAX_ROUNDS);
@@ -410,8 +410,19 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
     // and fast bot responses after fix pushes.
     const existingReviews = github.getReviews(projectDir, prInfo.number);
     const existingComments = github.getIssueComments(projectDir, prInfo.number);
-    const hasReview = existingReviews.some(r => r.state !== 'PENDING');
-    const hasBotComment = existingComments.some(c =>
+
+    // On retry: only count reviews posted AFTER the retry started
+    const isReviewFresh = (item) => {
+      if (!retryStartedAt) return true; // Not a retry — all reviews are valid
+      const itemDate = item.submitted_at || item.created_at || item.updated_at;
+      return itemDate && new Date(itemDate) > new Date(retryStartedAt);
+    };
+
+    const freshReviews = existingReviews.filter(isReviewFresh);
+    const freshComments = existingComments.filter(isReviewFresh);
+
+    const hasReview = freshReviews.some(r => r.state !== 'PENDING');
+    const hasBotComment = freshComments.some(c =>
       c.user?.type === 'Bot' || c.user?.login?.includes('bot')
     );
 

package/src/utils/git.js

@@ -52,48 +52,41 @@ export function getRepoInfo(cwd) {
   return { owner: match[1], repo: match[2] };
 }
 
-/**
- * Switch to target branch (create if not exists)
- */
 export function checkoutBranch(cwd, branch, baseBranch = 'main') {
   validateBranch(branch);
   validateBranch(baseBranch);
   const current = currentBranch(cwd);
   if (current === branch) return;
 
-  // Switch to base and pull latest
-  execSafe(`git checkout ${baseBranch}`, cwd);
-  execSafe(`git pull origin ${baseBranch}`, cwd);
+  // Stash any uncommitted changes to allow safe branch switching
+  const hasChanges = !isClean(cwd);
+  if (hasChanges) {
+    execSafe('git stash --include-untracked', cwd);
+  }
 
-  // Try to switch to existing branch
-  const result = execSafe(`git checkout ${branch}`, cwd);
-  if (!result.ok) {
-    // Branch doesn't exist or checkout failed — clean up and create fresh
-    execSafe(`git branch -D ${branch}`, cwd); // Delete if exists but broken
+  // Check if the branch already exists locally
+  const branchExists = execSafe(`git rev-parse --verify ${branch}`, cwd).ok;
+
+  if (branchExists) {
+    // Branch exists — just switch to it (preserving all previous work)
+    exec(`git checkout ${branch}`, cwd);
+
+    // Try to rebase onto latest base to pick up any new changes
+    execSafe(`git fetch origin ${baseBranch}`, cwd);
+    execSafe(`git rebase origin/${baseBranch}`, cwd);
+    // If rebase fails (conflicts), abort and continue with existing state
+    execSafe('git rebase --abort', cwd);
+  } else {
+    // Branch doesn't exist — create from latest base
+    execSafe(`git checkout ${baseBranch}`, cwd);
+    execSafe(`git pull origin ${baseBranch}`, cwd);
     exec(`git checkout -b ${branch}`, cwd);
   }
-}
-
-/**
- * Delete a branch (local + remote) and recreate fresh from base.
- * Used when retrying blocked tasks to ensure a clean slate.
- */
-export function resetBranch(cwd, branch, baseBranch = 'main') {
-  validateBranch(branch);
-  validateBranch(baseBranch);
-
-  // Switch to base first (can't delete current branch)
-  execSafe(`git checkout ${baseBranch}`, cwd);
-  execSafe(`git pull origin ${baseBranch}`, cwd);
-
-  // Delete local branch (force, ignore errors if doesn't exist)
-  execSafe(`git branch -D ${branch}`, cwd);
 
-  // Delete remote branch (ignore errors if doesn't exist)
-  execSafe(`git push origin --delete ${branch}`, cwd);
-
-  // Create fresh branch from base
-  exec(`git checkout -b ${branch}`, cwd);
+  // Restore stashed changes if we stashed earlier
+  if (hasChanges) {
+    execSafe('git stash pop', cwd);
+  }
 }
 
 /**
@@ -135,6 +128,6 @@ export function checkoutMain(cwd, baseBranch = 'main') {
 }
 
 export const git = {
-  isClean, currentBranch, getRepoInfo, checkoutBranch, resetBranch,
+  isClean, currentBranch, getRepoInfo, checkoutBranch,
   commitAll, pushBranch, checkoutMain, exec, execSafe,
 };

package/src/utils/github.js

@@ -383,7 +383,7 @@ export const github = {
   ensureRemoteBranch, hasCommitsBetween,
   getReviews, getReviewComments, getIssueComments,
   getLatestReviewState, mergePR, collectReviewFeedback,
-  isPrivateRepo, requestReReview, closePR, deleteBranch,
+  isPrivateRepo, requestReReview, closePR, deleteBranch, getPRState,
 };
 
 /**
@@ -412,3 +412,18 @@ export function deleteBranch(cwd, branch) {
     return false;
   }
 }
+
+/**
+ * Get the state of a PR: 'open', 'closed', or 'merged'
+ */
+export function getPRState(cwd, prNumber) {
+  try {
+    const num = validatePRNumber(prNumber);
+    const output = gh(`pr view ${num} --json state,mergedAt`, cwd);
+    const data = JSON.parse(output);
+    if (data.mergedAt) return 'merged';
+    return (data.state || 'OPEN').toLowerCase();
+  } catch {
+    return 'unknown';
+  }
+}