sequant 1.8.0 → 1.10.0

package/README.md

@@ -84,6 +84,7 @@ Run without Claude Code UI:
 npx sequant run 123              # Single issue
 npx sequant run 1 2 3            # Batch (parallel)
 npx sequant run 123 --quality-loop
+npx sequant run 123 --base feature/dashboard  # Custom base branch
 ```
 
 ---
@@ -148,7 +149,8 @@ See [Run Command Options](docs/run-command.md) for advanced usage.
 {
   "run": {
     "qualityLoop": false,
-    "maxIterations": 3
+    "maxIterations": 3,
+    "defaultBase": "feature/dashboard"  // Optional: custom default base branch
   }
 }
 ```
@@ -173,6 +175,7 @@ See [Customization Guide](docs/customization.md) for all options.
 - [Getting Started](docs/getting-started/installation.md)
 - [Workflow Concepts](docs/concepts/workflow-phases.md)
 - [Run Command](docs/run-command.md)
+- [Feature Branch Workflows](docs/feature-branch-workflow.md)
 - [Customization](docs/customization.md)
 - [Troubleshooting](docs/troubleshooting.md)
 

package/dist/bin/cli.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from "url";
 import { dirname, resolve } from "path";
 import { readFileSync } from "fs";
 import { initCommand } from "../src/commands/init.js";
