sequant 2.0.0 → 2.0.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "sequant",
   "description": "Structured workflow system for Claude Code - GitHub issue resolution with spec, exec, test, and QA phases",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "author": {
     "name": "sequant-io",
     "email": "hello@sequant.io"

package/README.md

@@ -1,6 +1,6 @@
 # Sequant
 
-**Workflow automation for [Claude Code](https://claude.ai/code).**
+**Workflow automation for AI coding agents.**
 
 Solve GitHub issues with structured phases and quality gates — from issue to merge-ready PR.
 
@@ -64,8 +64,9 @@ Or step-by-step:
 
 ### Prerequisites
 
-**Required:**
-- [Claude Code](https://claude.ai/code) — AI coding assistant
+**Required (one of):**
+- [Claude Code](https://claude.ai/code) — default agent
+- [Aider](https://aider.chat/) — alternative via `--agent aider`
 - [GitHub CLI](https://cli.github.com/) — run `gh auth login`
 - Git (for worktree-based isolation)
 
@@ -83,7 +84,7 @@ Or step-by-step:
 
 ## How It Works
 
-Sequant adds slash commands to Claude Code that enforce a structured workflow:
+Sequant enforces a structured workflow through slash commands (interactive) or CLI (headless):
 
 ```
 ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐
@@ -133,9 +134,9 @@ When checks fail, `/loop` automatically fixes and re-runs (up to 3x).
 
 ## Two Ways to Use
 
-### Interactive (Claude Code)
+### Interactive (Slash Commands)
 
-Type commands directly in Claude Code chat:
+Type commands in Claude Code or any MCP-connected client:
 
 ```
 /fullsolve 123              # Complete pipeline

package/dist/src/lib/workflow/batch-executor.d.ts

@@ -7,7 +7,7 @@
  * (including quality-loop retries, checkpoint commits, rebasing, and PR
  * creation).
  */
-import { IssueResult, type RunOptions, type IssueExecutionContext, type BatchExecutionContext } from "./types.js";
+import { PhaseResult, IssueResult, type RunOptions, type IssueExecutionContext, type BatchExecutionContext } from "./types.js";
 export type { RunOptions, ProgressCallback, IssueExecutionContext, BatchExecutionContext, } from "./types.js";
 /**
  * Emit a structured progress line to stderr for MCP progress notifications.
@@ -19,6 +19,14 @@ export type { RunOptions, ProgressCallback, IssueExecutionContext, BatchExecutio
  * @param event - Phase lifecycle event: "start", "complete", or "failed"
  * @param extra - Optional fields: durationSeconds (on complete), error (on failed)
  */
+/**
+ * Build enriched prompt context for the /loop phase from a failed phase result (#488).
+ * Passes QA verdict, failed ACs, and error directly so the /loop skill doesn't need
+ * to reconstruct context from GitHub comments (which fails in subprocess).
+ *
+ * @internal Exported for testing only
+ */
+export declare function buildLoopContext(failedResult: PhaseResult): string;
 export declare function emitProgressLine(issue: number, phase: string, event?: "start" | "complete" | "failed", extra?: {
     durationSeconds?: number;
     error?: string;

package/dist/src/lib/workflow/batch-executor.js

@@ -26,6 +26,34 @@ import { detectPhasesFromLabels, parseRecommendedWorkflow, determinePhasesForIss
  * @param event - Phase lifecycle event: "start", "complete", or "failed"
  * @param extra - Optional fields: durationSeconds (on complete), error (on failed)
  */
+/**
+ * Build enriched prompt context for the /loop phase from a failed phase result (#488).
+ * Passes QA verdict, failed ACs, and error directly so the /loop skill doesn't need
+ * to reconstruct context from GitHub comments (which fails in subprocess).
+ *
+ * @internal Exported for testing only
+ */
+export function buildLoopContext(failedResult) {
+    const parts = [`Previous phase "${failedResult.phase}" failed.`];
+    if (failedResult.verdict) {
+        parts.push(`QA Verdict: ${failedResult.verdict}`);
+    }
+    if (failedResult.summary?.gaps?.length) {
+        parts.push(`QA Gaps:\n${failedResult.summary.gaps.map((gap) => `- ${gap}`).join("\n")}`);
+    }
+    if (failedResult.summary?.suggestions?.length) {
+        parts.push(`Suggestions:\n${failedResult.summary.suggestions.map((s) => `- ${s}`).join("\n")}`);
+    }
+    if (failedResult.error) {
+        parts.push(`Error: ${failedResult.error}`);
+    }
+    // Include tail of output for additional context (truncated to avoid prompt bloat)
+    if (failedResult.output) {
+        const tail = failedResult.output.slice(-2000);
+        parts.push(`Last output:\n${tail}`);
+    }
+    return parts.join("\n\n");
+}
 export function emitProgressLine(issue, phase, event = "start", extra) {
     if (!process.env.SEQUANT_ORCHESTRATOR)
         return;
@@ -634,8 +662,17 @@ export async function runIssueWithLogging(ctx) {
                     catch {
                         /* progress errors must not halt */
                     }
+                    // Build enriched config for loop phase with QA context (#488).
+                    // Pass verdict, failed ACs, and error directly so the /loop skill
+                    // doesn't need to reconstruct context from GitHub comments.
+                    const loopConfig = {
+                        ...issueConfig,
+                        lastVerdict: result.verdict ?? undefined,
+                        failedAcs: result.summary?.gaps?.join("; ") ?? undefined,
+                        promptContext: buildLoopContext(result),
+                    };
                     const loopStartTime = new Date();
-                    const loopResult = await executePhaseWithRetry(issueNumber, "loop", issueConfig, sessionId, worktreePath, shutdownManager, loopSpinner);
+                    const loopResult = await executePhaseWithRetry(issueNumber, "loop", loopConfig, sessionId, worktreePath, shutdownManager, loopSpinner);
                     const loopEndTime = new Date();
                     phaseResults.push(loopResult);
                     // Emit loop completion/failure progress event (AC-8)

package/dist/src/lib/workflow/phase-executor.d.ts

@@ -48,7 +48,7 @@ export declare function formatDuration(seconds: number): string;
  *
  * @internal Exported for testing only
  */
-export declare function getPhasePrompt(phase: Phase, issueNumber: number, agent?: string): Promise<string>;
+export declare function getPhasePrompt(phase: Phase, issueNumber: number, agent?: string, promptContext?: string): Promise<string>;
 /**
  * Execute a single phase for an issue using the configured AgentDriver.
  */

package/dist/src/lib/workflow/phase-executor.js

@@ -224,9 +224,13 @@ export function formatDuration(seconds) {
  *
  * @internal Exported for testing only
  */
-export async function getPhasePrompt(phase, issueNumber, agent) {
+export async function getPhasePrompt(phase, issueNumber, agent, promptContext) {
     const prompts = agent && agent !== "claude-code" ? AIDER_PHASE_PROMPTS : PHASE_PROMPTS;
-    const basePrompt = prompts[phase].replace(/\{issue\}/g, String(issueNumber));
+    let basePrompt = prompts[phase].replace(/\{issue\}/g, String(issueNumber));
+    // Append phase-specific context (e.g., QA findings for loop phase)
+    if (promptContext) {
+        basePrompt += `\n\n---\n\n${promptContext}`;
+    }
     // Include AGENTS.md content in the prompt context for non-Claude agent compatibility.
     // Claude reads CLAUDE.md natively, but other agents (Aider, Codex, Gemini CLI)
     // rely on AGENTS.md for project context.
@@ -241,7 +245,7 @@ export async function getPhasePrompt(phase, issueNumber, agent) {
  */
 async function executePhase(issueNumber, phase, config, sessionId, worktreePath, shutdownManager, spinner) {
     const startTime = Date.now();
-    const prompt = await getPhasePrompt(phase, issueNumber, config.agent);
+    const prompt = await getPhasePrompt(phase, issueNumber, config.agent, config.promptContext);
     if (config.dryRun) {
         // Dry run - show the prompt that would be sent, then return
         if (config.verbose) {
@@ -318,6 +322,13 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath,
     if (config.issueType) {
         env.SEQUANT_ISSUE_TYPE = config.issueType;
     }
+    // Pass QA context to loop phase so it doesn't need to reconstruct from GitHub (#488)
+    if (config.lastVerdict) {
+        env.SEQUANT_LAST_VERDICT = config.lastVerdict;
+    }
+    if (config.failedAcs) {
+        env.SEQUANT_FAILED_ACS = config.failedAcs;
+    }
     // Track whether we're actively streaming verbose output
     // Pausing spinner once per streaming session prevents truncation from rapid pause/resume cycles
     // (Issue #283: ora's stop() clears the current line, which can truncate output when
@@ -452,36 +463,51 @@ delayFn = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
     if (config.retry === false) {
         return executePhaseFn(issueNumber, phase, config, sessionId, worktreePath, shutdownManager, spinner);
     }
+    // Skip cold-start retries for `loop` phase (#488).
+    // Loop is always a re-run after a failed QA — never a first boot.
+    // Failures at 47-51s are genuine skill failures, not cold-start issues.
+    // Without this guard, 2 cold-start retries + 1 MCP fallback = 3 wasted spawns per loop.
+    const skipColdStartRetry = phase === "loop";
     let lastResult;
-    // Phase 1: Cold-start retry attempts (with MCP enabled if configured)
-    for (let attempt = 0; attempt <= COLD_START_MAX_RETRIES; attempt++) {
+    if (skipColdStartRetry) {
+        // Single attempt — no cold-start retry loop
         lastResult = await executePhaseFn(issueNumber, phase, config, sessionId, worktreePath, shutdownManager, spinner);
-        const duration = lastResult.durationSeconds ?? 0;
-        // Success → return immediately
         if (lastResult.success) {
             return lastResult;
         }
-        // Genuine failure (took long enough to be real work) → skip cold-start retries.
-        // For spec phase, break to allow Phase 3 (spec-specific retry) to run.
-        // For other phases, return immediately — no further retries.
-        if (duration >= COLD_START_THRESHOLD_SECONDS) {
-            if (phase === "spec") {
-                break;
+    }
+    else {
+        // Phase 1: Cold-start retry attempts (with MCP enabled if configured)
+        for (let attempt = 0; attempt <= COLD_START_MAX_RETRIES; attempt++) {
+            lastResult = await executePhaseFn(issueNumber, phase, config, sessionId, worktreePath, shutdownManager, spinner);
+            const duration = lastResult.durationSeconds ?? 0;
+            // Success → return immediately
+            if (lastResult.success) {
+                return lastResult;
             }
-            return lastResult;
-        }
-        // Cold-start failure detected — retry
-        if (attempt < COLD_START_MAX_RETRIES) {
-            if (config.verbose) {
-                console.log(chalk.yellow(`\n    ⟳ Cold-start failure detected (${duration.toFixed(1)}s), retrying... (attempt ${attempt + 2}/${COLD_START_MAX_RETRIES + 1})`));
+            // Genuine failure (took long enough to be real work) → skip cold-start retries.
+            // For spec phase, break to allow Phase 3 (spec-specific retry) to run.
+            // For other phases, return immediately — no further retries.
+            if (duration >= COLD_START_THRESHOLD_SECONDS) {
+                if (phase === "spec") {
+                    break;
+                }
+                return lastResult;
+            }
+            // Cold-start failure detected — retry
+            if (attempt < COLD_START_MAX_RETRIES) {
+                if (config.verbose) {
+                    console.log(chalk.yellow(`\n    ⟳ Cold-start failure detected (${duration.toFixed(1)}s), retrying... (attempt ${attempt + 2}/${COLD_START_MAX_RETRIES + 1})`));
+                }
             }
         }
     }
     // Capture the original error for better diagnostics
     const originalError = lastResult.error;
     // Phase 2: MCP fallback - if MCP is enabled and we're still failing, try without MCP
-    // This handles npx-based MCP servers that fail on first run due to cold-cache issues
-    if (config.mcp && !lastResult.success) {
+    // This handles npx-based MCP servers that fail on first run due to cold-cache issues.
+    // Skip for `loop` phase — MCP is never the cause of loop failures (#488).
+    if (config.mcp && !lastResult.success && !skipColdStartRetry) {
         console.log(chalk.yellow(`\n    ⚠️ Phase failed with MCP enabled, retrying without MCP...`));
         // Create config copy with MCP disabled
         const configWithoutMcp = {

package/dist/src/lib/workflow/types.d.ts

@@ -80,6 +80,22 @@ export interface ExecutionConfig {
      * Propagated as SEQUANT_ISSUE_TYPE env var to skills.
      */
     issueType?: string;
+    /**
+     * Additional context appended to the phase prompt.
+     * Used by the quality loop to pass QA findings directly to the /loop skill
+     * so it doesn't need to reconstruct context from GitHub comments.
+     */
+    promptContext?: string;
+    /**
+     * Last QA verdict from a preceding phase.
+     * Propagated as SEQUANT_LAST_VERDICT env var to skills.
+     */
+    lastVerdict?: string;
+    /**
+     * Failed AC descriptions from a preceding QA phase.
+     * Propagated as SEQUANT_FAILED_ACS env var to skills.
+     */
+    failedAcs?: string;
 }
 /**
  * Default execution configuration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sequant",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Quantize your development workflow - Sequential AI phases with quality gates",
   "type": "module",
   "bin": {
@@ -32,16 +32,26 @@
     "prepublishOnly": "npm run build"
   },
   "keywords": [
+    "ai",
     "claude",
     "claude-code",
+    "aider",
+    "mcp",
+    "cli",
     "workflow",
-    "ai",
     "automation",
-    "quality",
-    "sequential",
-    "agent-skills",
-    "cursor",
-    "vscode"
+    "coding-agent",
+    "agent",
+    "github",
+    "github-issues",
+    "quality-gates",
+    "code-quality",
+    "orchestrator",
+    "developer-tools",
+    "anthropic",
+    "llm",
+    "ai-coding",
+    "copilot"
   ],
   "author": "Sequant Contributors",
   "license": "MIT",