sequant 1.15.3 → 1.15.4

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": "1.15.3",
+  "version": "1.15.4",
   "author": {
     "name": "sequant-io",
     "email": "hello@sequant.io"

package/dist/bin/cli.js

@@ -142,6 +142,7 @@ program
     .option("--no-retry", "Disable automatic retry with MCP fallback (useful for debugging)")
     .option("--resume", "Resume from last completed phase (reads phase markers from GitHub)")
     .option("--no-rebase", "Skip pre-PR rebase onto origin/main (use when you want to handle rebasing manually)")
+    .option("--no-pr", "Skip PR creation after successful QA (manual PR workflow)")
     .option("-f, --force", "Force re-execution of completed issues (bypass pre-flight state guard)")
     .action(runCommand);
 program

package/dist/src/commands/run.d.ts

@@ -130,6 +130,36 @@ export interface RebaseResult {
  * @internal Exported for testing
  */
 export declare function rebaseBeforePR(worktreePath: string, issueNumber: number, packageManager: string | undefined, verbose: boolean): RebaseResult;
+/**
+ * Result of PR creation
+ */
+export interface PRCreationResult {
+    /** Whether PR creation was attempted */
+    attempted: boolean;
+    /** Whether PR was created successfully (or already existed) */
+    success: boolean;
+    /** PR number */
+    prNumber?: number;
+    /** PR URL */
+    prUrl?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Push branch and create a PR after successful QA.
+ *
+ * Handles both fresh PR creation and detection of existing PRs.
+ * Failures are warnings — they don't fail the run.
+ *
+ * @param worktreePath Path to the worktree
+ * @param issueNumber Issue number
+ * @param issueTitle Issue title (for PR title)
+ * @param branch Branch name
+ * @param verbose Whether to show verbose output
+ * @returns PRCreationResult with PR info or error
+ * @internal Exported for testing
+ */
+export declare function createPR(worktreePath: string, issueNumber: number, issueTitle: string, branch: string, verbose: boolean, labels?: string[]): PRCreationResult;
 /**
  * Detect phases based on issue labels (like /solve logic)
  */
@@ -207,6 +237,12 @@ interface RunOptions {
      * Use when you want to preserve branch state or handle rebasing manually.
      */
     noRebase?: boolean;
+    /**
+     * Skip PR creation after successful QA.
+     * When true, branches are pushed but no PR is created.
+     * Useful for manual workflows where PRs are created separately.
+     */
+    noPr?: boolean;
     /**
      * Force re-execution of issues even if they have completed status.
      * Bypasses the pre-flight state guard that skips ready_for_merge/merged issues.

package/dist/src/commands/run.js

@@ -772,6 +772,140 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
         reinstalled,
     };
 }
+/**
+ * Push branch and create a PR after successful QA.
+ *
+ * Handles both fresh PR creation and detection of existing PRs.
+ * Failures are warnings — they don't fail the run.
+ *
+ * @param worktreePath Path to the worktree
+ * @param issueNumber Issue number
+ * @param issueTitle Issue title (for PR title)
+ * @param branch Branch name
+ * @param verbose Whether to show verbose output
+ * @returns PRCreationResult with PR info or error
+ * @internal Exported for testing
+ */
+export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose, labels) {
+    // Step 1: Check for existing PR on this branch
+    const existingPR = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
+    if (existingPR.status === 0 && existingPR.stdout) {
+        try {
+            const prInfo = JSON.parse(existingPR.stdout.toString());
+            if (prInfo.number && prInfo.url) {
+                if (verbose) {
+                    console.log(chalk.gray(`    ℹ️  PR #${prInfo.number} already exists for branch ${branch}`));
+                }
+                return {
+                    attempted: true,
+                    success: true,
+                    prNumber: prInfo.number,
+                    prUrl: prInfo.url,
+                };
+            }
+        }
+        catch {
+            // JSON parse failed — no existing PR, continue to create
+        }
+    }
+    // Step 2: Push branch to remote
+    if (verbose) {
+        console.log(chalk.gray(`    🚀 Pushing branch ${branch} to origin...`));
+    }
+    const pushResult = spawnSync("git", ["-C", worktreePath, "push", "-u", "origin", branch], { stdio: "pipe", timeout: 60000 });
+    if (pushResult.status !== 0) {
+        const pushError = pushResult.stderr?.toString().trim() ?? "Unknown error";
+        console.log(chalk.yellow(`    ⚠️  git push failed: ${pushError}`));
+        return {
+            attempted: true,
+            success: false,
+            error: `git push failed: ${pushError}`,
+        };
+    }
+    // Step 3: Create PR
+    if (verbose) {
+        console.log(chalk.gray(`    📝 Creating PR for #${issueNumber}...`));
+    }
+    const isBug = labels?.some((l) => /^bug/i.test(l));
+    const prefix = isBug ? "fix" : "feat";
+    const prTitle = `${prefix}(#${issueNumber}): ${issueTitle}`;
+    const prBody = [
+        `## Summary`,
+        ``,
+        `Automated PR for issue #${issueNumber}.`,
+        ``,
+        `Fixes #${issueNumber}`,
+        ``,
+        `---`,
+        `🤖 Generated by \`sequant run\``,
+    ].join("\n");
+    const prResult = spawnSync("gh", ["pr", "create", "--title", prTitle, "--body", prBody, "--head", branch], { stdio: "pipe", cwd: worktreePath, timeout: 30000 });
+    if (prResult.status !== 0) {
+        const prError = prResult.stderr?.toString().trim() ?? "Unknown error";
+        // Check if PR already exists (race condition or push-before-PR scenarios)
+        if (prError.includes("already exists")) {
+            const retryView = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
+            if (retryView.status === 0 && retryView.stdout) {
+                try {
+                    const prInfo = JSON.parse(retryView.stdout.toString());
+                    return {
+                        attempted: true,
+                        success: true,
+                        prNumber: prInfo.number,
+                        prUrl: prInfo.url,
+                    };
+                }
+                catch {
+                    // Fall through to error
+                }
+            }
+        }
+        console.log(chalk.yellow(`    ⚠️  PR creation failed: ${prError}`));
+        return {
+            attempted: true,
+            success: false,
+            error: `gh pr create failed: ${prError}`,
+        };
+    }
+    // Step 4: Extract PR URL from output and get PR details
+    const prOutput = prResult.stdout?.toString().trim() ?? "";
+    const prUrlMatch = prOutput.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
+    if (prUrlMatch) {
+        const prNumber = parseInt(prUrlMatch[1], 10);
+        const prUrl = prUrlMatch[0];
+        console.log(chalk.green(`    ✅ PR #${prNumber} created: ${prUrl}`));
+        return {
+            attempted: true,
+            success: true,
+            prNumber,
+            prUrl,
+        };
+    }
+    // Fallback: try gh pr view to get details
+    const viewResult = spawnSync("gh", ["pr", "view", branch, "--json", "number,url"], { stdio: "pipe", cwd: worktreePath, timeout: 15000 });
+    if (viewResult.status === 0 && viewResult.stdout) {
+        try {
+            const prInfo = JSON.parse(viewResult.stdout.toString());
+            console.log(chalk.green(`    ✅ PR #${prInfo.number} created: ${prInfo.url}`));
+            return {
+                attempted: true,
+                success: true,
+                prNumber: prInfo.number,
+                prUrl: prInfo.url,
+            };
+        }
+        catch {
+            // Fall through
+        }
+    }
+    // PR was created but we couldn't parse the URL
+    console.log(chalk.yellow(`    ⚠️  PR created but could not extract URL from output: ${prOutput}`));
+    return {
+        attempted: true,
+        success: true,
+        error: "PR created but URL extraction failed",
+    };
+}
 /**
  * Natural language prompts for each phase
  * These prompts will invoke the corresponding skills via natural language
@@ -1446,18 +1580,31 @@ export async function runCommand(issues, options) {
     const envConfig = getEnvConfig();
     // Settings provide defaults, env overrides settings, CLI overrides all
     // Note: phases are auto-detected per-issue unless --phases is explicitly set
+    // Commander.js converts --no-X to { X: false }, not { noX: true }.
+    // Normalize these so RunOptions fields (noLog, noMcp, etc.) work correctly.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const cliOpts = options;
+    const normalizedOptions = {
+        ...options,
+        ...(cliOpts.log === false && { noLog: true }),
+        ...(cliOpts.smartTests === false && { noSmartTests: true }),
+        ...(cliOpts.mcp === false && { noMcp: true }),
+        ...(cliOpts.retry === false && { noRetry: true }),
+        ...(cliOpts.rebase === false && { noRebase: true }),
+        ...(cliOpts.pr === false && { noPr: true }),
+    };
     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,
+        sequential: normalizedOptions.sequential ?? settings.run.sequential,
+        timeout: normalizedOptions.timeout ?? settings.run.timeout,
+        logPath: normalizedOptions.logPath ?? settings.run.logPath,
+        qualityLoop: normalizedOptions.qualityLoop ?? settings.run.qualityLoop,
+        maxIterations: normalizedOptions.maxIterations ?? settings.run.maxIterations,
+        noSmartTests: normalizedOptions.noSmartTests ?? !settings.run.smartTests,
         // Env overrides
         ...envConfig,
         // CLI explicit options override all
-        ...options,
+        ...normalizedOptions,
     };
     // Determine if we should auto-detect phases from labels
     const autoDetectPhases = !options.phases && settings.run.autoDetectPhases;
@@ -1766,6 +1913,10 @@ export async function runCommand(issues, options) {
                 // In chain mode, only the last issue should trigger pre-PR rebase
                 mergedOptions.chain ? i === issueNumbers.length - 1 : undefined);
                 results.push(result);
+                // Record PR info in log before completing issue
+                if (logWriter && result.prNumber && result.prUrl) {
+                    logWriter.setPRInfo(result.prNumber, result.prUrl);
+                }
                 // Complete issue logging
                 if (logWriter) {
                     logWriter.completeIssue();
@@ -1822,6 +1973,10 @@ export async function runCommand(issues, options) {
                 const result = await runIssueWithLogging(issueNumber, config, logWriter, stateManager, issueInfo.title, issueInfo.labels, mergedOptions, worktreeInfo?.path, worktreeInfo?.branch, shutdown, false, // Parallel mode doesn't support chain
                 manifest.packageManager);
                 results.push(result);
+                // Record PR info in log before completing issue
+                if (logWriter && result.prNumber && result.prUrl) {
+                    logWriter.setPRInfo(result.prNumber, result.prUrl);
+                }
                 // Complete issue logging
                 if (logWriter) {
                     logWriter.completeIssue();
@@ -1940,7 +2095,10 @@ export async function runCommand(issues, options) {
                 .map((p) => p.success ? colors.success(p.phase) : colors.error(p.phase))
                 .join(" → ");
             const loopInfo = result.loopTriggered ? colors.warning(" [loop]") : "";
-            console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${duration}`);
+            const prInfo = result.prUrl
+                ? colors.muted(` → PR #${result.prNumber}`)
+                : "";
+            console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${prInfo}${duration}`);
         }
         console.log("");
         if (logPath) {
@@ -1987,6 +2145,10 @@ async function executeBatch(issueNumbers, config, logWriter, stateManager, optio
         const result = await runIssueWithLogging(issueNumber, config, logWriter, stateManager, issueInfo.title, issueInfo.labels, options, worktreeInfo?.path, worktreeInfo?.branch, shutdownManager, false, // Batch mode doesn't support chain
         packageManager);
         results.push(result);
+        // Record PR info in log before completing issue
+        if (logWriter && result.prNumber && result.prUrl) {
+            logWriter.setPRInfo(result.prNumber, result.prUrl);
+        }
         // Complete issue logging
         if (logWriter) {
             logWriter.completeIssue();
@@ -2343,11 +2505,36 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
     if (shouldRebase) {
         rebaseBeforePR(worktreePath, issueNumber, packageManager, config.verbose);
     }
+    // Create PR after successful QA + rebase (unless --no-pr)
+    let prNumber;
+    let prUrl;
+    const shouldCreatePR = success && worktreePath && branch && !options.noPr;
+    if (shouldCreatePR) {
+        const prResult = createPR(worktreePath, issueNumber, issueTitle, branch, config.verbose, labels);
+        if (prResult.success && prResult.prNumber && prResult.prUrl) {
+            prNumber = prResult.prNumber;
+            prUrl = prResult.prUrl;
+            // Update workflow state with PR info
+            if (stateManager) {
+                try {
+                    await stateManager.updatePRInfo(issueNumber, {
+                        number: prResult.prNumber,
+                        url: prResult.prUrl,
+                    });
+                }
+                catch {
+                    // State tracking errors shouldn't stop execution
+                }
+            }
+        }
+    }
     return {
         issueNumber,
         success,
         phaseResults,
         durationSeconds,
         loopTriggered,
+        prNumber,
+        prUrl,
     };
 }

package/dist/src/lib/workflow/log-writer.d.ts

@@ -59,6 +59,10 @@ export declare class LogWriter {
      * @param phaseLog - Complete phase log entry
      */
     logPhase(phaseLog: PhaseLog): void;
+    /**
+     * Set PR info on the current issue (call before completeIssue)
+     */
+    setPRInfo(prNumber: number, prUrl: string): void;
     /**
      * Complete the current issue and add it to the run log
      */

package/dist/src/lib/workflow/log-writer.js

@@ -98,6 +98,16 @@ export class LogWriter {
             console.log(`📝 Logged phase: ${phaseLog.phase} (${phaseLog.status}) - ${phaseLog.durationSeconds.toFixed(1)}s`);
         }
     }
+    /**
+     * Set PR info on the current issue (call before completeIssue)
+     */
+    setPRInfo(prNumber, prUrl) {
+        if (!this.currentIssue) {
+            return;
+        }
+        this.currentIssue.prNumber = prNumber;
+        this.currentIssue.prUrl = prUrl;
+    }
     /**
      * Complete the current issue and add it to the run log
      */
@@ -114,6 +124,12 @@ export class LogWriter {
             status: this.currentIssue.status,
             phases: this.currentIssue.phases,
             totalDurationSeconds,
+            ...(this.currentIssue.prNumber != null && {
+                prNumber: this.currentIssue.prNumber,
+            }),
+            ...(this.currentIssue.prUrl != null && {
+                prUrl: this.currentIssue.prUrl,
+            }),
         };
         this.runLog.issues.push(issueLog);
         this.currentIssue = null;

package/dist/src/lib/workflow/run-log-schema.d.ts

@@ -197,6 +197,8 @@ export declare const IssueLogSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     totalDurationSeconds: z.ZodNumber;
+    prNumber: z.ZodOptional<z.ZodNumber>;
+    prUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type IssueLog = z.infer<typeof IssueLogSchema>;
 /**
@@ -314,6 +316,8 @@ export declare const RunLogSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         totalDurationSeconds: z.ZodNumber;
+        prNumber: z.ZodOptional<z.ZodNumber>;
+        prUrl: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     summary: z.ZodObject<{
         totalIssues: z.ZodNumber;

package/dist/src/lib/workflow/run-log-schema.js

@@ -126,6 +126,10 @@ export const IssueLogSchema = z.object({
     phases: z.array(PhaseLogSchema),
     /** Total execution time in seconds */
     totalDurationSeconds: z.number().nonnegative(),
+    /** PR number if created after successful QA */
+    prNumber: z.number().int().positive().optional(),
+    /** PR URL if created after successful QA */
+    prUrl: z.string().optional(),
 });
 /**
  * Run configuration

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

@@ -71,6 +71,10 @@ export interface IssueResult {
     abortReason?: string;
     loopTriggered?: boolean;
     durationSeconds?: number;
+    /** PR number if created after successful QA */
+    prNumber?: number;
+    /** PR URL if created after successful QA */
+    prUrl?: string;
 }
 /**
  * CLI arguments for run command

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sequant",
-  "version": "1.15.3",
+  "version": "1.15.4",
   "description": "Quantize your development workflow - Sequential AI phases with quality gates",
   "type": "module",
   "bin": {

package/templates/skills/exec/SKILL.md

@@ -23,6 +23,7 @@ allowed-tools:
   - Bash(git add:*)
   - Bash(git commit:*)
   - Bash(git log:*)
+  - Bash(git push:*)
   - Bash(git worktree:*)
   # Worktree management
   - Bash(./scripts/dev/new-feature.sh:*)