+import { isLocalNodeModulesInstall } from "../src/lib/version-check.js";
 // Read version from package.json dynamically
 // Works from both source (bin/) and compiled (dist/bin/) locations
 function getVersion() {
@@ -43,6 +44,13 @@ const program = new Command();
 if (process.argv.includes("--no-color")) {
     process.env.FORCE_COLOR = "0";
 }
+// Warn if running from local node_modules (not npx cache or global)
+// This helps users who accidentally have a stale local install
+if (!process.argv.includes("--quiet") && isLocalNodeModulesInstall()) {
+    console.warn(chalk.yellow("⚠️  Running sequant from local node_modules\n" +
+        "   For latest version: npx sequant@latest\n" +
+        "   To remove local: npm uninstall sequant\n"));
+}
 program
     .name("sequant")
     .description("Quantize your development workflow - Sequential AI phases with quality gates")
@@ -90,6 +98,8 @@ program
     .option("--no-smart-tests", "Disable smart test detection")
     .option("--testgen", "Run testgen phase after spec")
     .option("--quiet", "Suppress version warnings and non-essential output")
+    .option("--chain", "Chain issues: each branches from previous (requires --sequential)")
+    .option("--base <branch>", "Base branch for worktree creation (default: main or settings.run.defaultBase)")
     .action(runCommand);
 program
     .command("logs")

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

@@ -17,6 +17,12 @@ export declare function listWorktrees(): Array<{
  * Get changed files in a worktree compared to main
  */
 export declare function getWorktreeChangedFiles(worktreePath: string): string[];
+/**
+ * Create a checkpoint commit in the worktree after QA passes
+ * This allows recovery in case later issues in the chain fail
+ * @internal Exported for testing
+ */
+export declare function createCheckpointCommit(worktreePath: string, issueNumber: number, verbose: boolean): boolean;
 /**
  * Detect phases based on issue labels (like /solve logic)
  */
@@ -58,6 +64,13 @@ interface RunOptions {
     reuseWorktrees?: boolean;
     /** Suppress version warnings and non-essential output */
     quiet?: boolean;
+    /** Chain issues: each branches from previous (requires --sequential) */
+    chain?: boolean;
+    /**
+     * Base branch for worktree creation.
+     * Resolution priority: this CLI flag → settings.run.defaultBase → 'main'
+     */
+    base?: string;
 }
 /**
  * Main run command

package/dist/src/commands/run.js

@@ -13,6 +13,7 @@ import { getManifest } from "../lib/manifest.js";
 import { getSettings } from "../lib/settings.js";
 import { PM_CONFIG } from "../lib/stacks.js";
 import { LogWriter, createPhaseLogFromTiming, } from "../lib/workflow/log-writer.js";
+import { StateManager, } from "../lib/workflow/state-manager.js";
 import { DEFAULT_PHASES, DEFAULT_CONFIG, } from "../lib/workflow/types.js";
 import { ShutdownManager } from "../lib/shutdown.js";
 import { checkVersionCached, getVersionWarning } from "../lib/version-check.js";
@@ -105,8 +106,9 @@ export function getWorktreeChangedFiles(worktreePath) {
 }
 /**
  * Create or reuse a worktree for an issue
+ * @param baseBranch - Optional branch to use as base instead of origin/main (for chain mode)
  */
-async function ensureWorktree(issueNumber, title, verbose, packageManager) {
+async function ensureWorktree(issueNumber, title, verbose, packageManager, baseBranch) {
     const gitRoot = getGitRoot();
     if (!gitRoot) {
         console.log(chalk.red("    ❌ Not in a git repository"));
@@ -135,15 +137,34 @@ async function ensureWorktree(issueNumber, title, verbose, packageManager) {
     if (verbose) {
         console.log(chalk.gray(`    🌿 Creating worktree for #${issueNumber}...`));
     }
-    // Fetch latest main to ensure worktree starts from fresh baseline
-    if (verbose) {
-        console.log(chalk.gray(`    🔄 Fetching latest main...`));
+    // Determine the base for the new branch
+    // For custom base branches, use origin/<branch> if it's a remote-style reference
+    // For local branches (chain mode), use as-is
+    const isLocalBranch = baseBranch && !baseBranch.startsWith("origin/") && baseBranch !== "main";
+    const baseRef = baseBranch
+        ? isLocalBranch
+            ? baseBranch
+            : baseBranch.startsWith("origin/")
+                ? baseBranch
+                : `origin/${baseBranch}`
+        : "origin/main";
+    // Fetch the base branch to ensure worktree starts from fresh baseline
+    const branchToFetch = baseBranch
+        ? baseBranch.replace(/^origin\//, "")
+        : "main";
+    if (!isLocalBranch) {
+        if (verbose) {
+            console.log(chalk.gray(`    🔄 Fetching latest ${branchToFetch}...`));
+        }
+        const fetchResult = spawnSync("git", ["fetch", "origin", branchToFetch], {
+            stdio: "pipe",
+        });
+        if (fetchResult.status !== 0 && verbose) {
+            console.log(chalk.yellow(`    ⚠️  Could not fetch origin/${branchToFetch}, using local state`));
+        }
     }
-    const fetchResult = spawnSync("git", ["fetch", "origin", "main"], {
-        stdio: "pipe",
-    });
-    if (fetchResult.status !== 0 && verbose) {
-        console.log(chalk.yellow(`    ⚠️  Could not fetch origin/main, using local state`));
+    else if (verbose) {
+        console.log(chalk.gray(`    🔗 Chaining from branch: ${baseBranch}`));
     }
     // Ensure worktrees directory exists
     if (!existsSync(worktreesDir)) {
@@ -158,8 +179,8 @@ async function ensureWorktree(issueNumber, title, verbose, packageManager) {
         });
     }
     else {
-        // Create new branch from origin/main (fresh baseline)
-        createResult = spawnSync("git", ["worktree", "add", worktreePath, "-b", branch, "origin/main"], { stdio: "pipe" });
+        // Create new branch from base reference (origin/main or previous branch in chain)
+        createResult = spawnSync("git", ["worktree", "add", worktreePath, "-b", branch, baseRef], { stdio: "pipe" });
     }
     if (createResult.status !== 0) {
         const error = createResult.stderr.toString();
@@ -208,12 +229,14 @@ async function ensureWorktree(issueNumber, title, verbose, packageManager) {
 }
 /**
  * Ensure worktrees exist for all issues before execution
+ * @param baseBranch - Optional base branch for worktree creation (default: main)
  */
-async function ensureWorktrees(issues, verbose, packageManager) {
+async function ensureWorktrees(issues, verbose, packageManager, baseBranch) {
     const worktrees = new Map();
-    console.log(chalk.blue("\n  📂 Preparing worktrees..."));
+    const baseDisplay = baseBranch || "main";
+    console.log(chalk.blue(`\n  📂 Preparing worktrees from ${baseDisplay}...`));
     for (const issue of issues) {
-        const worktree = await ensureWorktree(issue.number, issue.title, verbose, packageManager);
+        const worktree = await ensureWorktree(issue.number, issue.title, verbose, packageManager, baseBranch);
         if (worktree) {
             worktrees.set(issue.number, worktree);
         }
@@ -225,6 +248,93 @@ async function ensureWorktrees(issues, verbose, packageManager) {
     }
     return worktrees;
 }
+/**
+ * Ensure worktrees exist for all issues in chain mode
+ * Each issue branches from the previous issue's branch
+ * @param baseBranch - Optional starting base branch for the chain (default: main)
+ */
+async function ensureWorktreesChain(issues, verbose, packageManager, baseBranch) {
+    const worktrees = new Map();
+    const baseDisplay = baseBranch || "main";
+    console.log(chalk.blue(`\n  🔗 Preparing chained worktrees from ${baseDisplay}...`));
+    // First issue starts from the specified base branch (or main)
+    let previousBranch = baseBranch;
+    for (const issue of issues) {
+        const worktree = await ensureWorktree(issue.number, issue.title, verbose, packageManager, previousBranch);
+        if (worktree) {
+            worktrees.set(issue.number, worktree);
+            previousBranch = worktree.branch; // Next issue will branch from this
+        }
+        else {
+            // If worktree creation fails, stop the chain
+            console.log(chalk.red(`  ❌ Chain broken: could not create worktree for #${issue.number}`));
+            break;
+        }
+    }
+    const created = Array.from(worktrees.values()).filter((w) => !w.existed).length;
+    const reused = Array.from(worktrees.values()).filter((w) => w.existed).length;
+    if (created > 0 || reused > 0) {
+        console.log(chalk.gray(`  Chained worktrees: ${created} created, ${reused} reused`));
+    }
+    // Show chain structure
+    if (worktrees.size > 0) {
+        const chainOrder = issues
+            .filter((i) => worktrees.has(i.number))
+            .map((i) => `#${i.number}`)
+            .join(" → ");
+        console.log(chalk.gray(`  Chain: ${baseDisplay} → ${chainOrder}`));
+    }
+    return worktrees;
+}
+/**
+ * Create a checkpoint commit in the worktree after QA passes
+ * This allows recovery in case later issues in the chain fail
+ * @internal Exported for testing
+ */
+export function createCheckpointCommit(worktreePath, issueNumber, verbose) {
+    // Check if there are uncommitted changes
+    const statusResult = spawnSync("git", ["-C", worktreePath, "status", "--porcelain"], { stdio: "pipe" });
+    if (statusResult.status !== 0) {
+        if (verbose) {
+            console.log(chalk.yellow(`    ⚠️  Could not check git status for checkpoint`));
+        }
+        return false;
+    }
+    const hasChanges = statusResult.stdout.toString().trim().length > 0;
+    if (!hasChanges) {
+        if (verbose) {
+            console.log(chalk.gray(`    📌 No changes to checkpoint (already committed)`));
+        }
+        return true;
+    }
+    // Stage all changes
+    const addResult = spawnSync("git", ["-C", worktreePath, "add", "-A"], {
+        stdio: "pipe",
+    });
+    if (addResult.status !== 0) {
+        if (verbose) {
+            console.log(chalk.yellow(`    ⚠️  Could not stage changes for checkpoint`));
+        }
+        return false;
+    }
+    // Create checkpoint commit
+    const commitMessage = `checkpoint(#${issueNumber}): QA passed
+
+This is an automatic checkpoint commit created after issue #${issueNumber}
+passed QA in chain mode. It serves as a recovery point if later issues fail.
+
+Co-Authored-By: Sequant <noreply@sequant.dev>`;
+    const commitResult = spawnSync("git", ["-C", worktreePath, "commit", "-m", commitMessage], { stdio: "pipe" });
+    if (commitResult.status !== 0) {
+        const error = commitResult.stderr.toString();
+        if (verbose) {
+            console.log(chalk.yellow(`    ⚠️  Could not create checkpoint commit: ${error}`));
+        }
+        return false;
+    }
+    console.log(chalk.green(`    📌 Checkpoint commit created for #${issueNumber}`));
+    return true;
+}
 /**
  * Natural language prompts for each phase
  * These prompts will invoke the corresponding skills via natural language
@@ -777,6 +887,8 @@ export async function runCommand(issues, options) {
     // Determine if we should auto-detect phases from labels
     const autoDetectPhases = !options.phases && settings.run.autoDetectPhases;
     mergedOptions.autoDetectPhases = autoDetectPhases;
+    // Resolve base branch: CLI flag → settings.run.defaultBase → 'main'
+    const resolvedBaseBranch = options.base ?? settings.run.defaultBase ?? undefined;
     // Parse issue numbers (or use batch mode)
     let issueNumbers;
     let batches = null;
@@ -793,8 +905,30 @@ export async function runCommand(issues, options) {
         console.log(chalk.gray("\nUsage: npx sequant run <issues...> [options]"));
         console.log(chalk.gray("Example: npx sequant run 1 2 3 --sequential"));
         console.log(chalk.gray('Batch example: npx sequant run --batch "1 2" --batch "3"'));
+        console.log(chalk.gray("Chain example: npx sequant run 1 2 3 --sequential --chain"));
         return;
     }
+    // Validate chain mode requirements
+    if (mergedOptions.chain) {
+        if (!mergedOptions.sequential) {
+            console.log(chalk.red("❌ --chain requires --sequential flag"));
+            console.log(chalk.gray("   Chain mode executes issues sequentially, each branching from the previous."));
+            console.log(chalk.gray("   Usage: npx sequant run 1 2 3 --sequential --chain"));
+            return;
+        }
+        if (batches) {
+            console.log(chalk.red("❌ --chain cannot be used with --batch"));
+            console.log(chalk.gray("   Chain mode creates a linear dependency chain between issues."));
+            return;
+        }
+        // Warn about long chains
+        if (issueNumbers.length > 5) {
+            console.log(chalk.yellow(`  ⚠️  Warning: Chain has ${issueNumbers.length} issues (recommended max: 5)`));
+            console.log(chalk.yellow("     Long chains increase merge complexity and review difficulty."));
+            console.log(chalk.yellow("     Consider breaking into smaller chains or using batch mode."));
+            console.log("");
+        }
+    }
     // Sort issues by dependencies (if more than one issue)
     if (issueNumbers.length > 1 && !batches) {
         const originalOrder = [...issueNumbers];
@@ -839,6 +973,12 @@ export async function runCommand(issues, options) {
         });
         await logWriter.initialize(runConfig);
     }
+    // Initialize state manager for persistent workflow state tracking
+    // State tracking is always enabled (unless dry run)
+    let stateManager = null;
+    if (!config.dryRun) {
+        stateManager = new StateManager({ verbose: config.verbose });
+    }
     // Initialize shutdown manager for graceful interruption handling
     const shutdown = new ShutdownManager();
     // Register log writer finalization as cleanup task
@@ -872,12 +1012,21 @@ export async function runCommand(issues, options) {
     if (logWriter) {
         console.log(chalk.gray(`  Logging: JSON (run ${logWriter.getRunId()?.slice(0, 8)}...)`));
     }
+    if (stateManager) {
+        console.log(chalk.gray(`  State tracking: enabled`));
+    }
     console.log(chalk.gray(`  Issues: ${issueNumbers.map((n) => `#${n}`).join(", ")}`));
     // Worktree isolation is enabled by default for multi-issue runs
     const useWorktreeIsolation = mergedOptions.worktreeIsolation !== false && issueNumbers.length > 0;
     if (useWorktreeIsolation) {
         console.log(chalk.gray(`  Worktree isolation: enabled`));
     }
+    if (resolvedBaseBranch) {
+        console.log(chalk.gray(`  Base branch: ${resolvedBaseBranch}`));
+    }
+    if (mergedOptions.chain) {
+        console.log(chalk.gray(`  Chain mode: enabled (each issue branches from previous)`));
+    }
     // Fetch issue info for all issues first
     const issueInfoMap = new Map();
     for (const issueNumber of issueNumbers) {
@@ -890,7 +1039,13 @@ export async function runCommand(issues, options) {
             number: num,
             title: issueInfoMap.get(num)?.title || `Issue #${num}`,
         }));
-        worktreeMap = await ensureWorktrees(issueData, config.verbose, manifest.packageManager);
+        // Use chain mode or standard worktree creation
+        if (mergedOptions.chain) {
+            worktreeMap = await ensureWorktreesChain(issueData, config.verbose, manifest.packageManager, resolvedBaseBranch);
+        }
+        else {
+            worktreeMap = await ensureWorktrees(issueData, config.verbose, manifest.packageManager, resolvedBaseBranch);
+        }
         // Register cleanup tasks for newly created worktrees (not pre-existing ones)
         for (const [issueNum, worktree] of worktreeMap.entries()) {
             if (!worktree.existed) {
@@ -915,7 +1070,7 @@ export async function runCommand(issues, options) {
             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, issueInfoMap, worktreeMap, shutdown);
+                const batchResults = await executeBatch(batch, config, logWriter, stateManager, mergedOptions, issueInfoMap, worktreeMap, shutdown);
                 results.push(...batchResults);
                 // Check if batch failed and we should stop
                 const batchFailed = batchResults.some((r) => !r.success);
@@ -937,7 +1092,7 @@ export async function runCommand(issues, options) {
                 if (logWriter) {
                     logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
                 }
-                const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions, worktreeInfo?.path, shutdown);
+                const result = await runIssueWithLogging(issueNumber, config, logWriter, stateManager, issueInfo.title, issueInfo.labels, mergedOptions, worktreeInfo?.path, worktreeInfo?.branch, shutdown, mergedOptions.chain);
                 results.push(result);
                 // Complete issue logging
                 if (logWriter) {
@@ -948,7 +1103,8 @@ export async function runCommand(issues, options) {
                     break;
                 }
                 if (!result.success) {
-                    console.log(chalk.yellow(`\n  ⚠️  Issue #${issueNumber} failed, stopping sequential execution`));
+                    const chainInfo = mergedOptions.chain ? " (chain stopped)" : "";
+                    console.log(chalk.yellow(`\n  ⚠️  Issue #${issueNumber} failed, stopping sequential execution${chainInfo}`));
                     break;
                 }
             }
@@ -970,7 +1126,7 @@ export async function runCommand(issues, options) {
                 if (logWriter) {
                     logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
                 }
-                const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions, worktreeInfo?.path, shutdown);
+                const result = await runIssueWithLogging(issueNumber, config, logWriter, stateManager, issueInfo.title, issueInfo.labels, mergedOptions, worktreeInfo?.path, worktreeInfo?.branch, shutdown, false);
                 results.push(result);
                 // Complete issue logging
                 if (logWriter) {
@@ -1027,7 +1183,7 @@ export async function runCommand(issues, options) {
 /**
  * Execute a batch of issues
  */
-async function executeBatch(issueNumbers, config, logWriter, options, issueInfoMap, worktreeMap, shutdownManager) {
+async function executeBatch(issueNumbers, config, logWriter, stateManager, options, issueInfoMap, worktreeMap, shutdownManager) {
     const results = [];
     for (const issueNumber of issueNumbers) {
         // Check if shutdown was triggered
@@ -1043,7 +1199,7 @@ async function executeBatch(issueNumbers, config, logWriter, options, issueInfoM
         if (logWriter) {
             logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
         }
-        const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, options, worktreeInfo?.path, shutdownManager);
+        const result = await runIssueWithLogging(issueNumber, config, logWriter, stateManager, issueInfo.title, issueInfo.labels, options, worktreeInfo?.path, worktreeInfo?.branch, shutdownManager, false);
         results.push(result);
         // Complete issue logging
         if (logWriter) {
@@ -1055,7 +1211,7 @@ async function executeBatch(issueNumbers, config, logWriter, options, issueInfoM
 /**
  * Execute all phases for a single issue with logging and quality loop
  */
-async function runIssueWithLogging(issueNumber, config, logWriter, labels, options, worktreePath, shutdownManager) {
+async function runIssueWithLogging(issueNumber, config, logWriter, stateManager, issueTitle, labels, options, worktreePath, branch, shutdownManager, chainMode) {
     const startTime = Date.now();
     const phaseResults = [];
     let loopTriggered = false;
@@ -1064,6 +1220,32 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
     if (worktreePath) {
         console.log(chalk.gray(`    Worktree: ${worktreePath}`));
     }
+    // Initialize state tracking for this issue
+    if (stateManager) {
+        try {
+            const existingState = await stateManager.getIssueState(issueNumber);
+            if (!existingState) {
+                await stateManager.initializeIssue(issueNumber, issueTitle, {
+                    worktree: worktreePath,
+                    branch,
+                    qualityLoop: config.qualityLoop,
+                    maxIterations: config.maxIterations,
+                });
+            }
+            else {
+                // Update worktree info if it changed
+                if (worktreePath && branch) {
+                    await stateManager.updateWorktreeInfo(issueNumber, worktreePath, branch);
+                }
+            }
+        }
+        catch (error) {
+            // State tracking errors shouldn't stop execution
+            if (config.verbose) {
+                console.log(chalk.yellow(`    ⚠️  State tracking error: ${error}`));
+            }
+        }
+    }
     // Determine phases for this specific issue
     let phases;
     let detectedQualityLoop = false;
@@ -1081,6 +1263,15 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
             // Run spec first to get recommended workflow
             console.log(chalk.gray(`    Running spec to determine workflow...`));
             console.log(chalk.gray(`    ⏳ spec...`));
+            // Track spec phase start in state
+            if (stateManager) {
+                try {
+                    await stateManager.updatePhaseStatus(issueNumber, "spec", "in_progress");
+                }
+                catch {
+                    // State tracking errors shouldn't stop execution
+                }
+            }
             const specStartTime = new Date();
             // Note: spec runs in main repo (not worktree) for planning
             const specResult = await executePhase(issueNumber, "spec", config, sessionId, worktreePath, // Will be ignored for spec (non-isolated phase)
@@ -1088,6 +1279,15 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
             const specEndTime = new Date();
             if (specResult.sessionId) {
                 sessionId = specResult.sessionId;
+                // Update session ID in state for resume capability
+                if (stateManager) {
+                    try {
+                        await stateManager.updateSessionId(issueNumber, specResult.sessionId);
+                    }
+                    catch {
+                        // State tracking errors shouldn't stop execution
+                    }
+                }
             }
             phaseResults.push(specResult);
             specAlreadyRan = true;
@@ -1100,6 +1300,18 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
                         : "failure", { error: specResult.error });
                 logWriter.logPhase(phaseLog);
             }
+            // Track spec phase completion in state
+            if (stateManager) {
+                try {
+                    const phaseStatus = specResult.success ? "completed" : "failed";
+                    await stateManager.updatePhaseStatus(issueNumber, "spec", phaseStatus, {
+                        error: specResult.error,
+                    });
+                }
+                catch {
+                    // State tracking errors shouldn't stop execution
+                }
+            }
             if (!specResult.success) {
                 console.log(chalk.red(`    ✗ spec: ${specResult.error}`));
                 const durationSeconds = (Date.now() - startTime) / 1000;
@@ -1170,12 +1382,30 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
         let phasesFailed = false;
         for (const phase of phases) {
             console.log(chalk.gray(`    ⏳ ${phase}...`));
+            // Track phase start in state
+            if (stateManager) {
+                try {
+                    await stateManager.updatePhaseStatus(issueNumber, phase, "in_progress");
+                }
+                catch {
+                    // State tracking errors shouldn't stop execution
+                }
+            }
             const phaseStartTime = new Date();
             const result = await executePhase(issueNumber, phase, config, sessionId, worktreePath, shutdownManager);
             const phaseEndTime = new Date();
             // Capture session ID for subsequent phases
             if (result.sessionId) {
                 sessionId = result.sessionId;
+                // Update session ID in state for resume capability
+                if (stateManager) {
+                    try {
+                        await stateManager.updateSessionId(issueNumber, result.sessionId);
+                    }
+                    catch {
+                        // State tracking errors shouldn't stop execution
+                    }
+                }
             }
             phaseResults.push(result);
             // Log phase result
@@ -1187,6 +1417,20 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
                         : "failure", { error: result.error });
                 logWriter.logPhase(phaseLog);
             }
+            // Track phase completion in state
+            if (stateManager) {
+                try {
+                    const phaseStatus = result.success
+                        ? "completed"
+                        : result.error?.includes("Timeout")
+                            ? "failed"
+                            : "failed";
+                    await stateManager.updatePhaseStatus(issueNumber, phase, phaseStatus, { error: result.error });
+                }
+                catch {
+                    // State tracking errors shouldn't stop execution
+                }
+            }
             if (result.success) {
                 const duration = result.durationSeconds
                     ? ` (${formatDuration(result.durationSeconds)})`
@@ -1231,6 +1475,20 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
     // Success is determined by whether all phases completed in any iteration,
     // not whether all accumulated phase results passed (which would fail after loop recovery)
     const success = completedSuccessfully;
+    // Update final issue status in state
+    if (stateManager) {
+        try {
+            const finalStatus = success ? "ready_for_merge" : "in_progress";
+            await stateManager.updateIssueStatus(issueNumber, finalStatus);
+        }
+        catch {
+            // State tracking errors shouldn't stop execution
+        }
+    }
+    // Create checkpoint commit in chain mode after QA passes
+    if (success && chainMode && worktreePath) {
+        createCheckpointCommit(worktreePath, issueNumber, config.verbose);
+    }
     return {
         issueNumber,
         success,

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

@@ -1,4 +1,20 @@
 /**
- * sequant status - Show version and configuration
+ * sequant status - Show version, configuration, and workflow state
  */
-export declare function statusCommand(): Promise<void>;
+export interface StatusCommandOptions {
+    /** Show only issues state */
+    issues?: boolean;
+    /** Show details for a specific issue */
+    issue?: number;
+    /** Output as JSON */
+    json?: boolean;
+    /** Rebuild state from run logs */
+    rebuild?: boolean;
+    /** Clean up stale/orphaned entries */
+    cleanup?: boolean;
+    /** Only show what would be cleaned (used with --cleanup) */
+    dryRun?: boolean;
+    /** Remove entries older than this many days (used with --cleanup) */
+    maxAge?: number;
+}
+export declare function statusCommand(options?: StatusCommandOptions): Promise<void>;