create-claude-workspace 2.3.28 → 2.3.30

package/dist/scheduler/loop.mjs

@@ -4,7 +4,8 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { resolve } from 'node:path';
 import { parseTodoMd, updateTaskCheckbox } from './tasks/parser.mjs';
-import { fetchOpenIssues, issueToTask, updateIssueStatus, isTriaged, updateIssueBody, addIssueLabels, closeIssue } from './tasks/issue-source.mjs';
+import { fetchOpenIssues, issueToTask, updateIssueStatus, isTriaged, updateIssueBody, addIssueLabels, closeIssue, commentOnIssue } from './tasks/issue-source.mjs';
+import { createPlatformIssue } from './git/issue-creator.mjs';
 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';
@@ -88,6 +89,7 @@ export async function runIteration(deps) {
         }
         try {
             tasks = fetchOpenIssues(projectDir, platform)
+                .filter(i => !i.labels.includes('status::triaged')) // skip original request issues (task issues are separate)
                 .map(i => issueToTask(i, state.currentPhase));
         }
         catch (err) {
@@ -410,7 +412,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
     pipeline.workerId = workerId;
     state.pipelines[task.id] = pipeline;
     // Determine which steps to skip (for resumed pipelines)
-    const skipTo = resumeStep ?? 'plan';
+    const skipTo = resumeStep ?? 'triage';
     const stepOrder = ['triage', 'plan', 'implement', 'test', 'review', 'rework', 'commit', 'pr-create', 'pr-watch', 'merge'];
     const skipToIndex = stepOrder.indexOf(skipTo);
     const shouldSkip = (step) => stepOrder.indexOf(step) < skipToIndex;
@@ -483,16 +485,40 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                         }
                         catch { /* ignore parse errors */ }
                     }
-                    // Update issue on platform with structured spec + labels
+                    // Create a NEW task issue with the structured spec, link back to the original request
                     if (ciPlatformTriage !== 'none' && issueNum) {
                         try {
-                            updateIssueBody(projectDir, ciPlatformTriage, issueNum, analystResult.output);
-                            const newLabels = [`type::${task.type}`, `complexity::${task.complexity}`, 'status::todo'];
-                            addIssueLabels(projectDir, ciPlatformTriage, issueNum, newLabels);
-                            logger.info(`[${task.id}] Issue updated with spec + labels`);
+                            const taskLabels = [`type::${task.type}`, `complexity::${task.complexity}`, 'status::todo'];
+                            const taskBody = `> Task created from request #${issueNum}\n\n${analystResult.output}`;
+                            const created = createPlatformIssue(projectDir, ciPlatformTriage, {
+                                title: task.title,
+                                body: taskBody,
+                                labels: taskLabels,
+                            });
+                            if (created) {
+                                // Mark original issue as triaged and link to the task issue
+                                commentOnIssue(projectDir, ciPlatformTriage, issueNum, `Triaged → task issue #${created.number}`);
+                                addIssueLabels(projectDir, ciPlatformTriage, issueNum, ['status::triaged']);
+                                // Switch the pipeline to track the new task issue
+                                const newId = `#${created.number}`;
+                                task.id = newId;
+                                task.issueMarker = newId;
+                                pipeline.taskId = newId;
+                                // Re-register pipeline under new ID
+                                delete state.pipelines[`#${issueNum}`];
+                                state.pipelines[newId] = pipeline;
+                                logger.info(`[${newId}] Created task issue from request #${issueNum}`);
+                            }
+                            else {
+                                // Fallback: update original issue if creation failed
+                                updateIssueBody(projectDir, ciPlatformTriage, issueNum, analystResult.output);
+                                const newLabels = [`type::${task.type}`, `complexity::${task.complexity}`, 'status::todo'];
+                                addIssueLabels(projectDir, ciPlatformTriage, issueNum, newLabels);
+                                logger.warn(`[${task.id}] Failed to create task issue — updated original instead`);
+                            }
                         }
                         catch (err) {
-                            logger.warn(`[${task.id}] Failed to update issue: ${err.message?.split('\n')[0]}`);
+                            logger.warn(`[${task.id}] Failed to create/update issue: ${err.message?.split('\n')[0]}`);
                         }
                     }
                 }
