create-claude-workspace 2.3.8 → 2.3.10

package/dist/scheduler/git/ci-watcher.mjs

@@ -1,11 +1,15 @@
 // ─── CI pipeline status polling ───
 // Uses gh/glab CLI to watch pipeline status after push.
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 const POLL_INTERVAL = 15_000;
 const MAX_POLL_TIME = 30 * 60_000; // 30 minutes
+const CLI_TIMEOUT = 15_000;
+function run(cmd, args, cwd, timeout = CLI_TIMEOUT) {
+    return execFileSync(cmd, args, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout }).trim();
+}
 export function detectCIPlatform(projectDir) {
     try {
-        const remote = execSync('git remote get-url origin', { cwd: projectDir, encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const remote = run('git', ['remote', 'get-url', 'origin'], projectDir);
         if (remote.includes('github.com') || remote.includes('github:'))
             return 'github';
         if (remote.includes('gitlab.com') || remote.includes('gitlab:') || remote.includes('gitlab'))
@@ -51,13 +55,13 @@ export async function watchPipeline(branch, platform, projectDir, logger, signal
 }
 function pollGitHub(branch, cwd, logger) {
     try {
-        const output = execSync(`gh run list --branch "${branch}" --limit 1 --json status,conclusion`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 15_000 }).trim();
+        const output = run('gh', ['run', 'list', '--branch', branch, '--limit', '1', '--json', 'status,conclusion'], cwd);
         const runs = JSON.parse(output);
         if (!runs.length)
             return 'not-found';
-        const run = runs[0];
-        if (run.status === 'completed') {
-            return run.conclusion === 'success' ? 'passed' : 'failed';
+        const run_ = runs[0];
+        if (run_.status === 'completed') {
+            return run_.conclusion === 'success' ? 'passed' : 'failed';
         }
         return 'pending';
     }
@@ -68,7 +72,7 @@ function pollGitHub(branch, cwd, logger) {
 }
 function pollGitLab(branch, cwd, logger) {
     try {
-        const output = execSync(`glab ci list --branch "${branch}" --output json`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 15_000 }).trim();
+        const output = run('glab', ['ci', 'list', '--branch', branch, '--output', 'json'], cwd);
         const pipelines = JSON.parse(output);
         if (!pipelines.length)
             return 'not-found';
@@ -89,16 +93,15 @@ function pollGitLab(branch, cwd, logger) {
 export function fetchFailureLogs(branch, platform, cwd) {
     try {
         if (platform === 'github') {
-            // Get the latest failed run ID and fetch logs
-            const runsOutput = execSync(`gh run list --branch "${branch}" --limit 1 --json databaseId,conclusion`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 15_000 }).trim();
+            const runsOutput = run('gh', ['run', 'list', '--branch', branch, '--limit', '1', '--json', 'databaseId,conclusion'], cwd);
             const runs = JSON.parse(runsOutput);
             if (!runs.length)
                 return undefined;
-            const runId = runs[0].databaseId;
-            return execSync(`gh run view ${runId} --log-failed`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 30_000 }).trim();
+            const runId = String(runs[0].databaseId);
+            return run('gh', ['run', 'view', runId, '--log-failed'], cwd, 30_000);
         }
         if (platform === 'gitlab') {
-            return execSync(`glab ci trace --branch "${branch}"`, { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 30_000 }).trim();
+            return run('glab', ['ci', 'trace', '--branch', branch], cwd, 30_000);
         }
     }
     catch { /* ignore */ }

package/dist/scheduler/git/manager.mjs

@@ -1,12 +1,12 @@
 // ─── Deterministic git operations ───
-// All operations use execSync — git is fast and must complete before the next step.
-import { execSync } from 'node:child_process';
+// All operations use execFileSync — safe from shell injection.
+import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 const GIT_TIMEOUT = 30_000;
 const PUSH_TIMEOUT = 60_000;
 function git(args, cwd, timeout = GIT_TIMEOUT) {
-    return execSync(`git ${args}`, { cwd, timeout, stdio: 'pipe', encoding: 'utf-8' }).trim();
+    return execFileSync('git', args, { cwd, timeout, stdio: 'pipe', encoding: 'utf-8' }).trim();
 }
 // ─── Worktree operations ───
 export function createWorktree(projectDir, branchSlug, baseBranch) {
@@ -15,21 +15,27 @@ export function createWorktree(projectDir, branchSlug, baseBranch) {
     if (existsSync(worktreePath)) {
         return worktreePath;
     }
-    git(`worktree add "${worktreePath}" -b "${branchSlug}" "${base}"`, projectDir);
+    git(['worktree', 'add', worktreePath, '-b', branchSlug, base], projectDir);
     return worktreePath;
 }
 export function cleanupWorktree(projectDir, worktreePath, branch) {
     try {
-        git(`worktree remove "${worktreePath}" --force`, projectDir);
+        git(['worktree', 'remove', worktreePath, '--force'], projectDir);
     }
     catch { /* may already be removed */ }
     try {
-        git(`branch -d "${branch}"`, projectDir);
+        git(['branch', '-d', branch], projectDir);
+    }
+    catch {
+        // -d may fail if not fully merged — force delete since we know it was merged or abandoned
+        try {
+            git(['branch', '-D', branch], projectDir);
+        }
+        catch { /* may already be deleted */ }
     }
-    catch { /* may already be deleted */ }
 }
 export function listWorktrees(projectDir) {
-    const output = git('worktree list --porcelain', projectDir);
+    const output = git(['worktree', 'list', '--porcelain'], projectDir);
     const mainNorm = normalizePath(resolve(projectDir));
     const paths = [];
     for (const line of output.split('\n')) {
@@ -50,24 +56,24 @@ export function listOrphanedWorktrees(projectDir, knownWorktrees) {
 }
 // ─── Commit operations ───
 export function commitInWorktree(worktreePath, message) {
-    git('add -A', worktreePath);
+    git(['add', '-A'], worktreePath);
     // Check if there's anything to commit
-    const status = git('status --porcelain', worktreePath);
+    const status = git(['status', '--porcelain'], worktreePath);
     if (!status)
         return '';
-    git(`commit -m "${escapeMsg(message)}"`, worktreePath);
-    return git('rev-parse HEAD', worktreePath);
+    git(['commit', '-m', message], worktreePath);
+    return git(['rev-parse', 'HEAD'], worktreePath);
 }
 export function getChangedFiles(worktreePath) {
     try {
         const mainBranch = getMainBranch(worktreePath);
-        const output = git(`diff --name-only "${mainBranch}"...HEAD`, worktreePath);
+        const output = git(['diff', '--name-only', `${mainBranch}...HEAD`], worktreePath);
         return output ? output.split('\n').filter(f => f.length > 0) : [];
     }
     catch {
         // Fallback: diff against parent
         try {
-            const output = git('diff --name-only HEAD~1', worktreePath);
+            const output = git(['diff', '--name-only', 'HEAD~1'], worktreePath);
             return output ? output.split('\n').filter(f => f.length > 0) : [];
         }
         catch {
@@ -76,14 +82,14 @@ export function getChangedFiles(worktreePath) {
     }
 }
 export function hasUncommittedChanges(dir) {
-    const status = git('status --porcelain', dir);
+    const status = git(['status', '--porcelain'], dir);
     return status.length > 0;
 }
 // ─── Push operations ───
 export function pushWorktree(worktreePath) {
     try {
-        const branch = git('rev-parse --abbrev-ref HEAD', worktreePath);
-        git(`push -u origin "${branch}"`, worktreePath, PUSH_TIMEOUT);
+        const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], worktreePath);
+        git(['push', '-u', 'origin', branch], worktreePath, PUSH_TIMEOUT);
         return true;
     }
     catch {
@@ -92,8 +98,8 @@ export function pushWorktree(worktreePath) {
 }
 export function forcePushWorktree(worktreePath) {
     try {
-        const branch = git('rev-parse --abbrev-ref HEAD', worktreePath);
-        git(`push --force-with-lease -u origin "${branch}"`, worktreePath, PUSH_TIMEOUT);
+        const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], worktreePath);
+        git(['push', '--force-with-lease', '-u', 'origin', branch], worktreePath, PUSH_TIMEOUT);
         return true;
     }
     catch {
@@ -101,39 +107,66 @@ export function forcePushWorktree(worktreePath) {
     }
 }
 export function mergeToMain(projectDir, branch) {
-    const main = getMainBranch(projectDir);
     try {
-        git(`merge "${branch}" --no-ff -m "Merge ${branch}"`, projectDir);
-        const sha = git('rev-parse HEAD', projectDir);
+        git(['merge', branch, '--no-ff', '-m', `Merge ${branch}`], projectDir);
+        const sha = git(['rev-parse', 'HEAD'], projectDir);
         return { success: true, sha, conflict: false };
     }
     catch (err) {
         const isConflict = hasConflicts(projectDir);
+        const conflictFiles = isConflict ? getConflictFiles(projectDir) : undefined;
         if (isConflict) {
-            git('merge --abort', projectDir);
+            git(['merge', '--abort'], projectDir);
         }
         return {
             success: false,
             sha: null,
             conflict: isConflict,
+            conflictFiles,
             error: err.message,
         };
     }
 }
 function hasConflicts(dir) {
     try {
-        const status = git('status --porcelain', dir);
+        const status = git(['status', '--porcelain'], dir);
         return status.includes('UU ') || status.includes('AA ') || status.includes('DD ');
     }
     catch {
         return false;
     }
 }
+function getConflictFiles(dir) {
+    try {
+        const status = git(['status', '--porcelain'], dir);
+        return status.split('\n')
+            .filter(l => /^(UU|AA|DD|DU|UD|AU|UA) /.test(l))
+            .map(l => l.slice(3));
+    }
+    catch {
+        return [];
+    }
+}
+export function abortMerge(dir) {
+    try {
+        git(['merge', '--abort'], dir);
+    }
+    catch { /* no merge in progress */ }
+}
+export function deleteBranchRemote(cwd, branch) {
+    try {
+        git(['push', 'origin', '--delete', branch], cwd, PUSH_TIMEOUT);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // ─── Branch / sync operations ───
 export function syncMain(projectDir) {
     try {
-        git('fetch --quiet', projectDir);
-        git('pull --ff-only --quiet', projectDir, PUSH_TIMEOUT);
+        git(['fetch', '--quiet'], projectDir);
+        git(['pull', '--ff-only', '--quiet'], projectDir, PUSH_TIMEOUT);
         return true;
     }
     catch {
@@ -143,13 +176,13 @@ export function syncMain(projectDir) {
 export function getMainBranch(projectDir) {
     try {
         // Check for remote HEAD
-        const ref = git('symbolic-ref refs/remotes/origin/HEAD', projectDir);
+        const ref = git(['symbolic-ref', 'refs/remotes/origin/HEAD'], projectDir);
         return ref.replace('refs/remotes/origin/', '');
     }
     catch {
         // Fallback: check common names
         try {
-            git('rev-parse --verify main', projectDir);
+            git(['rev-parse', '--verify', 'main'], projectDir);
             return 'main';
         }
         catch {
@@ -158,11 +191,11 @@ export function getMainBranch(projectDir) {
     }
 }
 export function getCurrentBranch(dir) {
-    return git('rev-parse --abbrev-ref HEAD', dir);
+    return git(['rev-parse', '--abbrev-ref', 'HEAD'], dir);
 }
 export function branchExists(projectDir, branch) {
     try {
-        git(`rev-parse --verify "${branch}"`, projectDir);
+        git(['rev-parse', '--verify', branch], projectDir);
         return true;
     }
     catch {
@@ -173,7 +206,7 @@ export function isBranchMerged(projectDir, branch) {
     try {
         const main = getMainBranch(projectDir);
         // Check if branch tip is an ancestor of main (i.e., was merged)
-        git(`merge-base --is-ancestor "${branch}" "${main}"`, projectDir);
+        git(['merge-base', '--is-ancestor', branch, main], projectDir);
         return true;
     }
     catch {
@@ -183,8 +216,8 @@ export function isBranchMerged(projectDir, branch) {
 // ─── Git identity ───
 export function hasGitIdentity(projectDir) {
     try {
-        git('config user.name', projectDir);
-        git('config user.email', projectDir);
+        git(['config', 'user.name'], projectDir);
+        git(['config', 'user.email'], projectDir);
         return true;
     }
     catch {
@@ -194,8 +227,10 @@ export function hasGitIdentity(projectDir) {
 // ─── Tag operations ───
 export function createTag(projectDir, tag, message) {
     try {
-        const msgArg = message ? `-m "${escapeMsg(message)}"` : '';
-        git(`tag -a "${tag}" ${msgArg}`, projectDir);
+        const args = message
+            ? ['tag', '-a', tag, '-m', message]
+            : ['tag', tag];
+        git(args, projectDir);
         return true;
     }
     catch {
@@ -204,7 +239,7 @@ export function createTag(projectDir, tag, message) {
 }
 export function getLatestTag(projectDir) {
     try {
-        return git('describe --tags --abbrev=0', projectDir);
+        return git(['describe', '--tags', '--abbrev=0'], projectDir);
     }
     catch {
         return null;
@@ -212,7 +247,7 @@ export function getLatestTag(projectDir) {
 }
 export function pushTags(projectDir) {
     try {
-        git('push --tags', projectDir, PUSH_TIMEOUT);
+        git(['push', '--tags'], projectDir, PUSH_TIMEOUT);
         return true;
     }
     catch {
@@ -222,23 +257,23 @@ export function pushTags(projectDir) {
 export function rebaseOnMain(worktreePath, projectDir) {
     try {
         const main = getMainBranch(projectDir);
-        git(`fetch origin "${main}"`, worktreePath, PUSH_TIMEOUT);
-        git(`rebase "origin/${main}"`, worktreePath, PUSH_TIMEOUT);
+        git(['fetch', 'origin', main], worktreePath, PUSH_TIMEOUT);
+        git(['rebase', `origin/${main}`], worktreePath, PUSH_TIMEOUT);
         return { success: true, conflict: false };
     }
     catch (err) {
         // Check if rebase is in progress (conflict)
         try {
-            const status = git('status --porcelain', worktreePath);
+            const status = git(['status', '--porcelain'], worktreePath);
             if (status.includes('UU ') || status.includes('AA ') || status.includes('DD ')) {
-                git('rebase --abort', worktreePath);
+                git(['rebase', '--abort'], worktreePath);
                 return { success: false, conflict: true, error: err.message };
             }
         }
         catch { /* ignore */ }
         // Abort any in-progress rebase
         try {
-            git('rebase --abort', worktreePath);
+            git(['rebase', '--abort'], worktreePath);
         }
         catch { /* ignore */ }
         return { success: false, conflict: false, error: err.message };
@@ -253,30 +288,30 @@ export function rebaseOnMain(worktreePath, projectDir) {
 export function cleanMainForMerge(projectDir) {
     // Abort any in-progress merge (conflict state from previous failed merge)
     try {
-        git('merge --abort', projectDir);
+        git(['merge', '--abort'], projectDir);
     }
     catch { /* no merge in progress */ }
     // Abort any in-progress rebase
     try {
-        git('rebase --abort', projectDir);
+        git(['rebase', '--abort'], projectDir);
     }
     catch { /* no rebase in progress */ }
     // Reset any staged changes back to unstaged
     try {
-        git('reset HEAD', projectDir);
+        git(['reset', 'HEAD'], projectDir);
     }
     catch { /* nothing staged */ }
     // If there are still uncommitted changes, stash them (preserves user edits)
-    const status = git('status --porcelain', projectDir);
+    const status = git(['status', '--porcelain'], projectDir);
     if (status) {
         try {
-            git('stash --include-untracked -m "scheduler: auto-stash before merge"', projectDir);
+            git(['stash', '--include-untracked', '-m', 'scheduler: auto-stash before merge'], projectDir);
             return true;
         }
         catch {
             // If stash fails, force-clean as last resort
             try {
-                git('checkout -- .', projectDir);
+                git(['checkout', '--', '.'], projectDir);
             }
             catch { /* ignore */ }
             return false;
@@ -286,11 +321,11 @@ export function cleanMainForMerge(projectDir) {
 }
 // ─── Stash operations ───
 export function stashChanges(dir) {
-    const status = git('status --porcelain', dir);
+    const status = git(['status', '--porcelain'], dir);
     if (!status)
         return false;
     try {
-        git('stash --include-untracked', dir);
+        git(['stash', '--include-untracked'], dir);
         return true;
     }
     catch {
@@ -299,7 +334,7 @@ export function stashChanges(dir) {
 }
 export function popStash(dir) {
     try {
-        git('stash pop', dir);
+        git(['stash', 'pop'], dir);
         return true;
     }
     catch {
@@ -309,7 +344,7 @@ export function popStash(dir) {
 // ─── Dirty main evaluation ───
 const TRACKING_FILES = new Set(['TODO.md', 'MEMORY.md']);
 export function evaluateDirtyMain(projectDir) {
-    const status = git('status --porcelain', projectDir);
+    const status = git(['status', '--porcelain'], projectDir);
     if (!status)
         return { trackingFiles: [], userFiles: [] };
     const trackingFiles = [];
@@ -331,16 +366,12 @@ export function evaluateDirtyMain(projectDir) {
 export function discardFiles(dir, files) {
     if (files.length === 0)
         return;
-    const fileArgs = files.map(f => `"${f}"`).join(' ');
     try {
-        git(`checkout -- ${fileArgs}`, dir);
+        git(['checkout', '--', ...files], dir);
     }
     catch { /* file may not exist in index */ }
 }
 // ─── Helpers ───
-function escapeMsg(msg) {
-    return msg.replace(/"/g, '\\"').replace(/\n/g, '\\n');
-}
 function normalizePath(p) {
     return p.replace(/\\/g, '/').toLowerCase();
 }

package/dist/scheduler/git/pr-manager.mjs

@@ -10,6 +10,15 @@ function run(bin, args, cwd, timeout = READ_TIMEOUT) {
     return execFileSync(bin, args, { cwd, timeout, stdio: 'pipe', encoding: 'utf-8' }).trim();
 }
 export function createPR(opts) {
+    // Check if a PR/MR already exists for this branch
+    try {
+        const existing = getPRStatus(opts.cwd, opts.platform, opts.branch);
+        if (existing.status === 'open' || existing.status === 'merged') {
+            return existing;
+        }
+        // If closed, fall through to create a new one
+    }
+    catch { /* no existing PR — create one */ }
     const body = opts.issueNumber
         ? `${opts.body}\n\nCloses #${opts.issueNumber}`
         : opts.body;

package/dist/scheduler/index.mjs

@@ -248,6 +248,8 @@ export async function runScheduler(opts) {
         if (!opts.resume) {
             state.pipelines = {};
         }
+        // Always re-run recovery on fresh scheduler start
+        state._recoveryDone = false;
         logger.info(`Loaded state: ${state.completedTasks.length} completed, ${state.skippedTasks.length} skipped, iteration ${state.iteration}`);
     }
     else {

package/dist/scheduler/loop.mjs

@@ -7,7 +7,7 @@ import { fetchOpenIssues, issueToTask, updateIssueStatus } from './tasks/issue-s
 import { buildGraph, getParallelBatches, isPhaseComplete, getNextPhase, isProjectComplete } from './tasks/queue.mjs';
 import { writeState, appendEvent, createEvent, rotateLog } from './state/state.mjs';
 import { recordSession, getSession, clearSession } from './state/session.mjs';
-import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree, forcePushWorktree, rebaseOnMain, cleanMainForMerge, popStash, getMainBranch, listOrphanedWorktrees, isBranchMerged, getCurrentBranch, hasUncommittedChanges, } from './git/manager.mjs';
+import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree, forcePushWorktree, rebaseOnMain, cleanMainForMerge, popStash, getMainBranch, listOrphanedWorktrees, isBranchMerged, getCurrentBranch, hasUncommittedChanges, abortMerge, deleteBranchRemote, } from './git/manager.mjs';
 import { createPR, getPRStatus, getPRComments, mergePR } from './git/pr-manager.mjs';
 import { scanAgents } from './agents/health-checker.mjs';
 import { detectCIPlatform, fetchFailureLogs } from './git/ci-watcher.mjs';
@@ -58,8 +58,19 @@ export async function runIteration(deps) {
             // Caller (scheduler.mts) handles pause state
         }
     }
-    // Recover orphaned worktrees — once per scheduler run (first iteration only)
+    // Pre-flight: commit uncommitted changes on main before any work
     if (!state._recoveryDone) {
+        if (hasUncommittedChanges(projectDir)) {
+            logger.warn('Uncommitted changes on main — auto-committing before starting work');
+            try {
+                commitInWorktree(projectDir, 'chore: auto-commit uncommitted changes before scheduler start');
+                logger.info('Uncommitted changes committed on main');
+            }
+            catch (err) {
+                logger.error(`Failed to commit main changes: ${err.message}`);
+            }
+        }
+        // Recover orphaned worktrees — once per scheduler run (first iteration only)
         state._recoveryDone = true;
         await recoverOrphanedWorktrees(projectDir, state, logger, deps);
     }
@@ -71,8 +82,14 @@ export async function runIteration(deps) {
             logger.error('Platform mode requires a git remote (github/gitlab)');
             return false;
         }
-        tasks = fetchOpenIssues(projectDir, platform)
-            .map(i => issueToTask(i, state.currentPhase));
+        try {
+            tasks = fetchOpenIssues(projectDir, platform)
+                .map(i => issueToTask(i, state.currentPhase));
+        }
+        catch (err) {
+            logger.error(`Failed to fetch remote issues: ${err.message?.split('\n')[0]}`);
+            return false;
+        }
     }
     else {
         const todoPath = resolve(projectDir, '.claude/scheduler/tasks.json');
@@ -433,6 +450,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                         // Sync main to get the merge commit
                         syncMain(projectDir);
                         cleanupWorktree(projectDir, worktreePath, slug);
+                        deleteBranchRemote(projectDir, slug);
                         pipeline.step = 'done';
                         clearSession(state, task.id);
                         delete state.pipelines[task.id];
@@ -490,8 +508,9 @@ async function runTaskPipeline(task, workerId, agents, deps) {
         }
         if (stashed)
             popStash(projectDir);
-        // Cleanup
+        // Cleanup: worktree + local branch + remote branch
         cleanupWorktree(projectDir, worktreePath, slug);
+        deleteBranchRemote(projectDir, slug);
         pipeline.step = 'done';
         clearSession(state, task.id);
         delete state.pipelines[task.id];
@@ -555,6 +574,22 @@ function isRefactoringTask(task) {
         || lower.includes('rename') || lower.includes('migrate') || lower.includes('upgrade');
 }
 // ─── Orphaned worktree recovery ───
+/** Mark issue as done on the platform after a successful recovery merge */
+function closeRecoveredIssue(projectDir, branch, logger) {
+    const platform = detectCIPlatform(projectDir);
+    if (platform === 'none')
+        return;
+    const issueNum = extractIssueFromBranch(branch);
+    if (!issueNum)
+        return;
+    try {
+        updateIssueStatus(projectDir, platform, issueNum, 'done');
+        logger.info(`[recovery] Issue #${issueNum} marked as done and closed`);
+    }
+    catch (err) {
+        logger.warn(`[recovery] Failed to close issue #${issueNum}: ${err.message}`);
+    }
+}
 async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
     const knownPaths = Object.values(state.pipelines).map(p => p.worktreePath);
     const orphans = listOrphanedWorktrees(projectDir, knownPaths);
@@ -569,6 +604,8 @@ async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
                 // Already merged — just clean up
                 logger.info(`[recovery] ${branch} already merged — cleaning up worktree`);
                 cleanupWorktree(projectDir, worktreePath, branch);
+                deleteBranchRemote(projectDir, branch);
+                closeRecoveredIssue(projectDir, branch, logger);
                 continue;
             }
             // Check if worktree has commits ahead of main
@@ -615,6 +652,8 @@ async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
                             logger.info(`[recovery] ${branch} merged via platform`);
                             syncMain(projectDir);
                             cleanupWorktree(projectDir, worktreePath, branch);
+                            deleteBranchRemote(projectDir, branch);
+                            closeRecoveredIssue(projectDir, branch, logger);
                             if (stashed)
                                 popStash(projectDir);
                             continue;
@@ -635,24 +674,69 @@ async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
             if (mergeResult.success) {
                 logger.info(`[recovery] ${branch} merged locally (${mergeResult.sha?.slice(0, 7)})`);
                 appendEvent(projectDir, createEvent('merge_completed', { detail: `recovery: ${branch}` }));
+                closeRecoveredIssue(projectDir, branch, logger);
             }
             else if (mergeResult.conflict) {
-                // Try rebase
-                const rebaseResult = rebaseOnMain(worktreePath, projectDir);
-                if (rebaseResult.success) {
-                    const retryResult = mergeToMain(projectDir, branch);
-                    if (retryResult.success) {
-                        logger.info(`[recovery] ${branch} merged after rebase`);
+                // mergeToMain already aborted the merge internally
+                // Delegate conflict resolution to orchestrator AI
+                logger.info(`[recovery] ${branch} has merge conflicts — delegating to AI`);
+                let resolved = false;
+                try {
+                    const conflictDecision = await deps.orchestrator.handleMergeConflict(branch, mergeResult.conflictFiles ?? []);
+                    if (conflictDecision.action === 'resolve') {
+                        // Spawn agent to resolve conflicts in the worktree via rebase
+                        logger.info(`[recovery] Spawning agent to resolve conflicts in ${branch}`);
+                        const conflictPrompt = [
+                            `You are in a worktree for branch "${branch}".`,
+                            `Rebase this branch onto main and resolve all merge conflicts.`,
+                            ``,
+                            `Steps:`,
+                            `1. Run: git rebase main`,
+                            `2. For each conflict, read the conflicting files and resolve them sensibly`,
+                            `3. After resolving each file: git add <file>`,
+                            `4. Continue rebase: git rebase --continue`,
+                            `5. Repeat until rebase is complete`,
+                            ``,
+                            `Conflicting files: ${(mergeResult.conflictFiles ?? []).join(', ') || 'unknown'}`,
+                            ``,
+                            `Important: preserve the intent of both sides. When in doubt, prefer the feature branch changes.`,
+                        ].join('\n');
+                        const slot = deps.pool.idleSlot();
+                        if (slot) {
+                            await deps.pool.spawn(slot.id, {
+                                cwd: worktreePath,
+                                prompt: conflictPrompt,
+                                model: 'claude-sonnet-4-6',
+                                onMessage: deps.onMessage,
+                            });
+                            // Retry merge after agent resolved conflicts
+                            const retryResult = mergeToMain(projectDir, branch);
+                            if (retryResult.success) {
+                                logger.info(`[recovery] ${branch} merged after AI conflict resolution`);
+                                appendEvent(projectDir, createEvent('merge_completed', { detail: `recovery-ai-resolve: ${branch}` }));
+                                resolved = true;
+                            }
+                        }
                     }
-                    else {
-                        logger.error(`[recovery] ${branch} merge failed after rebase — skipping`);
-                        if (stashed)
-                            popStash(projectDir);
-                        continue;
+                    else if (conflictDecision.action === 'rebase') {
+                        const rebaseResult = rebaseOnMain(worktreePath, projectDir);
+                        if (rebaseResult.success) {
+                            const retryResult = mergeToMain(projectDir, branch);
+                            if (retryResult.success) {
+                                logger.info(`[recovery] ${branch} merged after rebase`);
+                                resolved = true;
+                            }
+                        }
                     }
+                    // action === 'skip' → resolved stays false
                 }
-                else {
+                catch (err) {
+                    logger.warn(`[recovery] AI conflict resolution failed for ${branch}: ${err.message}`);
+                    abortMerge(projectDir);
+                }
+                if (!resolved) {
                     logger.error(`[recovery] ${branch} has unresolvable conflicts — skipping`);
+                    abortMerge(projectDir);
                     if (stashed)
                         popStash(projectDir);
                     continue;
@@ -660,11 +744,15 @@ async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
             }
             else {
                 logger.error(`[recovery] ${branch} merge failed: ${mergeResult.error} — skipping`);
+                abortMerge(projectDir);
                 if (stashed)
                     popStash(projectDir);
                 continue;
             }
+            // Post-merge cleanup: worktree + local branch + remote branch + close issue
             cleanupWorktree(projectDir, worktreePath, branch);
+            deleteBranchRemote(projectDir, branch);
+            closeRecoveredIssue(projectDir, branch, logger);
             if (stashed)
                 popStash(projectDir);
         }
@@ -788,6 +876,11 @@ function extractIssueNumber(marker) {
     const match = marker.match(/#(\d+)/);
     return match ? parseInt(match[1], 10) : null;
 }
+/** Extract issue number from branch name like "feat/#94-description" or "feat/94-description" */
+function extractIssueFromBranch(branch) {
+    const match = branch.match(/#?(\d+)/);
+    return match ? parseInt(match[1], 10) : null;
+}
 function getCurrentBranchFromProject(projectDir) {
     return getMainBranch(projectDir);
 }

package/dist/scheduler/tasks/issue-source.mjs

@@ -1,9 +1,9 @@
 // ─── Platform issue source ───
 // Reads tasks from GitHub/GitLab issues instead of TODO.md.
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 const CLI_TIMEOUT = 30_000;
-function cli(cmd, cwd) {
-    return execSync(cmd, { cwd, timeout: CLI_TIMEOUT, stdio: 'pipe', encoding: 'utf-8' }).trim();
+function run(cmd, args, cwd) {
+    return execFileSync(cmd, args, { cwd, timeout: CLI_TIMEOUT, stdio: 'pipe', encoding: 'utf-8' }).trim();
 }
 // ─── Fetch open issues ───
 export function fetchOpenIssues(cwd, platform) {
@@ -13,39 +13,29 @@ export function fetchOpenIssues(cwd, platform) {
     return fetchGitLabIssues(cwd);
 }
 function fetchGitHubIssues(cwd) {
-    try {
-        const output = cli('gh issue list --json number,title,body,labels,milestone,assignees --state open --limit 200', cwd);
-        const issues = JSON.parse(output);
-        // Filter out pull requests (GitHub API sometimes includes them)
-        return issues.map(i => ({
-            issueNumber: i.number,
-            title: i.title,
-            body: i.body ?? '',
-            labels: i.labels.map(l => l.name),
-            milestone: i.milestone?.title ?? null,
-            assignee: i.assignees[0]?.login ?? null,
-        }));
-    }
-    catch {
-        return [];
-    }
+    const output = run('gh', ['issue', 'list', '--json', 'number,title,body,labels,milestone,assignees', '--state', 'open', '--limit', '200'], cwd);
+    const issues = JSON.parse(output);
+    // Filter out pull requests (GitHub API sometimes includes them)
+    return issues.map(i => ({
+        issueNumber: i.number,
+        title: i.title,
+        body: i.body ?? '',
+        labels: i.labels.map(l => l.name),
+        milestone: i.milestone?.title ?? null,
+        assignee: i.assignees[0]?.login ?? null,
+    }));
 }
 function fetchGitLabIssues(cwd) {
-    try {
-        const output = cli('glab issue list --output json --per-page 200', cwd);
-        const issues = JSON.parse(output);
-        return issues.map(i => ({
-            issueNumber: i.iid,
-            title: i.title,
-            body: i.description ?? '',
-            labels: i.labels,
-            milestone: i.milestone?.title ?? null,
-            assignee: i.assignees[0]?.username ?? null,
-        }));
-    }
-    catch {
-        return [];
-    }
+    const output = run('glab', ['issue', 'list', '--output', 'json', '--per-page', '200'], cwd);
+    const issues = JSON.parse(output);
+    return issues.map(i => ({
+        issueNumber: i.iid,
+        title: i.title,
+        body: i.description ?? '',
+        labels: i.labels,
+        milestone: i.milestone?.title ?? null,
+        assignee: i.assignees[0]?.username ?? null,
+    }));
 }
 // ─── Convert issue to Task ───
 const PHASE_RE = /^Phase\s+(\d+)/i;
@@ -137,20 +127,27 @@ export function updateIssueStatus(cwd, platform, issueNumber, status) {
     const statusLabel = `status::${status}`;
     const allStatuses = ['status::todo', 'status::in-progress', 'status::in-review', 'status::done', 'status::skipped', 'status::blocked'];
     const removeLabels = allStatuses.filter(s => s !== statusLabel);
-    try {
-        if (platform === 'github') {
-            for (const label of removeLabels) {
-                try {
-                    cli(`gh issue edit ${issueNumber} --remove-label "${label}"`, cwd);
-                }
-                catch { /* label may not exist */ }
+    const num = String(issueNumber);
+    if (platform === 'github') {
+        for (const label of removeLabels) {
+            try {
+                run('gh', ['issue', 'edit', num, '--remove-label', label], cwd);
             }
-            cli(`gh issue edit ${issueNumber} --add-label "${statusLabel}"`, cwd);
+            catch { /* label may not exist */ }
+        }
+        run('gh', ['issue', 'edit', num, '--add-label', statusLabel], cwd);
+    }
+    else {
+        run('glab', ['issue', 'update', num, '--unlabel', removeLabels.join(',')], cwd);
+        run('glab', ['issue', 'update', num, '--label', statusLabel], cwd);
+    }
+    // Close the issue when done or skipped
+    if (status === 'done' || status === 'skipped') {
+        if (platform === 'github') {
+            run('gh', ['issue', 'close', num], cwd);
         }
         else {
-            cli(`glab issue update ${issueNumber} --unlabel "${removeLabels.join(',')}"`, cwd);
-            cli(`glab issue update ${issueNumber} --label "${statusLabel}"`, cwd);
+            run('glab', ['issue', 'close', num], cwd);
         }
     }
-    catch { /* best-effort */ }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-workspace",
-  "version": "2.3.8",
+  "version": "2.3.10",
   "author": "",
   "repository": {
     "type": "git",