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

package/dist/bin/cli.js

@@ -139,7 +139,11 @@ program
     .option("--qa-gate", "Wait for QA pass before starting next issue in chain (requires --chain)")
     .option("--base <branch>", "Base branch for worktree creation (default: main or settings.run.defaultBase)")
     .option("--no-mcp", "Disable MCP server injection in headless mode")
+    .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
     .command("logs")

package/dist/src/commands/logs.js

@@ -112,6 +112,21 @@ function displayLogSummary(log, filename) {
             const phaseDuration = chalk.gray(`(${formatDuration(phase.durationSeconds)})`);
             const error = phase.error ? chalk.red(` - ${phase.error}`) : "";
             console.log(`      ${phaseStatus} ${phase.phase} ${phaseDuration}${error}`);
+            // Show observability data (AC-9)
+            if (phase.commitHash) {
+                console.log(chalk.gray(`        commit: ${phase.commitHash.slice(0, 8)}`));
+            }
+            if (phase.filesModified && phase.filesModified.length > 0) {
+                console.log(chalk.gray(`        files: ${phase.filesModified.length} modified`));
+            }
+            if (phase.fileDiffStats && phase.fileDiffStats.length > 0) {
+                const totalAdditions = phase.fileDiffStats.reduce((sum, f) => sum + f.additions, 0);
+                const totalDeletions = phase.fileDiffStats.reduce((sum, f) => sum + f.deletions, 0);
+                console.log(chalk.gray(`        diff: +${totalAdditions}/-${totalDeletions} lines`));
+            }
+            if (phase.cacheMetrics) {
+                console.log(chalk.gray(`        cache: ${phase.cacheMetrics.hits} hits, ${phase.cacheMetrics.misses} misses, ${phase.cacheMetrics.skipped} skipped`));
+            }
         }
     }
 }

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

@@ -4,7 +4,9 @@
  * Runs the Sequant workflow (/spec → /exec → /qa) for one or more issues
  * using the Claude Agent SDK for proper skill invocation.
  */
-import { Phase, QaVerdict } from "../lib/workflow/types.js";
+import { Phase, ExecutionConfig, PhaseResult, QaVerdict } from "../lib/workflow/types.js";
+import { ShutdownManager } from "../lib/shutdown.js";
+import { PhaseSpinner } from "../lib/phase-spinner.js";
 /**
  * Parse QA verdict from phase output
  *
@@ -17,6 +19,36 @@ import { Phase, QaVerdict } from "../lib/workflow/types.js";
  * @returns The parsed verdict or null if not found
  */
 export declare function parseQaVerdict(output: string): QaVerdict | null;
+/**
+ * Result of worktree freshness check
+ */
+interface WorktreeFreshnessResult {
+    /** True if worktree is stale (significantly behind main) */
+    isStale: boolean;
+    /** Number of commits behind origin/main */
+    commitsBehind: number;
+    /** True if worktree has uncommitted changes */
+    hasUncommittedChanges: boolean;
+    /** True if worktree has unpushed commits */
+    hasUnpushedCommits: boolean;
+}
+/**
+ * Check if a worktree is stale (behind origin/main) and should be recreated
+ *
+ * @param worktreePath - Path to the worktree
+ * @param verbose - Enable verbose output
+ * @returns Freshness check result
+ */
+export declare function checkWorktreeFreshness(worktreePath: string, verbose: boolean): WorktreeFreshnessResult;
+/**
+ * Remove and recreate a stale worktree
+ *
+ * @param existingPath - Path to existing worktree
+ * @param branch - Branch name
+ * @param verbose - Enable verbose output
+ * @returns true if worktree was removed
+ */
+export declare function removeStaleWorktree(existingPath: string, branch: string, verbose: boolean): boolean;
 /**
  * List all active worktrees with their branches
  */
@@ -59,6 +91,75 @@ export declare function filterResumedPhases(issueNumber: number, phases: Phase[]
  * @internal Exported for testing
  */
 export declare function createCheckpointCommit(worktreePath: string, issueNumber: number, verbose: boolean): boolean;
+/**
+ * Check if any lockfile changed during a rebase and re-run install if needed.
+ * This prevents dependency drift when the lockfile was updated on main.
+ * @param worktreePath Path to the worktree
+ * @param packageManager Package manager to use for install
+ * @param verbose Whether to show verbose output
+ * @param preRebaseRef Git ref pointing to pre-rebase HEAD (defaults to ORIG_HEAD,
+ *        which git sets automatically after rebase). Using ORIG_HEAD captures all
+ *        lockfile changes across multi-commit rebases, unlike HEAD~1 which only
+ *        checks the last commit.
+ * @returns true if reinstall was performed, false otherwise
+ * @internal Exported for testing
+ */
+export declare function reinstallIfLockfileChanged(worktreePath: string, packageManager: string | undefined, verbose: boolean, preRebaseRef?: string): boolean;
+/**
+ * Result of a pre-PR rebase operation
+ */
+export interface RebaseResult {
+    /** Whether the rebase was performed */
+    performed: boolean;
+    /** Whether the rebase succeeded */
+    success: boolean;
+    /** Whether dependencies were reinstalled */
+    reinstalled: boolean;
+    /** Error message if rebase failed */
+    error?: string;
+}
+/**
+ * Rebase the worktree branch onto origin/main before PR creation.
+ * This ensures the branch is up-to-date and prevents lockfile drift.
+ *
+ * @param worktreePath Path to the worktree
+ * @param issueNumber Issue number (for logging)
+ * @param packageManager Package manager to use if reinstall needed
+ * @param verbose Whether to show verbose output
+ * @returns RebaseResult indicating success/failure and whether reinstall was performed
+ * @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)
  */
@@ -124,7 +225,55 @@ interface RunOptions {
      * Reads phase markers from GitHub issue comments and skips completed phases.
      */
     resume?: boolean;
+    /**
+     * Disable automatic retry with MCP fallback.
+     * When true, no retry attempts are made on phase failure.
+     * Useful for debugging to see the actual failure without retry masking it.
+     */
+    noRetry?: boolean;
+    /**
+     * Skip pre-PR rebase onto origin/main.
+     * When true, branches are not rebased before creating the PR.
+     * 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.
+     */
+    force?: boolean;
 }
+/**
+ * Execute a single phase for an issue using Claude Agent SDK
+ */
+declare function executePhase(issueNumber: number, phase: Phase, config: ExecutionConfig, sessionId?: string, worktreePath?: string, shutdownManager?: ShutdownManager, spinner?: PhaseSpinner): Promise<PhaseResult & {
+    sessionId?: string;
+}>;
+/**
+ * Execute a phase with automatic retry for cold-start failures and MCP fallback.
+ *
+ * Retry strategy:
+ * 1. If phase fails within COLD_START_THRESHOLD_SECONDS, retry up to COLD_START_MAX_RETRIES times
+ * 2. If still failing and MCP is enabled, retry once with MCP disabled (npx-based MCP servers
+ *    can fail on first run due to cold-cache issues)
+ *
+ * The MCP fallback is safe because MCP servers are optional enhancements, not required
+ * for core functionality.
+ */
+/**
+ * @internal Exported for testing only
+ */
+export declare function executePhaseWithRetry(issueNumber: number, phase: Phase, config: ExecutionConfig, sessionId?: string, worktreePath?: string, shutdownManager?: ShutdownManager, spinner?: PhaseSpinner, 
+/** @internal Injected for testing — defaults to module-level executePhase */
+executePhaseFn?: typeof executePhase): Promise<PhaseResult & {
+    sessionId?: string;
+}>;
 /**
  * Main run command
  */