sequant 1.1.1 → 1.1.3

package/dist/src/commands/run.js

@@ -1,23 +1,110 @@
 /**
  * sequant run - Execute workflow for GitHub issues
  *
- * Runs the Sequant workflow (/spec → /exec → /qa) for one or more issues.
+ * Runs the Sequant workflow (/spec → /exec → /qa) for one or more issues
+ * using the Claude Agent SDK for proper skill invocation.
  */
 import chalk from "chalk";
-import { spawn, spawnSync } from "child_process";
+import { spawnSync } from "child_process";
+import { query } from "@anthropic-ai/claude-agent-sdk";
 import { getManifest } from "../lib/manifest.js";
+import { getSettings } from "../lib/settings.js";
 import { LogWriter, createPhaseLogFromTiming, } from "../lib/workflow/log-writer.js";
+import { DEFAULT_PHASES, DEFAULT_CONFIG, } from "../lib/workflow/types.js";
+/**
+ * Natural language prompts for each phase
+ * These prompts will invoke the corresponding skills via natural language
+ */
+const PHASE_PROMPTS = {
+    spec: "Review GitHub issue #{issue} and create an implementation plan with verification criteria. Run the /spec {issue} workflow.",
+    testgen: "Generate test stubs for GitHub issue #{issue} based on the specification. Run the /testgen {issue} workflow.",
+    exec: "Implement the feature for GitHub issue #{issue} following the spec. Run the /exec {issue} workflow.",
+    test: "Execute structured browser-based testing for GitHub issue #{issue}. Run the /test {issue} workflow.",
+    qa: "Review the implementation for GitHub issue #{issue} against acceptance criteria. Run the /qa {issue} workflow.",
+    loop: "Parse test/QA findings for GitHub issue #{issue} and iterate until quality gates pass. Run the /loop {issue} workflow.",
+};
+/**
+ * UI-related labels that trigger automatic test phase
+ */
+const UI_LABELS = ["ui", "frontend", "admin", "web", "browser"];
+/**
+ * Bug-related labels that skip spec phase
+ */
+const BUG_LABELS = ["bug", "fix", "hotfix", "patch"];
+/**
+ * Documentation labels that skip spec phase
+ */
+const DOCS_LABELS = ["docs", "documentation", "readme"];
+/**
+ * Complex labels that enable quality loop
+ */
+const COMPLEX_LABELS = ["complex", "refactor", "breaking", "major"];
 /**
- * Check if claude CLI is available
+ * Detect phases based on issue labels (like /solve logic)
  */
