create-claude-workspace 2.3.27 → 2.3.29

package/dist/scheduler/agents/prompt-builder.mjs

@@ -1,5 +1,66 @@
 // ─── Minimal prompt construction for each pipeline step ───
 // No workflow instructions. Just task + context + expected output format.
+// ─── Shared helpers ───
+function descriptionBlock(task) {
+    if (!task.description)
+        return [];
+    return [``, `## Issue Description`, task.description];
+}
+// ─── Triage prompts ───
+export function buildPOTriagePrompt(ctx) {
+    return [
+        `You are a product owner evaluating a feature request.`,
+        ``,
+        `## Feature Request`,
+        `**${ctx.task.title}**`,
+        ...descriptionBlock(ctx.task),
+        ``,
+        `## Working Directory`,
+        ctx.worktreePath,
+        ``,
+        `## Project Root`,
+        ctx.projectDir,
+        ``,
+        `## Instructions`,
+        `Read PRODUCT.md (if available) and the codebase to understand the product context.`,
+        `Evaluate this feature request and respond with a structured analysis.`,
+        ``,
+        `## Required Output Format`,
+        `Respond with JSON:`,
+        '```json',
+        `{`,
+        `  "decision": "accept" | "reject",`,
+        `  "risks": ["risk 1", "risk 2"],`,
+        `  "scope": "Your refined scope description — what exactly should be implemented",`,
+        `  "priority": "critical" | "high" | "medium" | "low",`,
+        `  "reason": "Brief explanation of your decision",`,
+        `  "suggestedType": "frontend" | "backend" | "fullstack",`,
+        `  "suggestedComplexity": "S" | "M" | "L"`,
+        `}`,
+        '```',
+        ``,
+        `## Decision Criteria`,
+        `- ACCEPT if: aligns with product vision, reasonable scope, clear value`,
+        `- REJECT if: out of scope, too risky, contradicts product direction, duplicate of existing functionality`,
+        `- When accepting, refine the scope to be specific and achievable`,
+        `- Estimate type and complexity based on what you see in the codebase`,
+    ].join('\n');
+}
+export function buildITAnalystTriagePrompt(ctx, poOutput) {
+    const kind = ctx.task.issueKind ?? 'feature';
+    const lines = [
+        `You are an IT analyst creating a detailed technical specification for a ${kind} issue.`,
+        ``,
+        `## Issue`,
+        `**${ctx.task.title}**`,
+        ...descriptionBlock(ctx.task),
+    ];
+    if (poOutput) {
+        lines.push(``, `## Product Owner's Brief`, poOutput);
+    }
+    lines.push(``, `## Working Directory`, ctx.worktreePath, ``, `## Project Root`, ctx.projectDir, ``, `## Instructions`, `Read the codebase to understand existing patterns, architecture, and conventions.`, `Create a detailed specification for this ${kind}.`, ``, `## Required Output Format`, ``, `### Description`, `Clear explanation of what needs to be done and why.`, ``, `### Acceptance Criteria`, `- [ ] Testable criterion 1`, `- [ ] Testable criterion 2`, `- [ ] (at least 3 criteria)`, ``, `### Technical Notes`, `Architecture decisions, existing patterns to follow, reuse opportunities.`, ``, `### Edge Cases`, `- Boundary condition 1`, `- Boundary condition 2`, ``, `### Affected Components`, `List file paths and modules that will need changes.`, ``, `### Metadata`, `Respond with a JSON block at the end:`, '```json', `{`, `  "type": "frontend" | "backend" | "fullstack",`, `  "complexity": "S" | "M" | "L",`, `  "dependencies": ["#N", ...]`, `}`, '```');
+    return lines.join('\n');
+}
 // ─── Planning prompts ───
 export function buildPlanPrompt(ctx) {
     const lines = [
@@ -7,6 +68,7 @@ export function buildPlanPrompt(ctx) {
         ``,
         `## Task`,
         `**${ctx.task.title}** (${ctx.task.type}, Complexity: ${ctx.task.complexity})`,
+        ...descriptionBlock(ctx.task),
         ``,
         `## Working Directory`,
         ctx.worktreePath,
@@ -30,6 +92,7 @@ export function buildImplementPrompt(ctx) {
         ``,
         `## Task`,
         `**${ctx.task.title}** (${ctx.task.type}, Complexity: ${ctx.task.complexity})`,
+        ...descriptionBlock(ctx.task),
         ``,
         `## Working Directory`,
         ctx.worktreePath,
@@ -54,6 +117,7 @@ export function buildQAPrompt(ctx) {
         ``,
         `## Task`,
         `**${ctx.task.title}** (${ctx.task.type})`,
+        ...descriptionBlock(ctx.task),
         ``,
         `## Working Directory`,
         ctx.worktreePath,
@@ -74,6 +138,7 @@ export function buildReviewPrompt(ctx) {
         ``,
         `## Task`,
         `**${ctx.task.title}** (${ctx.task.type})`,
+        ...descriptionBlock(ctx.task),
         ``,
         `## Working Directory`,
         ctx.worktreePath,
@@ -111,6 +176,7 @@ export function buildDecomposePrompt(task) {
         ``,
         `## Task`,
         `**${task.title}** (${task.type}, Phase ${task.phase})`,
+        ...descriptionBlock(task),
         ``,
         `## Instructions`,
         `Split this task into 2-4 smaller tasks (Complexity S or M).`,
@@ -136,6 +202,7 @@ export function buildRoutingPrompt(task, step, agents) {
         ``,
         `## Task`,
         `**${task.title}** (${task.type}, Complexity: ${task.complexity})`,
+        ...descriptionBlock(task),
         ``,
         `## Pipeline Step`,
         step,

package/dist/scheduler/agents/worker-pool.mjs

@@ -118,7 +118,7 @@ export class WorkerPool {
         };
     }
     async killAll() {
-        for (const [slotId, q] of this.queries) {
+        const kills = [...this.queries.entries()].map(async ([slotId, q]) => {
             try {
                 await q.return(undefined);
             }
@@ -127,7 +127,8 @@ export class WorkerPool {
             slot.status = 'idle';
             slot.taskId = null;
             slot.pid = null;
-        }
+        });
+        await Promise.allSettled(kills);
         this.queries.clear();
     }
     reset() {

package/dist/scheduler/index.mjs

@@ -66,6 +66,10 @@ export function parseSchedulerArgs(argv) {
             mutable.resume = true;
             continue;
         }
+        if (arg === '--reset-iterations') {
+            mutable.resetIterations = true;
+            continue;
+        }
         if (arg === '--interactive' || arg === '-i') {
             mutable.interactive = true;
             continue;
@@ -178,6 +182,7 @@ Options:
   --project-dir <path>       Project directory (default: cwd)
   --skip-permissions         Bypass all permission checks
   --resume                   Resume from saved state
+  --reset-iterations         Reset iteration counter (use with --resume)
   --resume-session <id>      Resume specific Claude session
   --notify-command <cmd>     Shell command on critical events
   --log-file <path>          Log file path
@@ -248,6 +253,12 @@ export async function runScheduler(opts) {
         // Clear in-progress pipelines from previous run (can't resume mid-pipeline)
         if (!opts.resume) {
             state.pipelines = {};
+            // Reset iteration counter on fresh start (not --resume)
+            state.iteration = 0;
+        }
+        // Explicit --reset-iterations flag (works with or without --resume)
+        if (opts.resetIterations) {
+            state.iteration = 0;
         }
         // Always re-run recovery on fresh scheduler start
         state._recoveryDone = false;
@@ -256,6 +267,12 @@ export async function runScheduler(opts) {
     else {
         state = emptyState(opts.concurrency);
     }
+    // Warn if iteration limit already reached (e.g. --resume without --reset-iterations)
+    if (state.iteration >= opts.maxIterations) {
+        logger.warn(`Iteration limit reached (${state.iteration}/${opts.maxIterations}). Use --reset-iterations or --max-iterations ${state.iteration + 50} to continue.`);
+        tui.destroy();
+        return;
+    }
     // Ensure platform CLI is available before task mode detection
     const detectedPlatform = detectCIPlatform(opts.projectDir);
     if (detectedPlatform !== 'none') {
@@ -326,12 +343,26 @@ export async function runScheduler(opts) {
     let stopping = false;
     const stoppingRef = { value: false };
     const cleanup = () => {
+        if (stopping) {
+            // Second signal — force exit immediately
+            logger.warn('Force exit.');
+            tui.destroy();
+            process.exit(1);
+        }
         stopping = true;
         stoppingRef.value = true;
         writeState(opts.projectDir, state);
         appendEvent(opts.projectDir, createEvent('health_check', { detail: 'Interrupted — state saved' }));
-        logger.warn('Interrupted. State saved.');
+        logger.warn('Interrupted. State saved. Press Ctrl+C again to force exit.');
+        // Kill workers with 5s timeout — guarantee exit even if SDK hangs
+        const forceTimer = setTimeout(() => {
+            logger.warn('Kill timeout — force exit.');
+            tui.destroy();
+            process.exit(1);
+        }, 5_000);
+        forceTimer.unref();
         pool.killAll().finally(() => {
+            clearTimeout(forceTimer);
             tui.destroy();
             process.exit(0);
         });

package/dist/scheduler/loop.mjs

@@ -4,7 +4,7 @@ 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 } from './tasks/issue-source.mjs';
+import { fetchOpenIssues, issueToTask, updateIssueStatus, isTriaged, updateIssueBody, addIssueLabels, closeIssue } from './tasks/issue-source.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';
@@ -14,7 +14,7 @@ import { scanAgents } from './agents/health-checker.mjs';
 import { detectCIPlatform, fetchFailureLogs } from './git/ci-watcher.mjs';
 import { createRelease } from './git/release.mjs';
 import { processInbox, addTaskMessageToTask } from './tasks/inbox.mjs';
-import { buildPlanPrompt, buildImplementPrompt, buildQAPrompt, buildReviewPrompt, buildReworkPrompt, buildCIFixPrompt, buildPRCommentPrompt, } from './agents/prompt-builder.mjs';
+import { buildPlanPrompt, buildImplementPrompt, buildQAPrompt, buildReviewPrompt, buildReworkPrompt, buildCIFixPrompt, buildPRCommentPrompt, buildPOTriagePrompt, buildITAnalystTriagePrompt, } from './agents/prompt-builder.mjs';
 import { discoveredIssueToTask } from './tools/report-issue.mjs';
 import { createSchedulerToolServer } from './tools/scheduler-tools.mjs';
 const MAX_REVIEW_CYCLES = 5;
@@ -405,15 +405,102 @@ async function runTaskPipeline(task, workerId, agents, deps) {
         assignedAgent: null,
         prState: null,
         approvalWaitingSince: null,
+        triageOutput: null,
     };
     pipeline.workerId = workerId;
     state.pipelines[task.id] = pipeline;
     // Determine which steps to skip (for resumed pipelines)
-    const skipTo = resumeStep ?? 'plan';
-    const stepOrder = ['plan', 'implement', 'test', 'review', 'rework', 'commit', 'pr-create', 'pr-watch', 'merge'];
+    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;
     try {
+        // STEP 0: Triage (platform issues only — features go through PO, bugs go to IT analyst)
+        if (!shouldSkip('triage')) {
+            if (task.source === 'platform' && !isTriaged(task)) {
+                pipeline.step = 'triage';
+                appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'triage' }));
+                const ciPlatformTriage = detectCIPlatform(projectDir);
+                const issueNum = extractIssueNumber(task.issueMarker);
+                const isBug = task.issueKind === 'bug';
+                let poOutput;
+                // Features: product owner evaluates first
+                if (!isBug) {
+                    logger.info(`[${task.id}] Triage: feature request — consulting product owner`);
+                    const poResult = await spawnAgent(pool, workerId, {
+                        agent: 'product-owner',
+                        cwd: worktreePath,
+                        prompt: buildPOTriagePrompt({ task, worktreePath, projectDir }),
+                        model: 'opus',
+                    }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                    if (poResult.success) {
+                        poOutput = poResult.output;
+                        // Parse PO decision
+                        const jsonMatch = poResult.output.match(/\{[\s\S]*"decision"[\s\S]*\}/);
+                        if (jsonMatch) {
+                            try {
+                                const poDecision = JSON.parse(jsonMatch[0]);
+                                if (poDecision.decision === 'reject') {
+                                    logger.info(`[${task.id}] Product owner rejected: ${poDecision.reason}`);
+                                    // Close the issue with explanation
+                                    if (ciPlatformTriage !== 'none' && issueNum) {
+                                        closeIssue(projectDir, ciPlatformTriage, issueNum, `**Rejected by product analysis:**\n\n${poDecision.reason}\n\nRisks: ${(poDecision.risks ?? []).join(', ')}`);
+                                    }
+                                    cleanupWorktree(projectDir, worktreePath, slug);
+                                    pipeline.step = 'done';
+                                    delete state.pipelines[task.id];
+                                    task.status = 'skipped';
+                                    state.skippedTasks.push(task.id);
+                                    appendEvent(projectDir, createEvent('task_skipped', { taskId: task.id, detail: `PO rejected: ${poDecision.reason}` }));
+                                    return false;
+                                }
+                            }
+                            catch { /* parse error — continue with IT analyst */ }
+                        }
+                    }
+                }
+                // IT analyst creates detailed spec
+                logger.info(`[${task.id}] Triage: ${isBug ? 'bug' : 'accepted feature'} — creating spec via IT analyst`);
+                const analystResult = await spawnAgent(pool, workerId, {
+                    agent: 'it-analyst',
+                    cwd: worktreePath,
+                    prompt: buildITAnalystTriagePrompt({ task, worktreePath, projectDir }, poOutput),
+                    model: 'sonnet',
+                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                if (analystResult.success) {
+                    pipeline.triageOutput = analystResult.output;
+                    // Update task description with triage output
+                    task.description = analystResult.output;
+                    // Parse metadata from analyst output
+                    const metaMatch = analystResult.output.match(/```json\s*(\{[\s\S]*?\})\s*```/);
+                    if (metaMatch) {
+                        try {
+                            const meta = JSON.parse(metaMatch[1]);
+                            if (meta.type)
+                                task.type = meta.type;
+                            if (meta.complexity)
+                                task.complexity = meta.complexity;
+                        }
+                        catch { /* ignore parse errors */ }
+                    }
+                    // Update issue on platform with structured spec + labels
+                    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`);
+                        }
+                        catch (err) {
+                            logger.warn(`[${task.id}] Failed to update issue: ${err.message?.split('\n')[0]}`);
+                        }
+                    }
+                }
+                else {
+                    logger.warn(`[${task.id}] IT analyst triage failed — proceeding with original description`);
+                }
+            }
+        }
         // Route task to agent
         const routing = await orchestrator.routeTask(task, shouldSkip('plan') ? skipTo : 'plan', agents);
         pipeline.assignedAgent = routing.agent;
@@ -839,6 +926,7 @@ export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps)
                 assignedAgent: null,
                 prState: null,
                 approvalWaitingSince: null,
+                triageOutput: null,
             };
         }
         catch (err) {
@@ -932,6 +1020,7 @@ async function analyzeStaleUnmergedBranches(projectDir, state, logger, deps) {
                         assignedAgent: null,
                         prState: null,
                         approvalWaitingSince: null,
+                        triageOutput: null,
                     };
                     logger.info(`[recovery] Branch "${d.branch}" re-injected at step "${step}"`);
                 }
@@ -1042,6 +1131,7 @@ export function recoverOpenMRs(projectDir, platform, state, logger) {
                     assignedAgent: null,
                     prState: { prNumber: mr.number, url: '', issueNumber: issueNum },
                     approvalWaitingSince: null,
+                    triageOutput: null,
                 };
             }
             catch (err) {

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

@@ -42,8 +42,14 @@ const PHASE_RE = /^Phase\s+(\d+)/i;
 const DEPENDS_ON_RE = /depends[- ]on:\s*(.+)/im;
 export function issueToTask(issue, fallbackPhase) {
     const phase = extractPhase(issue.milestone) ?? fallbackPhase;
-    const complexity = extractLabel(issue.labels, 'complexity::', 'M');
-    const type = extractLabel(issue.labels, 'type::', 'fullstack');
+    const hasTypeLabel = issue.labels.some(l => l.startsWith('type::'));
+    const hasComplexityLabel = issue.labels.some(l => l.startsWith('complexity::'));
+    const type = hasTypeLabel
+        ? extractLabel(issue.labels, 'type::', 'fullstack')
+        : inferType(issue.title, issue.body);
+    const complexity = hasComplexityLabel
+        ? extractLabel(issue.labels, 'complexity::', 'M')
+        : inferComplexity(issue.title, issue.body);
     const status = extractStatus(issue.labels);
     const dependsOn = extractDependencies(issue.body, issue.labels);
     return {
@@ -55,8 +61,10 @@ export function issueToTask(issue, fallbackPhase) {
         dependsOn,
         issueMarker: `#${issue.issueNumber}`,
         kitUpgrade: issue.labels.some(l => l.toLowerCase().includes('kit-upgrade')),
-        lineNumber: 0, // not applicable for platform issues
+        lineNumber: 0,
         source: 'platform',
+        description: truncateBody(issue.body, 4000),
+        issueKind: classifyIssueKind(issue.title, issue.labels),
         status,
         changelog: inferChangelog(issue.title, issue.labels),
     };
@@ -123,6 +131,109 @@ function inferChangelog(title, labels) {
         return 'changed';
     return 'added';
 }
+// ─── Body truncation ───
+export function truncateBody(body, maxChars) {
+    if (!body || !body.trim())
+        return undefined;
+    if (body.length <= maxChars)
+        return body;
+    // Truncate at the last paragraph break before maxChars
+    const truncated = body.slice(0, maxChars);
+    const lastBreak = truncated.lastIndexOf('\n\n');
+    const cutPoint = lastBreak > maxChars * 0.5 ? lastBreak : maxChars;
+    return truncated.slice(0, cutPoint) + '\n\n[... truncated]';
+}
+// ─── Issue classification ───
+const BUG_KEYWORDS = ['bug', 'fix', 'hotfix', 'broken', 'crash', 'error', 'regression', 'defect'];
+export function classifyIssueKind(title, labels) {
+    // Labels take priority
+    if (labels.some(l => l === 'bug' || l === 'type::bug'))
+        return 'bug';
+    if (labels.some(l => l === 'feature' || l === 'enhancement' || l === 'type::feature'))
+        return 'feature';
+    // Keyword detection from title
+    const lower = title.toLowerCase();
+    if (BUG_KEYWORDS.some(kw => lower.includes(kw)))
+        return 'bug';
+    return 'feature';
+}
+/**
+ * An issue is considered "triaged" if it has both status:: and type:: and complexity:: labels.
+ * Triaged issues skip the triage step and go directly to planning.
+ */
+export function isTriaged(task) {
+    // Platform tasks that were created by the setup pipeline (it-analyst/technical-planner)
+    // already have proper labels. We check if the source data had explicit labels.
+    // The simplest heuristic: if the task has a non-default status label AND description
+    // contains structured sections (acceptance criteria), it's been triaged.
+    // But for now, we use a simpler approach: issues with all 3 metadata labels are triaged.
+    return task.source === 'platform' && task.status === 'todo'
+        && task.type !== 'fullstack' // has explicit type (not fallback)
+        && task.complexity !== 'M'; // has explicit complexity (not fallback)
+}
+// ─── Heuristic inference (fallback when labels missing) ───
+const FRONTEND_SIGNALS = ['component', 'ui', 'css', 'scss', 'template', 'form', 'button', 'page', 'modal', 'dialog', 'layout', 'responsive', 'animation'];
+const BACKEND_SIGNALS = ['api', 'endpoint', 'database', 'migration', 'auth', 'middleware', 'worker', 'cron', 'server', 'query', 'schema'];
+export function inferType(title, body) {
+    const text = `${title} ${body}`.toLowerCase();
+    const fScore = FRONTEND_SIGNALS.filter(s => text.includes(s)).length;
+    const bScore = BACKEND_SIGNALS.filter(s => text.includes(s)).length;
+    if (fScore > 0 && bScore > 0)
+        return 'fullstack';
+    if (fScore > bScore)
+        return 'frontend';
+    if (bScore > fScore)
+        return 'backend';
+    return 'fullstack';
+}
+export function inferComplexity(title, body) {
+    const text = `${title} ${body}`;
+    const criteriaCount = (text.match(/^[-*]\s/gm) ?? []).length;
+    const wordCount = text.split(/\s+/).length;
+    if (criteriaCount >= 8 || wordCount >= 500)
+        return 'L';
+    if (criteriaCount >= 3 || wordCount >= 150)
+        return 'M';
+    return 'S';
+}
+// ─── Update issue on platform ───
+export function updateIssueBody(cwd, platform, issueNumber, body) {
+    const num = String(issueNumber);
+    if (platform === 'github') {
+        run('gh', ['issue', 'edit', num, '--body', body], cwd);
+    }
+    else {
+        run('glab', ['issue', 'update', num, '--description', body], cwd);
+    }
+}
+export function addIssueLabels(cwd, platform, issueNumber, labels) {
+    if (labels.length === 0)
+        return;
+    const num = String(issueNumber);
+    if (platform === 'github') {
+        run('gh', ['issue', 'edit', num, '--add-label', labels.join(',')], cwd);
+    }
+    else {
+        run('glab', ['issue', 'update', num, '--label', labels.join(',')], cwd);
+    }
+}
+export function closeIssue(cwd, platform, issueNumber, comment) {
+    const num = String(issueNumber);
+    if (comment) {
+        if (platform === 'github') {
+            run('gh', ['issue', 'comment', num, '--body', comment], cwd);
+        }
+        else {
+            run('glab', ['issue', 'note', num, '--message', comment], cwd);
+        }
+    }
+    if (platform === 'github') {
+        run('gh', ['issue', 'close', num], cwd);
+    }
+    else {
+        run('glab', ['issue', 'close', num], cwd);
+    }
+}
 // ─── Update issue status on platform ───
 export function updateIssueStatus(cwd, platform, issueNumber, status) {
     const statusLabel = `status::${status}`;

package/dist/scheduler/types.mjs

@@ -6,6 +6,7 @@ export const SCHEDULER_DEFAULTS = {
     maxTurns: 50,
     skipPermissions: true,
     resume: false,
+    resetIterations: false,
     resumeSession: null,
     logFile: '.claude/scheduler/scheduler.log',
     noPull: false,

package/package.json

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