@@ -882,7 +908,25 @@ export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps)
                 continue;
             }
             const branch = getCurrentBranch(worktreePath);
-            const alreadyMerged = isBranchMerged(projectDir, branch);
+            const hasChanges = hasUncommittedChanges(worktreePath);
+            const changedFromMain = getChangedFiles(worktreePath);
+            const hasCommits = changedFromMain.length > 0;
+            // Check platform PR status before making any merge decisions
+            let prMerged = false;
+            let prOpen = false;
+            if (ciPlatform !== 'none') {
+                try {
+                    const prStatus = getPRStatus(projectDir, ciPlatform, branch);
+                    prMerged = prStatus.status === 'merged';
+                    prOpen = prStatus.status === 'open';
+                }
+                catch { /* no PR exists */ }
+            }
+            // Only consider truly merged if:
+            // 1. PR was explicitly merged on the platform, OR
+            // 2. Branch has unique commits AND they're all on main (git ancestry) AND no open PR
+            const gitMerged = hasCommits && !prOpen && isBranchMerged(projectDir, branch);
+            const alreadyMerged = prMerged || gitMerged;
             if (alreadyMerged) {
                 logger.info(`[recovery] ${branch} already merged — cleaning up`);
                 cleanupWorktree(projectDir, worktreePath, branch);
@@ -890,14 +934,10 @@ export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps)
                 closeRecoveredIssue(projectDir, branch, logger);
                 continue;
             }
-            const hasChanges = hasUncommittedChanges(worktreePath);
-            const changedFromMain = getChangedFiles(worktreePath);
-            const hasCommits = changedFromMain.length > 0;
             if (!hasCommits && !hasChanges) {
-                logger.info(`[recovery] ${branch} has no changes — cleaning up`);
-                cleanupWorktree(projectDir, worktreePath, branch);
-                deleteBranchRemote(projectDir, branch);
-                continue;
+                // Branch exists but has no work yet — re-inject at the beginning of the pipeline
+                // (agent may have crashed before making any changes, issue is still valid)
+                logger.info(`[recovery] ${branch} has no changes yet — re-injecting from start`);
             }
             // Auto-commit any uncommitted changes so the pipeline can work with them
             if (hasChanges) {
@@ -907,7 +947,8 @@ export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps)
             // Determine the right pipeline step to resume from
             const issueNum = extractIssueFromBranch(branch);
             const taskId = issueNum ? `#${issueNum}` : branch;
-            const step = diagnoseStep(projectDir, branch, ciPlatform);
+            const hasWork = hasCommits || hasChanges;
+            const step = hasWork ? diagnoseStep(projectDir, branch, ciPlatform) : 'plan';
             logger.info(`[recovery] ${branch} → re-injecting into pipeline at step "${step}"`);
             // Register in pipelines so the normal task loop picks it up
             state.pipelines[taskId] = {

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

@@ -217,6 +217,15 @@ export function addIssueLabels(cwd, platform, issueNumber, labels) {
         run('glab', ['issue', 'update', num, '--label', labels.join(',')], cwd);
     }
 }
+export function commentOnIssue(cwd, platform, issueNumber, comment) {
+    const num = String(issueNumber);
+    if (platform === 'github') {
+        run('gh', ['issue', 'comment', num, '--body', comment], cwd);
+    }
+    else {
+        run('glab', ['issue', 'note', num, '--message', comment], cwd);
+    }
+}
 export function closeIssue(cwd, platform, issueNumber, comment) {
     const num = String(issueNumber);
     if (comment) {

package/package.json

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