-function checkClaudeCli() {
-    const result = spawnSync("claude", ["--version"], {
-        stdio: "pipe",
-        shell: true,
-    });
-    return result.status === 0;
+function detectPhasesFromLabels(labels) {
+    const lowerLabels = labels.map((l) => l.toLowerCase());
+    // Check for bug/fix labels → exec → qa (skip spec)
+    const isBugFix = lowerLabels.some((label) => BUG_LABELS.some((bugLabel) => label.includes(bugLabel)));
+    // Check for docs labels → exec → qa (skip spec)
+    const isDocs = lowerLabels.some((label) => DOCS_LABELS.some((docsLabel) => label.includes(docsLabel)));
+    // Check for UI labels → add test phase
+    const isUI = lowerLabels.some((label) => UI_LABELS.some((uiLabel) => label.includes(uiLabel)));
+    // Check for complex labels → enable quality loop
+    const isComplex = lowerLabels.some((label) => COMPLEX_LABELS.some((complexLabel) => label.includes(complexLabel)));
+    // Build phase list
+    let phases;
+    if (isBugFix || isDocs) {
+        // Simple workflow: exec → qa
+        phases = ["exec", "qa"];
+    }
+    else if (isUI) {
+        // UI workflow: spec → exec → test → qa
+        phases = ["spec", "exec", "test", "qa"];
+    }
+    else {
+        // Standard workflow: spec → exec → qa
+        phases = ["spec", "exec", "qa"];
+    }
+    return { phases, qualityLoop: isComplex };
+}
+/**
+ * Parse recommended workflow from /spec output
+ *
+ * Looks for:
+ * ## Recommended Workflow
+ * **Phases:** exec → qa
+ * **Quality Loop:** enabled|disabled
+ */
+function parseRecommendedWorkflow(output) {
+    // Find the Recommended Workflow section
+    const workflowMatch = output.match(/## Recommended Workflow[\s\S]*?\*\*Phases:\*\*\s*([^\n]+)/i);
+    if (!workflowMatch) {
+        return null;
+    }
+    // Parse phases from "exec → qa" or "spec → exec → test → qa" format
+    const phasesStr = workflowMatch[1].trim();
+    const phaseNames = phasesStr
+        .split(/\s*→\s*|\s*->\s*|\s*,\s*/)
+        .map((p) => p.trim().toLowerCase())
+        .filter((p) => p.length > 0);
+    // Validate and convert to Phase type
+    const validPhases = [];
+    for (const name of phaseNames) {
+        if (["spec", "testgen", "exec", "test", "qa", "loop"].includes(name)) {
+            validPhases.push(name);
+        }
+    }
+    if (validPhases.length === 0) {
+        return null;
+    }
+    // Parse quality loop setting
+    const qualityLoopMatch = output.match(/\*\*Quality Loop:\*\*\s*(enabled|disabled|true|false|yes|no)/i);
+    const qualityLoop = qualityLoopMatch
+        ? ["enabled", "true", "yes"].includes(qualityLoopMatch[1].toLowerCase())
+        : false;
+    return { phases: validPhases, qualityLoop };
 }
-import { DEFAULT_PHASES, DEFAULT_CONFIG, } from "../lib/workflow/types.js";
 /**
  * Format duration in human-readable format
  */
@@ -30,9 +117,15 @@ function formatDuration(seconds) {
     return `${mins}m ${secs.toFixed(0)}s`;
 }
 /**
- * Execute a single phase for an issue using claude CLI
+ * Get the prompt for a phase with the issue number substituted
  */
-async function executePhase(issueNumber, phase, config) {
+function getPhasePrompt(phase, issueNumber) {
+    return PHASE_PROMPTS[phase].replace(/\{issue\}/g, String(issueNumber));
+}
+/**
+ * Execute a single phase for an issue using Claude Agent SDK
+ */
+async function executePhase(issueNumber, phase, config, sessionId) {
     const startTime = Date.now();
     if (config.dryRun) {
         // Dry run - just simulate
@@ -45,61 +138,136 @@ async function executePhase(issueNumber, phase, config) {
             durationSeconds: 0,
         };
     }
-    // Execute claude CLI with the skill
-    return new Promise((resolve) => {
-        const command = `/${phase} ${issueNumber}`;
-        const timeout = config.phaseTimeout * 1000;
-        if (config.verbose) {
-            console.log(chalk.gray(`    Executing: ${command}`));
-        }
-        const proc = spawn("claude", ["--print", "--dangerously-skip-permissions", "-p", command], {
-            stdio: config.verbose ? "inherit" : "pipe",
-            shell: true,
-            timeout,
+    const prompt = getPhasePrompt(phase, issueNumber);
+    if (config.verbose) {
+        console.log(chalk.gray(`    Prompt: ${prompt}`));
+    }
+    try {
+        // Create abort controller for timeout
+        const abortController = new AbortController();
+        const timeoutId = setTimeout(() => {
+            abortController.abort();
+        }, config.phaseTimeout * 1000);
+        let resultSessionId;
+        let resultMessage;
+        let lastError;
+        let capturedOutput = "";
+        // Execute using Claude Agent SDK
+        const queryInstance = query({
+            prompt,
+            options: {
+                abortController,
+                cwd: process.cwd(),
+                // Load project settings including skills
+                settingSources: ["project"],
+                // Use Claude Code's system prompt and tools
+                systemPrompt: { type: "preset", preset: "claude_code" },
+                tools: { type: "preset", preset: "claude_code" },
+                // Bypass permissions for headless execution
+                permissionMode: "bypassPermissions",
+                allowDangerouslySkipPermissions: true,
+                // Resume from previous session if provided
+                ...(sessionId ? { resume: sessionId } : {}),
+                // Configure smart tests via environment
+                env: {
+                    ...process.env,
+                    CLAUDE_HOOKS_SMART_TESTS: config.noSmartTests ? "false" : "true",
+                },
+            },
         });
-        let killed = false;
-        const timer = setTimeout(() => {
-            killed = true;
-            proc.kill("SIGTERM");
-        }, timeout);
-        proc.on("close", (code) => {
-            clearTimeout(timer);
-            const durationSeconds = (Date.now() - startTime) / 1000;
-            if (killed) {
-                resolve({
-                    phase,
-                    success: false,
-                    durationSeconds,
-                    error: `Timeout after ${config.phaseTimeout}s`,
-                });
+        // Stream and process messages
+        for await (const message of queryInstance) {
+            // Capture session ID from system init message
+            if (message.type === "system" && message.subtype === "init") {
+                resultSessionId = message.session_id;
+            }
+            // Capture output from assistant messages
+            if (message.type === "assistant") {
+                // Extract text content from the message
+                const content = message.message.content;
+                const textContent = content
+                    .filter((c) => c.type === "text" && c.text)
+                    .map((c) => c.text)
+                    .join("");
+                if (textContent) {
+                    capturedOutput += textContent;
+                    // Show streaming output in verbose mode
+                    if (config.verbose) {
+                        process.stdout.write(chalk.gray(textContent));
+                    }
+                }
+            }
+            // Capture the final result
+            if (message.type === "result") {
+                resultMessage = message;
             }
-            else if (code === 0) {
-                resolve({
+        }
+        clearTimeout(timeoutId);
+        const durationSeconds = (Date.now() - startTime) / 1000;
+        // Check result status
+        if (resultMessage) {
+            if (resultMessage.subtype === "success") {
+                return {
                     phase,
                     success: true,
                     durationSeconds,
-                });
+                    sessionId: resultSessionId,
+                    output: capturedOutput,
+                };
             }
             else {
-                resolve({
+                // Handle error subtypes
+                const errorSubtype = resultMessage.subtype;
+                if (errorSubtype === "error_max_turns") {
+                    lastError = "Max turns reached";
+                }
+                else if (errorSubtype === "error_during_execution") {
+                    lastError =
+                        resultMessage.errors?.join(", ") || "Error during execution";
+                }
+                else if (errorSubtype === "error_max_budget_usd") {
+                    lastError = "Budget limit exceeded";
+                }
+                else {
+                    lastError = `Error: ${errorSubtype}`;
+                }
+                return {
                     phase,
                     success: false,
                     durationSeconds,
-                    error: `Exit code ${code}`,
-                });
+                    error: lastError,
+                    sessionId: resultSessionId,
+                };
             }
-        });
-        proc.on("error", (err) => {
-            clearTimeout(timer);
-            const durationSeconds = (Date.now() - startTime) / 1000;
-            resolve({
+        }
+        // No result message received
+        return {
+            phase,
+            success: false,
+            durationSeconds: (Date.now() - startTime) / 1000,
+            error: "No result received from Claude",
+            sessionId: resultSessionId,
+        };
+    }
+    catch (err) {
+        const durationSeconds = (Date.now() - startTime) / 1000;
+        const error = err instanceof Error ? err.message : String(err);
+        // Check if it was an abort (timeout)
+        if (error.includes("abort") || error.includes("AbortError")) {
+            return {
                 phase,
                 success: false,
                 durationSeconds,
-                error: err.message,
-            });
-        });
-    });
+                error: `Timeout after ${config.phaseTimeout}s`,
+            };
+        }
+        return {
+            phase,
+            success: false,
+            durationSeconds,
+            error,
+        };
+    }
 }
 /**
  * Fetch issue info from GitHub
@@ -129,47 +297,141 @@ async function getIssueInfo(issueNumber) {
     }
     return { title: `Issue #${issueNumber}`, labels: [] };
 }
+/**
+ * Check if an issue has UI-related labels
+ */
+function hasUILabels(labels) {
+    return labels.some((label) => UI_LABELS.some((uiLabel) => label.toLowerCase().includes(uiLabel)));
+}
+/**
+ * Determine phases to run based on options and issue labels
+ */
+function determinePhasesForIssue(basePhases, labels, options) {
+    let phases = [...basePhases];
+    // Add testgen phase after spec if requested
+    if (options.testgen && phases.includes("spec")) {
+        const specIndex = phases.indexOf("spec");
+        if (!phases.includes("testgen")) {
+            phases.splice(specIndex + 1, 0, "testgen");
+        }
+    }
+    // Auto-detect UI issues and add test phase
+    if (hasUILabels(labels) && !phases.includes("test")) {
+        // Add test phase before qa if present, otherwise at the end
+        const qaIndex = phases.indexOf("qa");
+        if (qaIndex !== -1) {
+            phases.splice(qaIndex, 0, "test");
+        }
+        else {
+            phases.push("test");
+        }
+    }
+    return phases;
+}
+/**
+ * Parse environment variables for CI configuration
+ */
+function getEnvConfig() {
+    const config = {};
+    if (process.env.SEQUANT_QUALITY_LOOP === "true") {
+        config.qualityLoop = true;
+    }
+    if (process.env.SEQUANT_MAX_ITERATIONS) {
+        const maxIter = parseInt(process.env.SEQUANT_MAX_ITERATIONS, 10);
+        if (!isNaN(maxIter)) {
+            config.maxIterations = maxIter;
+        }
+    }
+    if (process.env.SEQUANT_SMART_TESTS === "false") {
+        config.noSmartTests = true;
+    }
+    if (process.env.SEQUANT_TESTGEN === "true") {
+        config.testgen = true;
+    }
+    return config;
+}
+/**
+ * Parse batch arguments into groups of issues
+ */
+function parseBatches(batchArgs) {
+    return batchArgs.map((batch) => batch
+        .split(/\s+/)
+        .map((n) => parseInt(n, 10))
+        .filter((n) => !isNaN(n)));
+}
 /**
  * Main run command
  */
 export async function runCommand(issues, options) {
-    console.log(chalk.blue("\n🚀 Sequant Workflow Execution\n"));
+    console.log(chalk.blue("\n🌐 Sequant Workflow Execution\n"));
     // Check if initialized
     const manifest = await getManifest();
     if (!manifest) {
         console.log(chalk.red("❌ Sequant is not initialized. Run `sequant init` first."));
         return;
     }
-    // Check if claude CLI is available (skip for dry-run)
-    if (!options.dryRun && !checkClaudeCli()) {
-        console.log(chalk.red("❌ Claude CLI not found. Install it from https://claude.ai/code"));
-        console.log(chalk.gray("  Or use --dry-run to preview without execution."));
-        return;
+    // Load settings and merge with environment config and CLI options
+    const settings = await getSettings();
+    const envConfig = getEnvConfig();
+    // Settings provide defaults, env overrides settings, CLI overrides all
+    // Note: phases are auto-detected per-issue unless --phases is explicitly set
+    const mergedOptions = {
+        // Settings defaults (phases removed - now auto-detected)
+        sequential: options.sequential ?? settings.run.sequential,
+        timeout: options.timeout ?? settings.run.timeout,
+        logPath: options.logPath ?? settings.run.logPath,
+        qualityLoop: options.qualityLoop ?? settings.run.qualityLoop,
+        maxIterations: options.maxIterations ?? settings.run.maxIterations,
+        noSmartTests: options.noSmartTests ?? !settings.run.smartTests,
+        // Env overrides
+        ...envConfig,
+        // CLI explicit options override all
+        ...options,
+    };
+    // Determine if we should auto-detect phases from labels
+    const autoDetectPhases = !options.phases && settings.run.autoDetectPhases;
+    mergedOptions.autoDetectPhases = autoDetectPhases;
+    // Parse issue numbers (or use batch mode)
+    let issueNumbers;
+    let batches = null;
+    if (mergedOptions.batch && mergedOptions.batch.length > 0) {
+        batches = parseBatches(mergedOptions.batch);
+        issueNumbers = batches.flat();
+        console.log(chalk.gray(`  Batch mode: ${batches.map((b) => `[${b.join(", ")}]`).join(" → ")}`));
+    }
+    else {
+        issueNumbers = issues.map((i) => parseInt(i, 10)).filter((n) => !isNaN(n));
     }
-    // Parse issue numbers
-    const issueNumbers = issues
-        .map((i) => parseInt(i, 10))
-        .filter((n) => !isNaN(n));
     if (issueNumbers.length === 0) {
         console.log(chalk.red("❌ No valid issue numbers provided."));
         console.log(chalk.gray("\nUsage: sequant run <issues...> [options]"));
         console.log(chalk.gray("Example: sequant run 1 2 3 --sequential"));
+        console.log(chalk.gray('Batch example: sequant run --batch "1 2" --batch "3"'));
         return;
     }
     // Build config
+    // Note: config.phases is only used when --phases is explicitly set or autoDetect fails
+    const explicitPhases = mergedOptions.phases
+        ? mergedOptions.phases.split(",").map((p) => p.trim())
+        : null;
     const config = {
         ...DEFAULT_CONFIG,
-        phases: options.phases
-            ? options.phases.split(",").map((p) => p.trim())
-            : DEFAULT_PHASES,
-        sequential: options.sequential ?? false,
-        dryRun: options.dryRun ?? false,
-        verbose: options.verbose ?? false,
-        phaseTimeout: options.timeout ?? DEFAULT_CONFIG.phaseTimeout,
+        phases: explicitPhases ?? DEFAULT_PHASES,
+        sequential: mergedOptions.sequential ?? false,
+        dryRun: mergedOptions.dryRun ?? false,
+        verbose: mergedOptions.verbose ?? false,
+        phaseTimeout: mergedOptions.timeout ?? DEFAULT_CONFIG.phaseTimeout,
+        qualityLoop: mergedOptions.qualityLoop ?? false,
+        maxIterations: mergedOptions.maxIterations ?? DEFAULT_CONFIG.maxIterations,
+        noSmartTests: mergedOptions.noSmartTests ?? false,
     };
     // Initialize log writer if JSON logging enabled
+    // Default: enabled via settings (logJson: true), can be disabled with --no-log
     let logWriter = null;
-    if (options.logJson && !config.dryRun) {
+    const shouldLog = !mergedOptions.noLog &&
+        !config.dryRun &&
+        (mergedOptions.logJson ?? settings.run.logJson);
+    if (shouldLog) {
         const runConfig = {
             phases: config.phases,
             sequential: config.sequential,
@@ -177,15 +439,29 @@ export async function runCommand(issues, options) {
             maxIterations: config.maxIterations,
         };
         logWriter = new LogWriter({
-            logPath: options.logPath,
+            logPath: mergedOptions.logPath ?? settings.run.logPath,
             verbose: config.verbose,
         });
         await logWriter.initialize(runConfig);
     }
     // Display configuration
     console.log(chalk.gray(`  Stack: ${manifest.stack}`));
-    console.log(chalk.gray(`  Phases: ${config.phases.join(" → ")}`));
+    if (autoDetectPhases) {
+        console.log(chalk.gray(`  Phases: auto-detect from labels`));
+    }
+    else {
+        console.log(chalk.gray(`  Phases: ${config.phases.join(" → ")}`));
+    }
     console.log(chalk.gray(`  Mode: ${config.sequential ? "sequential" : "parallel"}`));
+    if (config.qualityLoop) {
+        console.log(chalk.gray(`  Quality loop: enabled (max ${config.maxIterations} iterations)`));
+    }
+    if (mergedOptions.testgen) {
+        console.log(chalk.gray(`  Testgen: enabled`));
+    }
+    if (config.noSmartTests) {
+        console.log(chalk.gray(`  Smart tests: disabled`));
+    }
     if (config.dryRun) {
         console.log(chalk.yellow(`  ⚠️  DRY RUN - no actual execution`));
     }
@@ -195,15 +471,30 @@ export async function runCommand(issues, options) {
     console.log(chalk.gray(`  Issues: ${issueNumbers.map((n) => `#${n}`).join(", ")}`));
     // Execute
     const results = [];
-    if (config.sequential) {
+    if (batches) {
+        // Batch execution: run batches sequentially, issues within batch based on mode
+        for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+            const batch = batches[batchIdx];
+            console.log(chalk.blue(`\n  Batch ${batchIdx + 1}/${batches.length}: Issues ${batch.map((n) => `#${n}`).join(", ")}`));
+            const batchResults = await executeBatch(batch, config, logWriter, mergedOptions);
+            results.push(...batchResults);
+            // Check if batch failed and we should stop
+            const batchFailed = batchResults.some((r) => !r.success);
+            if (batchFailed && config.sequential) {
+                console.log(chalk.yellow(`\n  ⚠️  Batch ${batchIdx + 1} failed, stopping batch execution`));
+                break;
+            }
+        }
+    }
+    else if (config.sequential) {
         // Sequential execution
         for (const issueNumber of issueNumbers) {
+            const issueInfo = await getIssueInfo(issueNumber);
             // Start issue logging
             if (logWriter) {
-                const issueInfo = await getIssueInfo(issueNumber);
                 logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
             }
-            const result = await runIssueWithLogging(issueNumber, config, logWriter);
+            const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions);
             results.push(result);
             // Complete issue logging
             if (logWriter) {
@@ -219,12 +510,12 @@ export async function runCommand(issues, options) {
         // Parallel execution (for now, just run sequentially but don't stop on failure)
         // TODO: Add proper parallel execution with listr2
         for (const issueNumber of issueNumbers) {
+            const issueInfo = await getIssueInfo(issueNumber);
             // Start issue logging
             if (logWriter) {
-                const issueInfo = await getIssueInfo(issueNumber);
                 logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
             }
-            const result = await runIssueWithLogging(issueNumber, config, logWriter);
+            const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions);
             results.push(result);
             // Complete issue logging
             if (logWriter) {
@@ -252,7 +543,8 @@ export async function runCommand(issues, options) {
         const phases = result.phaseResults
             .map((p) => (p.success ? chalk.green(p.phase) : chalk.red(p.phase)))
             .join(" → ");
-        console.log(`  ${status} #${result.issueNumber}: ${phases}${duration}`);
+        const loopInfo = result.loopTriggered ? chalk.yellow(" [loop]") : "";
+        console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${duration}`);
     }
     console.log("");
     if (logPath) {
@@ -269,46 +561,201 @@ export async function runCommand(issues, options) {
     }
 }
 /**
- * Execute all phases for a single issue with logging
+ * Execute a batch of issues
  */
-async function runIssueWithLogging(issueNumber, config, logWriter) {
+async function executeBatch(issueNumbers, config, logWriter, options) {
+    const results = [];
+    for (const issueNumber of issueNumbers) {
+        const issueInfo = await getIssueInfo(issueNumber);
+        // Start issue logging
+        if (logWriter) {
+            logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
+        }
+        const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, options);
+        results.push(result);
+        // Complete issue logging
+        if (logWriter) {
+            logWriter.completeIssue();
+        }
+    }
+    return results;
+}
+/**
+ * Execute all phases for a single issue with logging and quality loop
+ */
+async function runIssueWithLogging(issueNumber, config, logWriter, labels, options) {
     const startTime = Date.now();
     const phaseResults = [];
+    let loopTriggered = false;
+    let sessionId;
     console.log(chalk.blue(`\n  Issue #${issueNumber}`));
-    for (const phase of config.phases) {
-        console.log(chalk.gray(`    ⏳ ${phase}...`));
-        const phaseStartTime = new Date();
-        const result = await executePhase(issueNumber, phase, config);
-        const phaseEndTime = new Date();
-        phaseResults.push(result);
-        // Log phase result
-        if (logWriter) {
-            const phaseLog = createPhaseLogFromTiming(phase, issueNumber, phaseStartTime, phaseEndTime, result.success
-                ? "success"
-                : result.error?.includes("Timeout")
-                    ? "timeout"
-                    : "failure", { error: result.error });
-            logWriter.logPhase(phaseLog);
+    // Determine phases for this specific issue
+    let phases;
+    let detectedQualityLoop = false;
+    let specAlreadyRan = false;
+    if (options.autoDetectPhases) {
+        // Check if labels indicate a simple bug/fix (skip spec entirely)
+        const lowerLabels = labels.map((l) => l.toLowerCase());
+        const isSimpleBugFix = lowerLabels.some((label) => BUG_LABELS.some((bugLabel) => label.includes(bugLabel)));
+        if (isSimpleBugFix) {
+            // Simple bug fix: skip spec, go straight to exec → qa
+            phases = ["exec", "qa"];
+            console.log(chalk.gray(`    Bug fix detected: ${phases.join(" → ")}`));
         }
-        if (result.success) {
-            const duration = result.durationSeconds
-                ? ` (${formatDuration(result.durationSeconds)})`
+        else {
+            // Run spec first to get recommended workflow
+            console.log(chalk.gray(`    Running spec to determine workflow...`));
+            console.log(chalk.gray(`    ⏳ spec...`));
+            const specStartTime = new Date();
+            const specResult = await executePhase(issueNumber, "spec", config, sessionId);
+            const specEndTime = new Date();
+            if (specResult.sessionId) {
+                sessionId = specResult.sessionId;
+            }
+            phaseResults.push(specResult);
+            specAlreadyRan = true;
+            // Log spec phase result
+            if (logWriter) {
+                const phaseLog = createPhaseLogFromTiming("spec", issueNumber, specStartTime, specEndTime, specResult.success
+                    ? "success"
+                    : specResult.error?.includes("Timeout")
+                        ? "timeout"
+                        : "failure", { error: specResult.error });
+                logWriter.logPhase(phaseLog);
+            }
+            if (!specResult.success) {
+                console.log(chalk.red(`    ✗ spec: ${specResult.error}`));
+                const durationSeconds = (Date.now() - startTime) / 1000;
+                return {
+                    issueNumber,
+                    success: false,
+                    phaseResults,
+                    durationSeconds,
+                    loopTriggered: false,
+                };
+            }
+            const duration = specResult.durationSeconds
+                ? ` (${formatDuration(specResult.durationSeconds)})`
                 : "";
-            console.log(chalk.green(`    ✓ ${phase}${duration}`));
+            console.log(chalk.green(`    ✓ spec${duration}`));
+            // Parse recommended workflow from spec output
+            let parsedWorkflow = specResult.output
+                ? parseRecommendedWorkflow(specResult.output)
+                : null;
+            if (parsedWorkflow) {
+                // Remove spec from phases since we already ran it
+                phases = parsedWorkflow.phases.filter((p) => p !== "spec");
+                detectedQualityLoop = parsedWorkflow.qualityLoop;
+                console.log(chalk.gray(`    Spec recommends: ${phases.join(" → ")}${detectedQualityLoop ? " (quality loop)" : ""}`));
+            }
+            else {
+                // Fall back to label-based detection
+                console.log(chalk.yellow(`    Could not parse spec recommendation, using label-based detection`));
+                const detected = detectPhasesFromLabels(labels);
+                phases = detected.phases.filter((p) => p !== "spec");
+                detectedQualityLoop = detected.qualityLoop;
+                console.log(chalk.gray(`    Fallback: ${phases.join(" → ")}`));
+            }
+        }
+    }
+    else {
+        // Use explicit phases with adjustments
+        phases = determinePhasesForIssue(config.phases, labels, options);
+        if (phases.length !== config.phases.length) {
+            console.log(chalk.gray(`    Phases adjusted: ${phases.join(" → ")}`));
+        }
+    }
+    // Add testgen phase if requested (and spec was in the phases)
+    if (options.testgen &&
+        (phases.includes("spec") || specAlreadyRan) &&
+        !phases.includes("testgen")) {
+        // Insert testgen at the beginning if spec already ran, otherwise after spec
+        if (specAlreadyRan) {
+            phases.unshift("testgen");
         }
         else {
-            console.log(chalk.red(`    ✗ ${phase}: ${result.error}`));
-            // Stop on first failure
+            const specIndex = phases.indexOf("spec");
+            if (specIndex !== -1) {
+                phases.splice(specIndex + 1, 0, "testgen");
+            }
+        }
+    }
+    let iteration = 0;
+    const useQualityLoop = config.qualityLoop || detectedQualityLoop;
+    const maxIterations = useQualityLoop ? config.maxIterations : 1;
+    while (iteration < maxIterations) {
+        iteration++;
+        if (useQualityLoop && iteration > 1) {
+            console.log(chalk.yellow(`    Quality loop iteration ${iteration}/${maxIterations}`));
+            loopTriggered = true;
+        }
+        let phasesFailed = false;
+        for (const phase of phases) {
+            console.log(chalk.gray(`    ⏳ ${phase}...`));
+            const phaseStartTime = new Date();
+            const result = await executePhase(issueNumber, phase, config, sessionId);
+            const phaseEndTime = new Date();
+            // Capture session ID for subsequent phases
+            if (result.sessionId) {
+                sessionId = result.sessionId;
+            }
+            phaseResults.push(result);
+            // Log phase result
+            if (logWriter) {
+                const phaseLog = createPhaseLogFromTiming(phase, issueNumber, phaseStartTime, phaseEndTime, result.success
+                    ? "success"
+                    : result.error?.includes("Timeout")
+                        ? "timeout"
+                        : "failure", { error: result.error });
+                logWriter.logPhase(phaseLog);
+            }
+            if (result.success) {
+                const duration = result.durationSeconds
+                    ? ` (${formatDuration(result.durationSeconds)})`
+                    : "";
+                console.log(chalk.green(`    ✓ ${phase}${duration}`));
+            }
+            else {
+                console.log(chalk.red(`    ✗ ${phase}: ${result.error}`));
+                phasesFailed = true;
+                // If quality loop enabled, run loop phase to fix issues
+                if (useQualityLoop && iteration < maxIterations) {
+                    console.log(chalk.yellow(`    Running /loop to fix issues...`));
+                    const loopResult = await executePhase(issueNumber, "loop", config, sessionId);
+                    phaseResults.push(loopResult);
+                    if (loopResult.sessionId) {
+                        sessionId = loopResult.sessionId;
+                    }
+                    if (loopResult.success) {
+                        console.log(chalk.green(`    ✓ loop - retrying phases`));
+                        // Continue to next iteration
+                        break;
+                    }
+                    else {
+                        console.log(chalk.red(`    ✗ loop: ${loopResult.error}`));
+                    }
+                }
+                // Stop on first failure (if not in quality loop or loop failed)
+                break;
+            }
+        }
+        // If all phases passed, exit the loop
+        if (!phasesFailed) {
+            break;
+        }
+        // If we're not in quality loop mode, don't retry
+        if (!config.qualityLoop) {
             break;
         }
     }
     const durationSeconds = (Date.now() - startTime) / 1000;
-    const success = phaseResults.every((r) => r.success);
+    const success = phaseResults.length > 0 && phaseResults.every((r) => r.success);
     return {
         issueNumber,
         success,
         phaseResults,
         durationSeconds,
+        loopTriggered,
     };
 }
 //# sourceMappingURL=run.js.map