@jojonax/codex-copilot 1.3.3 → 1.3.5

package/bin/cli.js

@@ -20,6 +20,8 @@ import { init } from '../src/commands/init.js';
 import { run } from '../src/commands/run.js';
 import { status } from '../src/commands/status.js';
 import { reset } from '../src/commands/reset.js';
+import { retry } from '../src/commands/retry.js';
+import { skip } from '../src/commands/skip.js';
 import { log } from '../src/utils/logger.js';
 import { checkForUpdates } from '../src/utils/update-check.js';
 
@@ -61,12 +63,38 @@ async function main() {
           process.exit(1);
         }
         await status(projectDir);
+        process.exit(0);
         break;
 
       case 'reset':
         await reset(projectDir);
+        process.exit(0);
         break;
 
+      case 'retry':
+        if (!existsSync(resolve(projectDir, '.codex-copilot/tasks.json'))) {
+          log.error('Not initialized. Run: codex-copilot init');
+          process.exit(1);
+        }
+        await retry(projectDir);
+        process.exit(0);
+        break;
+
+      case 'skip': {
+        if (!existsSync(resolve(projectDir, '.codex-copilot/tasks.json'))) {
+          log.error('Not initialized. Run: codex-copilot init');
+          process.exit(1);
+        }
+        const skipTaskId = process.argv[3];
+        if (!skipTaskId) {
+          log.error('Usage: codex-copilot skip <task_id>');
+          process.exit(1);
+        }
+        await skip(projectDir, skipTaskId);
+        process.exit(0);
+        break;
+      }
+
       case 'update':
         log.info('Updating to latest version...');
         try {
@@ -75,8 +103,18 @@ async function main() {
         } catch {
           log.error('Update failed. Try manually: npm install -g @jojonax/codex-copilot@latest --force');
         }
+        process.exit(0);
         break;
 
+      case '--version':
+      case '-v':
+        console.log(`v${version}`);
+        process.exit(0);
+        break;
+
+      case 'help':
+      case '--help':
+      case '-h':
       default:
         console.log('  Usage: codex-copilot <command>');
         console.log('');
@@ -85,6 +123,8 @@ async function main() {
         console.log('    run       Start automated development loop');
         console.log('    status    View current task progress');
         console.log('    reset     Reset state and start over');
+        console.log('    retry     Retry blocked tasks with enhanced prompts');
+        console.log('    skip <id> Force-skip a task to unblock dependents');
         console.log('    update    Update to latest version');
         console.log('');
         console.log('  Workflow:');
@@ -92,12 +132,9 @@ async function main() {
         console.log('    2. codex-copilot init    (auto-detect PRD and decompose tasks)');
         console.log('    3. codex-copilot run     (start automated dev loop)');
         console.log('');
-        console.log('  Update:');
-        console.log('    npm install -g @jojonax/codex-copilot@latest');
-        console.log('');
         console.log('  \x1b[36mⓘ  This is a help page. Exit and run the commands above directly in your terminal.\x1b[0m');
         console.log('');
-        break;
+        process.exit(0);
     }
   } catch (err) {
     log.error(`Execution failed: ${err.message}`);

package/package.json

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

package/src/commands/retry.js

@@ -0,0 +1,158 @@
+/**
+ * codex-copilot retry - Reset blocked tasks for re-execution
+ *
+ * Recovery strategy per block scenario:
+ *   Dev-blocked:    Save partial context, reset to pending
+ *   Review-blocked: Close PR, delete branch, save review feedback, reset to pending
+ *   Merge-blocked:  Reset only the merge step
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { log, progressBar } from '../utils/logger.js';
+import { git } from '../utils/git.js';
+import { github } from '../utils/github.js';
+import { createCheckpoint } from '../utils/checkpoint.js';
+
+function readJSON(path) {
+  return JSON.parse(readFileSync(path, 'utf-8'));
+}
+
+function writeJSON(path, data) {
+  writeFileSync(path, JSON.stringify(data, null, 2));
+}
+
+export async function retry(projectDir) {
+  const tasksPath = resolve(projectDir, '.codex-copilot/tasks.json');
+  const checkpoint = createCheckpoint(projectDir);
+  const retryDir = resolve(projectDir, '.codex-copilot/retry_context');
+
+  let tasks;
+  try {
+    tasks = readJSON(tasksPath);
+  } catch (err) {
+    log.error(`Failed to read tasks: ${err.message}`);
+    process.exit(1);
+  }
+
+  const blocked = tasks.tasks.filter(t => t.status === 'blocked');
+
+  if (blocked.length === 0) {
+    log.info('No blocked tasks found \u2014 nothing to retry.');
+    return;
+  }
+
+  log.title('\ud83d\udd04 Blocked Task Recovery');
+  log.blank();
+  log.info(`Found ${blocked.length} blocked task(s):`);
+  log.blank();
+
+  // Ensure retry context directory exists
+  mkdirSync(retryDir, { recursive: true });
+
+  for (const task of blocked) {
+    const reason = task.block_reason || 'unknown';
+    log.info(`  #${task.id}: ${task.title}`);
+    log.dim(`       Reason: ${reason}`);
+
+    if (reason === 'review_failed') {
+      await recoverReviewBlocked(projectDir, task, checkpoint, retryDir);
+    } else if (reason === 'merge_failed') {
+      recoverMergeBlocked(task, checkpoint);
+    } else {
+      // dev_failed or unknown
+      recoverDevBlocked(projectDir, task, checkpoint, retryDir);
+    }
+
+    task.status = 'pending';
+    task.retry_count = (task.retry_count || 0) + 1;
+    log.info(`  \u2705 Task #${task.id} reset to pending (retry #${task.retry_count})`);
+    log.blank();
+  }
+
+  writeJSON(tasksPath, tasks);
+
+  log.blank();
+  const done = tasks.tasks.filter(t => t.status === 'completed').length;
+  const pending = tasks.tasks.filter(t => t.status === 'pending').length;
+  progressBar(done, tasks.total, `${done}/${tasks.total} done, ${pending} pending`);
+  log.blank();
+  log.info('Run `codex-copilot run` to resume with enhanced prompts.');
+}
+
+/**
+ * Dev-blocked: save any partial work context, clear checkpoints
+ */
+function recoverDevBlocked(projectDir, task, checkpoint, retryDir) {
+  // Try to capture any partial diff from the branch
+  const diffResult = git.execSafe(`git diff HEAD`, projectDir);
+  if (diffResult.ok && diffResult.output.trim()) {
+    const contextPath = resolve(retryDir, `${task.id}.md`);
+    writeFileSync(contextPath, [
+      `# Retry Context for Task #${task.id}`,
+      '',
+      '## Previous Attempt',
+      'The AI attempted this task but failed to produce working code.',
+      'Try a simpler, more incremental approach.',
+      '',
+      '## Partial Changes (from failed attempt)',
+      '```diff',
+      diffResult.output.substring(0, 5000), // Cap at 5KB
+      '```',
+    ].join('\n'));
+    log.dim('       Saved partial diff as retry context');
+  }
+
+  // Clear all checkpoints for this task
+  checkpoint.clearTask(task.id);
+}
+
+/**
+ * Review-blocked: close PR, delete branch, save review feedback
+ */
+async function recoverReviewBlocked(projectDir, task, checkpoint, retryDir) {
+  const state = checkpoint.load();
+  const prNumber = state.current_pr;
+
+  // Save review feedback as retry context
+  if (prNumber) {
+    const feedback = github.collectReviewFeedback(projectDir, prNumber);
+    if (feedback) {
+      const contextPath = resolve(retryDir, `${task.id}.md`);
+      writeFileSync(contextPath, [
+        `# Retry Context for Task #${task.id}`,
+        '',
+        '## Known Issues from Previous Review',
+        'The previous implementation was rejected. Avoid making the same mistakes.',
+        '',
+        feedback,
+      ].join('\n'));
+      log.dim('       Saved review feedback as retry context');
+    }
+
+    // Close the stale PR
+    if (github.closePR(projectDir, prNumber)) {
+      log.dim(`       Closed stale PR #${prNumber}`);
+    }
+  }
+
+  // Delete the remote feature branch
+  if (task.branch) {
+    if (github.deleteBranch(projectDir, task.branch)) {
+      log.dim(`       Deleted remote branch ${task.branch}`);
+    }
+    // Delete local branch too
+    git.execSafe(`git branch -D ${task.branch}`, projectDir);
+  }
+
+  // Clear all checkpoints for this task
+  checkpoint.clearTask(task.id);
+}
+
+/**
+ * Merge-blocked: only reset the merge step
+ */
+function recoverMergeBlocked(task, checkpoint) {
+  checkpoint.clearStep(task.id, 'merge', 'merged');
+  log.dim('       Reset merge step \u2014 will retry merge on next run');
+}

package/src/commands/run.js

@@ -53,6 +53,7 @@ export async function run(projectDir) {
   const maxReviewRounds = config.max_review_rounds || 2;
   const pollInterval = config.review_poll_interval || 60;
   const waitTimeout = config.review_wait_timeout || 600;
+  const isPrivate = github.isPrivateRepo(projectDir); // Cache once
 
   const providerInfo = provider.getProvider(providerId);
   log.info(`AI Provider: ${providerInfo ? providerInfo.name : providerId}`);
@@ -110,16 +111,27 @@ export async function run(projectDir) {
     log.title(`━━━ Task ${task.id}/${tasks.total}: ${task.title} ━━━`);
     log.blank();
 
-    // Check dependencies
+    // Check dependencies — completed, skipped, and blocked all satisfy dependencies.
+    // Blocked tasks are treated as "done for now" to prevent cascade-skipping;
+    // the user can retry them later with `codex-copilot retry`.
     if (task.depends_on && task.depends_on.length > 0) {
+      const DONE_STATUSES = ['completed', 'skipped', 'blocked'];
       const unfinished = task.depends_on.filter(dep => {
         const depTask = tasks.tasks.find(t => t.id === dep);
-        return depTask && depTask.status !== 'completed';
+        return depTask && !DONE_STATUSES.includes(depTask.status);
       });
       if (unfinished.length > 0) {
         log.warn(`Unfinished dependencies: ${unfinished.join(', ')} — skipping`);
         continue;
       }
+      // Warn about blocked deps but still proceed
+      const blockedDeps = task.depends_on.filter(dep => {
+        const depTask = tasks.tasks.find(t => t.id === dep);
+        return depTask && depTask.status === 'blocked';
+      });
+      if (blockedDeps.length > 0) {
+        log.warn(`⚠ Dependencies ${blockedDeps.join(', ')} are blocked — proceeding anyway`);
+      }
     }
 
     // Mark task as in_progress
@@ -129,6 +141,13 @@ export async function run(projectDir) {
     // ===== Phase 1: Develop =====
     if (!checkpoint.isStepDone(task.id, 'develop', 'codex_complete')) {
       await developPhase(projectDir, task, baseBranch, checkpoint, providerId);
+      // If dev phase failed, mark blocked and skip to next task
+      if (task.status === 'blocked') {
+        writeJSON(tasksPath, tasks);
+        log.blank();
+        log.warn(`⚠ Task #${task.id} is blocked — AI development failed`);
+        continue;
+      }
     } else {
       log.dim('⏩ Skipping develop phase (already completed)');
     }
@@ -136,7 +155,7 @@ export async function run(projectDir) {
     // ===== Phase 2: Create PR =====
     let prInfo;
     if (!checkpoint.isStepDone(task.id, 'pr', 'pr_created')) {
-      prInfo = await prPhase(projectDir, task, baseBranch, checkpoint);
+      prInfo = await prPhase(projectDir, task, baseBranch, checkpoint, isPrivate);
     } else {
       // PR already created, load from state
       state = checkpoint.load();
@@ -150,7 +169,7 @@ export async function run(projectDir) {
         maxRounds: maxReviewRounds,
         pollInterval,
         waitTimeout,
-      }, checkpoint, providerId);
+      }, checkpoint, providerId, isPrivate);
     } else {
       log.dim('⏩ Skipping review phase (already completed)');
     }
@@ -176,6 +195,8 @@ export async function run(projectDir) {
 
     // Mark task complete
     task.status = 'completed';
+    delete task.block_reason;
+    delete task.retry_count;
     writeJSON(tasksPath, tasks);
     checkpoint.completeTask(task.id);
 
@@ -186,7 +207,13 @@ export async function run(projectDir) {
   }
 
   log.blank();
-  log.title('🎉 All tasks complete!');
+  const finalDone = tasks.tasks.filter(t => t.status === 'completed').length;
+  const finalBlocked = tasks.tasks.filter(t => t.status === 'blocked').length;
+  if (finalBlocked > 0) {
+    log.title(`✅ Finished — ${finalDone}/${tasks.total} done, ${finalBlocked} blocked`);
+  } else {
+    log.title('🎉 All tasks complete!');
+  }
   log.blank();
   process.removeListener('SIGINT', gracefulShutdown);
   process.removeListener('SIGTERM', gracefulShutdown);
@@ -215,7 +242,7 @@ async function developPhase(projectDir, task, baseBranch, checkpoint, providerId
 
   // Step 2: Build development prompt
   if (!checkpoint.isStepDone(task.id, 'develop', 'prompt_ready')) {
-    const devPrompt = buildDevPrompt(task);
+    const devPrompt = buildDevPrompt(task, projectDir);
     const promptPath = resolve(projectDir, '.codex-copilot/_current_prompt.md');
     writeFileSync(promptPath, devPrompt);
     checkpoint.saveStep(task.id, 'develop', 'prompt_ready', { branch: task.branch });
@@ -231,6 +258,11 @@ async function developPhase(projectDir, task, baseBranch, checkpoint, providerId
     if (ok) {
       log.info('Development complete');
       checkpoint.saveStep(task.id, 'develop', 'codex_complete', { branch: task.branch });
+    } else {
+      log.error('AI development failed — marking task as blocked');
+      task.status = 'blocked';
+      task.block_reason = 'dev_failed';
+      return;
     }
   }
 }
@@ -238,14 +270,15 @@ async function developPhase(projectDir, task, baseBranch, checkpoint, providerId
 // ──────────────────────────────────────────────
 // Phase 2: Create PR
 // ──────────────────────────────────────────────
-async function prPhase(projectDir, task, baseBranch, checkpoint) {
+async function prPhase(projectDir, task, baseBranch, checkpoint, isPrivate) {
   log.step('Phase 2/4: Submit PR');
 
   // Step 1: Commit changes
   if (!checkpoint.isStepDone(task.id, 'pr', 'committed')) {
     if (!git.isClean(projectDir)) {
       log.info('Uncommitted changes detected, auto-committing...');
-      git.commitAll(projectDir, `feat(task-${task.id}): ${task.title}`);
+      const skipCI = isPrivate ? ' [skip ci]' : '';
+      git.commitAll(projectDir, `feat(task-${task.id}): ${task.title}${skipCI}`);
     }
     checkpoint.saveStep(task.id, 'pr', 'committed', { branch: task.branch });
     log.info('Changes committed');
@@ -293,7 +326,7 @@ async function prPhase(projectDir, task, baseBranch, checkpoint) {
 // ──────────────────────────────────────────────
 // Phase 3: Review loop
 // ──────────────────────────────────────────────
-async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pollInterval, waitTimeout }, checkpoint, providerId) {
+async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pollInterval, waitTimeout }, checkpoint, providerId, isPrivate) {
   const HARD_MAX_ROUNDS = 5;
   const MAX_POLL_RETRIES = 3;
   let maxRounds = Math.min(_maxRounds, HARD_MAX_ROUNDS);
@@ -319,26 +352,41 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
 
     let gotReview = false;
 
-    // Round 1 (or resume): proactively check for existing reviews.
-    // After a fix push (round > 1): ONLY wait for NEW reviews
-    // to avoid re-processing the same stale feedback in a loop.
-    if (round <= 1 || round === startRound) {
-      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 =>
-        c.user?.type === 'Bot' || c.user?.login?.includes('bot')
-      );
-
-      if (hasReview || hasBotComment) {
-        log.info('Review found — processing immediately');
-        gotReview = true;
-      }
+    // Always proactively check for existing reviews first.
+    // This catches: already-posted bot reviews, stale reviews found on resume,
+    // 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 =>
+      c.user?.type === 'Bot' || c.user?.login?.includes('bot')
+    );
+
+    if (hasReview || hasBotComment) {
+      log.info('Review found — processing immediately');
+      gotReview = true;
     }
 
     if (!gotReview) {
-      log.info(`Waiting for ${round > 1 ? 'new ' : ''}review... (timeout: ${waitTimeout}s)`);
-      gotReview = await waitForReview(projectDir, prInfo.number, pollInterval, waitTimeout);
+      // After fix pushes (round > 1), bot should respond quickly if configured.
+      // Use shorter timeout to avoid wasting 10+ minutes waiting for nothing.
+      const effectiveTimeout = round > 1 ? Math.min(waitTimeout, 120) : waitTimeout;
+      log.info(`Waiting for ${round > 1 ? 'new ' : ''}review... (timeout: ${effectiveTimeout}s)`);
+      gotReview = await waitForReview(projectDir, prInfo.number, pollInterval, effectiveTimeout);
+    }
+
+    if (!gotReview) {
+      // Before giving up, do one last proactive check
+      const lastChance = github.getLatestReviewState(projectDir, prInfo.number);
+      if (lastChance === 'APPROVED') {
+        log.info('✅ Review approved (found on final check)!');
+        return;
+      }
+      const lastFeedback = github.collectReviewFeedback(projectDir, prInfo.number);
+      if (lastFeedback) {
+        log.info('Found existing feedback — processing');
+        gotReview = true;
+      }
     }
 
     if (!gotReview) {
@@ -346,6 +394,7 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
       if (pollRetries >= MAX_POLL_RETRIES) {
         log.error(`Review polling timed out ${MAX_POLL_RETRIES} times — marking task as blocked`);
         task.status = 'blocked';
+        task.block_reason = 'review_timeout';
         return;
       }
       log.warn(`Review wait timed out — auto-retrying (${pollRetries}/${MAX_POLL_RETRIES})...`);
@@ -435,7 +484,7 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
 
     // Push fix — only if there are actual changes
     if (!git.isClean(projectDir)) {
-      const skipCI = github.isPrivateRepo(projectDir) ? ' [skip ci]' : '';
+      const skipCI = isPrivate ? ' [skip ci]' : '';
       git.commitAll(projectDir, `fix(task-${task.id}): address review comments (round ${round})${skipCI}`);
       git.pushBranch(projectDir, task.branch);
       log.info('Fix pushed');
@@ -451,6 +500,7 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
       log.error('AI fix produced no changes — marking task as blocked');
       log.error('This task needs manual code changes to resolve review issues');
       task.status = 'blocked';
+      task.block_reason = 'review_failed';
       return;
     }
   }
@@ -459,6 +509,17 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
 async function waitForReview(projectDir, prNumber, pollInterval, timeout) {
   let elapsed = 0;
   const startReviewCount = github.getReviews(projectDir, prNumber).length;
+  const startCommentCount = github.getIssueComments(projectDir, prNumber).length;
+
+  // Spinner for visual feedback during polling
+  const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let spinIdx = 0;
+  const spinTimer = setInterval(() => {
+    const frame = SPINNER[spinIdx % SPINNER.length];
+    const remaining = Math.max(0, timeout - elapsed);
+    process.stdout.write(`\r\x1b[K  \x1b[36m${frame}\x1b[0m Waiting for review... (${remaining}s remaining)`);
+    spinIdx++;
+  }, 80);
 
   while (elapsed < timeout) {
     await sleep(pollInterval * 1000);
@@ -467,20 +528,18 @@ async function waitForReview(projectDir, prNumber, pollInterval, timeout) {
     const currentReviews = github.getReviews(projectDir, prNumber);
     const currentComments = github.getIssueComments(projectDir, prNumber);
 
-    // Check for new reviews or bot comments
     const hasNewReview = currentReviews.length > startReviewCount;
-    const hasBotComment = currentComments.some(c =>
-      (c.user?.type === 'Bot' || c.user?.login?.includes('bot')) &&
-      new Date(c.created_at).getTime() > (Date.now() - elapsed * 1000)
-    );
+    const hasNewBotComment = currentComments.length > startCommentCount &&
+      currentComments.some(c => c.user?.type === 'Bot' || c.user?.login?.includes('bot'));
 
-    if (hasNewReview || hasBotComment) {
+    if (hasNewReview || hasNewBotComment) {
+      clearInterval(spinTimer);
+      process.stdout.write('\r\x1b[K');
       return true;
     }
-
-    process.stdout.write('.');
   }
-  console.log('');
+  clearInterval(spinTimer);
+  process.stdout.write('\r\x1b[K');
   return false;
 }
 
@@ -499,7 +558,7 @@ ${feedback}
 1. Fix each issue listed above
 2. Suggestions (non-blocking) can be skipped — explain why in the commit message
 3. Ensure fixes don't introduce new issues
-4. When done, run: git add -A && git commit -m "fix(task-${task.id}): address review round ${round}"
+4. Do NOT run git add or git commit — the automation handles committing
 `;
 
   // Save to file and execute via provider
@@ -543,6 +602,7 @@ async function mergePhase(projectDir, task, prInfo, baseBranch, checkpoint) {
   if (!merged) {
     log.error('Merge failed after 3 attempts — marking task as blocked');
     task.status = 'blocked';
+    task.block_reason = 'merge_failed';
     return;
   }
 
@@ -598,25 +658,33 @@ async function ensureBaseReady(projectDir, baseBranch) {
   log.info(`Base branch '${baseBranch}' ready ✓`);
 }
 
-function buildDevPrompt(task) {
+function buildDevPrompt(task, projectDir) {
   const acceptanceList = Array.isArray(task.acceptance) && task.acceptance.length > 0
     ? task.acceptance.map(a => `- ${a}`).join('\n')
     : '- Feature works correctly';
+
+  let retrySection = '';
+  if (projectDir) {
+    const retryContextPath = resolve(projectDir, `.codex-copilot/retry_context/${task.id}.md`);
+    if (existsSync(retryContextPath)) {
+      const retryContext = readFileSync(retryContextPath, 'utf-8');
+      retrySection = `\n## ⚠️ Retry Context (from previous failed attempt)\n${retryContext}\n`;
+    }
+  }
+
   return `Please complete the following development task:
 
 ## Task #${task.id}: ${task.title}
 
 ${task.description}
-
+${retrySection}
 ## Acceptance Criteria
 ${acceptanceList}
 
 ## Requirements
 1. Strictly follow the project's existing code style and tech stack
 2. Ensure the code compiles/runs correctly when done
-3. When done, run:
-   git add -A
-   git commit -m "feat(task-${task.id}): ${task.title}"
+3. Do NOT run git add or git commit — the automation handles committing
 `;
 }
 

package/src/commands/skip.js

@@ -0,0 +1,68 @@
+/**
+ * codex-copilot skip <task_id> - Force-skip a blocked task
+ *
+ * Marks a blocked/pending task as 'skipped' so that tasks
+ * depending on it can proceed. Use when a task is permanently
+ * stuck and downstream work should continue regardless.
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { log } from '../utils/logger.js';
+
+function readJSON(path) {
+  return JSON.parse(readFileSync(path, 'utf-8'));
+}
+
+function writeJSON(path, data) {
+  writeFileSync(path, JSON.stringify(data, null, 2));
+}
+
+export async function skip(projectDir, taskId) {
+  const tasksPath = resolve(projectDir, '.codex-copilot/tasks.json');
+
+  let tasks;
+  try {
+    tasks = readJSON(tasksPath);
+  } catch (err) {
+    log.error(`Failed to read tasks: ${err.message}`);
+    process.exit(1);
+  }
+
+  const id = parseInt(taskId, 10);
+  if (isNaN(id)) {
+    log.error('Invalid task ID. Usage: codex-copilot skip <task_id>');
+    process.exit(1);
+  }
+
+  const task = tasks.tasks.find(t => t.id === id);
+  if (!task) {
+    log.error(`Task #${id} not found`);
+    process.exit(1);
+  }
+
+  if (task.status === 'completed') {
+    log.info(`Task #${id} is already completed — no action needed`);
+    return;
+  }
+
+  if (task.status === 'skipped') {
+    log.info(`Task #${id} is already skipped`);
+    return;
+  }
+
+  // Find downstream tasks that depend on this one
+  const downstream = tasks.tasks.filter(t =>
+    t.depends_on && t.depends_on.includes(id)
+  );
+
+  task.status = 'skipped';
+  writeJSON(tasksPath, tasks);
+
+  log.info(`\u2705 Task #${id} marked as skipped: ${task.title}`);
+  if (downstream.length > 0) {
+    log.info(`   ${downstream.length} downstream task(s) unblocked: ${downstream.map(t => `#${t.id}`).join(', ')}`);
+  }
+  log.blank();
+  log.info('Run `codex-copilot run` to continue.');
+}

package/src/utils/checkpoint.js

@@ -112,7 +112,38 @@ export function createCheckpoint(projectDir) {
     return state;
   }
 
-  return { load, save, saveStep, completeTask, isStepDone, reset };
+  /**
+   * Clear all checkpoint data for a task (for retry)
+   */
+  function clearTask(taskId) {
+    const state = load();
+    if (state.current_task === taskId) {
+      return save({
+        phase: null,
+        phase_step: null,
+        current_pr: null,
+        review_round: 0,
+        branch: null,
+      });
+    }
+    return state;
+  }
+
+  /**
+   * Clear a specific phase step (for partial retry, e.g. merge-only)
+   */
+  function clearStep(taskId, phase, phaseStep) {
+    const state = load();
+    if (state.current_task === taskId && state.phase === phase && state.phase_step === phaseStep) {
+      return save({
+        phase: null,
+        phase_step: null,
+      });
+    }
+    return state;
+  }
+
+  return { load, save, saveStep, completeTask, isStepDone, reset, clearTask, clearStep };
 }
 
 function getDefaultState() {

package/src/utils/github.js

@@ -311,7 +311,8 @@ export function isPrivateRepo(cwd) {
  */
 export function requestReReview(cwd, prNumber) {
   try {
-    gh(`pr comment ${prNumber} --body "/review"`, cwd);
+    const num = validatePRNumber(prNumber);
+    gh(`pr comment ${num} --body "/review"`, cwd);
     return true;
   } catch {
     return false;
@@ -323,5 +324,32 @@ export const github = {
   ensureRemoteBranch, hasCommitsBetween,
   getReviews, getReviewComments, getIssueComments,
   getLatestReviewState, mergePR, collectReviewFeedback,
-  isPrivateRepo, requestReReview,
+  isPrivateRepo, requestReReview, closePR, deleteBranch,
 };
+
+/**
+ * Close a pull request without merging
+ */
+export function closePR(cwd, prNumber) {
+  try {
+    const num = validatePRNumber(prNumber);
+    gh(`pr close ${num}`, cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Delete a remote branch
+ */
+export function deleteBranch(cwd, branch) {
+  try {
+    execSync(`git push origin --delete ${branch}`, {
+      cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/provider.js

@@ -9,7 +9,7 @@
  *   - Codex Desktop / Cursor IDE / Antigravity IDE: clipboard + manual
  */
 
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import { readFileSync, writeFileSync } from 'fs';
 import { resolve } from 'path';
 import { log } from './logger.js';
@@ -196,7 +196,9 @@ export async function executePrompt(providerId, promptPath, cwd) {
 }
 
 /**
- * Execute via CLI provider — each tool has its own command pattern
+ * Execute via CLI provider — each tool has its own command pattern.
+ * Output is captured and filtered to show only file-level progress,
+ * keeping the terminal clean (like Claude Code's compact display).
  */
 async function executeCLI(prov, providerId, promptPath, cwd) {
   // Verify the CLI is still available
@@ -214,24 +216,71 @@ async function executeCLI(prov, providerId, promptPath, cwd) {
 
   const command = prov.buildCommand(promptPath, cwd);
   log.info(`Executing via ${prov.name}...`);
-  log.dim(`  → ${command.substring(0, 80)}${command.length > 80 ? '...' : ''}`);
+  log.dim(`  \u2192 ${command.substring(0, 80)}${command.length > 80 ? '...' : ''}`);
 
-  try {
-    execSync(command, { cwd, stdio: 'inherit', timeout: 0 });
-    log.info(`${prov.name} execution complete`);
-    return true;
-  } catch (err) {
-    log.warn(`${prov.name} execution failed: ${err.message}`);
+  return new Promise((resolvePromise) => {
+    const child = spawn('sh', ['-c', command], {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
 
-    // For quota exhaustion / auth errors, give a clear message
-    if (err.message.includes('rate_limit') || err.message.includes('quota') ||
-        err.message.includes('429') || err.message.includes('insufficient')) {
-      log.error('⚠ Possible quota exhaustion — checkpoint saved, you can resume later');
+    let lastFile = '';
+    let statusText = 'Working...';
+    let lineBuffer = '';
+    const FILE_EXT = /(?:^|\s|['"|(/])([a-zA-Z0-9_.\/-]+\.(?:rs|ts|js|jsx|tsx|py|go|toml|yaml|yml|json|md|css|html|sh|sql|prisma|vue|svelte))\b/;
+
+    // Spinner animation — gives a dynamic, alive feel
+    const SPINNER = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F'];
+    let spinIdx = 0;
+    const spinTimer = setInterval(() => {
+      const frame = SPINNER[spinIdx % SPINNER.length];
+      process.stdout.write(`\r\x1b[K  \x1b[36m${frame}\x1b[0m ${statusText}`);
+      spinIdx++;
+    }, 80);
+
+    function processLine(line) {
+      const fileMatch = line.match(FILE_EXT);
+      if (fileMatch && fileMatch[1] !== lastFile) {
+        lastFile = fileMatch[1];
+        statusText = lastFile;
+      }
     }
 
-    log.warn('Falling back to clipboard mode');
-    return await clipboardFallback(promptPath);
-  }
+    child.stdout.on('data', (data) => {
+      lineBuffer += data.toString();
+      const lines = lineBuffer.split('\n');
+      lineBuffer = lines.pop();
+      for (const line of lines) processLine(line);
+    });
+
+    child.stderr.on('data', (data) => {
+      const text = data.toString().trim();
+      if (text && !text.includes('\u2588') && !text.includes('progress')) {
+        for (const line of text.split('\n').slice(0, 3)) {
+          if (line.trim()) log.dim(`  ${line.substring(0, 120)}`);
+        }
+      }
+    });
+
+    child.on('close', (code) => {
+      clearInterval(spinTimer);
+      process.stdout.write('\r\x1b[K');
+      if (code === 0) {
+        log.info(`${prov.name} execution complete`);
+        resolvePromise(true);
+      } else {
+        log.warn(`${prov.name} exited with code ${code}`);
+        resolvePromise(false);
+      }
+    });
+
+    child.on('error', (err) => {
+      clearInterval(spinTimer);
+      process.stdout.write('\r\x1b[K');
+      log.warn(`${prov.name} execution failed: ${err.message}`);
+      resolvePromise(false);
+    });
+  });
 }
 
 /**