sequant 2.7.0 → 2.9.0

package/dist/src/lib/workflow/worktree-manager.d.ts

@@ -43,6 +43,19 @@ export interface RebaseResult {
     /** Error message if rebase failed */
     error?: string;
 }
+/**
+ * Result of rebasing a worktree onto a local branch (chain successor → predecessor).
+ */
+export interface LocalRebaseResult {
+    /** Whether the rebase was attempted */
+    performed: boolean;
+    /** Whether the rebase succeeded (branch now contains `ontoBranch`'s commits) */
+    success: boolean;
+    /** Whether a merge conflict caused the rebase to be aborted */
+    conflict: boolean;
+    /** Error message if the rebase failed */
+    error?: string;
+}
 /**
  * Result of PR creation
  */
@@ -176,6 +189,17 @@ export declare function createCheckpointCommit(worktreePath: string, issueNumber
  * @internal Exported for testing
  */
 export declare function reinstallIfLockfileChanged(worktreePath: string, packageManager: string | undefined, verbose: boolean, preRebaseRef?: string): boolean;
+/**
+ * Rebase a worktree's branch onto a *local* branch ref (e.g. a chain
+ * predecessor's feature branch), NOT origin/main. Used to chain a successor
+ * onto its predecessor's committed work at execution time (#748), and to
+ * re-chain a pre-existing worktree onto its chain base.
+ *
+ * On conflict, aborts the rebase to restore the original branch state and
+ * returns `{ success: false, conflict: true }` so callers can warn rather than
+ * silently treat a broken link as healthy.
+ */
+export declare function rebaseOntoLocalBranch(worktreePath: string, ontoBranch: string, verbose?: boolean): LocalRebaseResult;
 /**
  * Rebase the worktree branch onto the base branch before PR creation.
  * This ensures the branch is up-to-date and prevents lockfile drift.
@@ -189,6 +213,24 @@ export declare function reinstallIfLockfileChanged(worktreePath: string, package
  * @internal Exported for testing
  */
 export declare function rebaseBeforePR(worktreePath: string, issueNumber: number, packageManager: string | undefined, verbose: boolean, baseBranch?: string): RebaseResult;
+/**
+ * Build the automated PR body for `sequant run`.
+ *
+ * Pure and I/O-free, kept separate from {@link createPR} (which shells out to
+ * `gh`) so the body — including the non-A+ QA note (#749) — is unit-testable
+ * directly.
+ *
+ * @param issueNumber Issue the PR closes
+ * @param opts.stackManifest Appended before the trailer under --stacked (#605)
+ * @param opts.qaVerdict QA verdict for the run; a non-A+ stopping state
+ *   (anything other than `READY_FOR_MERGE`) surfaces a note so a human reviewer
+ *   sees why the run broke to PR without reaching A+ (#749).
+ * @internal Exported for testing
+ */
+export declare function buildAutomatedPRBody(issueNumber: number, opts?: {
+    stackManifest?: string;
+    qaVerdict?: string;
+}): string;
 /**
  * Push branch and create a PR after successful QA.
  *
@@ -210,4 +252,4 @@ export declare function rebaseBeforePR(worktreePath: string, issueNumber: number
 export declare function createPR(worktreePath: string, issueNumber: number, issueTitle: string, branch: string, verbose: boolean, labels?: string[], stackOptions?: {
     prBase?: string;
     stackManifest?: string;
-}): PRCreationResult;
+}, qaVerdict?: string): PRCreationResult;

package/dist/src/lib/workflow/worktree-manager.js

@@ -365,21 +365,14 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
             if (verbose) {
                 console.log(chalk.gray(`    Rebasing existing worktree onto chain base (${baseBranch})...`));
             }
-            const rebaseResult = spawnSync("git", ["-C", existingPath, "rebase", baseBranch], { stdio: "pipe" });
-            if (rebaseResult.status !== 0) {
-                const rebaseError = rebaseResult.stderr.toString();
-                // Check if it's a conflict
-                if (rebaseError.includes("CONFLICT") ||
-                    rebaseError.includes("could not apply")) {
+            const rebase = rebaseOntoLocalBranch(existingPath, baseBranch, verbose);
+            if (!rebase.success) {
+                if (rebase.conflict) {
                     console.log(chalk.yellow(`    !  Rebase conflict detected. Aborting rebase and keeping original branch state.`));
                     console.log(chalk.yellow(`    ℹ️  Branch ${branch} is not properly chained. Manual rebase may be required.`));
-                    // Abort the rebase to restore branch state
-                    spawnSync("git", ["-C", existingPath, "rebase", "--abort"], {
-                        stdio: "pipe",
-                    });
                 }
                 else {
-                    console.log(chalk.yellow(`    !  Rebase failed: ${rebaseError.trim()}`));
+                    console.log(chalk.yellow(`    !  Rebase failed: ${rebase.error ?? ""}`));
                     console.log(chalk.yellow(`    ℹ️  Continuing with branch in its original state.`));
                 }
                 return {
@@ -390,9 +383,6 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
                     rebased: false,
                 };
             }
-            if (verbose) {
-                console.log(chalk.green(`    ✔ Existing worktree rebased onto ${baseBranch}`));
-            }
             return {
                 issue: issueNumber,
                 path: existingPath,
@@ -700,9 +690,10 @@ passed QA in chain mode. It serves as a recovery point if later issues fail.`;
     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}`));
-        }
+        // #760: chain resume rebases the next link onto this checkpoint, so a
+        // commit failure is surfaced regardless of --verbose (the call site adds
+        // the resume-impact warning; here we show the underlying git error).
+        console.log(chalk.yellow(`    !  Could not create checkpoint commit for #${issueNumber}: ${error.trim()}`));
         return false;
     }
     console.log(chalk.green(`    📌 Checkpoint commit created for #${issueNumber}`));
@@ -766,6 +757,39 @@ export function reinstallIfLockfileChanged(worktreePath, packageManager, verbose
     console.log(chalk.green(`    ✔ Dependencies reinstalled`));
     return true;
 }
+/**
+ * Rebase a worktree's branch onto a *local* branch ref (e.g. a chain
+ * predecessor's feature branch), NOT origin/main. Used to chain a successor
+ * onto its predecessor's committed work at execution time (#748), and to
+ * re-chain a pre-existing worktree onto its chain base.
+ *
+ * On conflict, aborts the rebase to restore the original branch state and
+ * returns `{ success: false, conflict: true }` so callers can warn rather than
+ * silently treat a broken link as healthy.
+ */
+export function rebaseOntoLocalBranch(worktreePath, ontoBranch, verbose = false) {
+    const rebaseResult = spawnSync("git", ["-C", worktreePath, "rebase", ontoBranch], { stdio: "pipe" });
+    if (rebaseResult.status === 0) {
+        if (verbose) {
+            console.log(chalk.green(`    ✔ Rebased worktree onto ${ontoBranch}`));
+        }
+        return { performed: true, success: true, conflict: false };
+    }
+    const rebaseError = rebaseResult.stderr.toString();
+    const isConflict = rebaseError.includes("CONFLICT") || rebaseError.includes("could not apply");
+    if (isConflict) {
+        // Abort to restore the original branch state.
+        spawnSync("git", ["-C", worktreePath, "rebase", "--abort"], {
+            stdio: "pipe",
+        });
+    }
+    return {
+        performed: true,
+        success: false,
+        conflict: isConflict,
+        error: rebaseError.trim(),
+    };
+}
 /**
  * Rebase the worktree branch onto the base branch before PR creation.
  * This ensures the branch is up-to-date and prevents lockfile drift.
@@ -832,6 +856,63 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
         reinstalled,
     };
 }
+/**
+ * Render a non-A+ QA verdict as a PR-body note, or `null` for an A+ / absent
+ * verdict.
+ *
+ * Only stopping states that still break to a PR reach this path
+ * (`AC_MET_BUT_NOT_A_PLUS`, `NEEDS_VERIFICATION`); `READY_FOR_MERGE` and an
+ * absent verdict produce no note. (#749)
+ */
+function qaVerdictNote(verdict) {
+    if (!verdict || verdict === "READY_FOR_MERGE")
+        return null;
+    switch (verdict) {
+        case "AC_MET_BUT_NOT_A_PLUS":
+            return `> **QA verdict: AC_MET_BUT_NOT_A_PLUS** — acceptance criteria met, but not A+. The run broke to this PR for review rather than entering the quality loop; see the QA review comment for improvement notes.`;
+        case "NEEDS_VERIFICATION":
+            return `> **QA verdict: NEEDS_VERIFICATION** — acceptance criteria met, pending external verification (e.g. CI or a manual test). See the QA review comment.`;
+        default:
+            return `> **QA verdict: ${verdict}** — see the QA review comment.`;
+    }
+}
+/**
+ * Build the automated PR body for `sequant run`.
+ *
+ * Pure and I/O-free, kept separate from {@link createPR} (which shells out to
+ * `gh`) so the body — including the non-A+ QA note (#749) — is unit-testable
+ * directly.
+ *
+ * @param issueNumber Issue the PR closes
+ * @param opts.stackManifest Appended before the trailer under --stacked (#605)
+ * @param opts.qaVerdict QA verdict for the run; a non-A+ stopping state
+ *   (anything other than `READY_FOR_MERGE`) surfaces a note so a human reviewer
+ *   sees why the run broke to PR without reaching A+ (#749).
+ * @internal Exported for testing
+ */
+export function buildAutomatedPRBody(issueNumber, opts) {
+    const bodyLines = [
+        `## Summary`,
+        ``,
+        `Automated PR for issue #${issueNumber}.`,
+        ``,
+        `Fixes #${issueNumber}`,
+        ``,
+    ];
+    // #749: surface a non-A+ QA verdict in the PR body (not just the run log) so
+    // a reviewer sees why the run broke to PR rather than reaching A+.
+    const note = qaVerdictNote(opts?.qaVerdict);
+    if (note) {
+        bodyLines.push(note, ``);
+    }
+    // #605 AC-4: emit stack manifest before the trailer so reviewers see the
+    // chain at the top of the body. Manifest is only set under --stacked.
+    if (opts?.stackManifest) {
+        bodyLines.push(opts.stackManifest, ``);
+    }
+    bodyLines.push(`---`, `🤖 Generated by \`sequant run\``);
+    return bodyLines.join("\n");
+}
 /**
  * Push branch and create a PR after successful QA.
  *
@@ -850,7 +931,7 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
  * @returns PRCreationResult with PR info or error
  * @internal Exported for testing
  */
-export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose, labels, stackOptions) {
+export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose, labels, stackOptions, qaVerdict) {
     const github = new GitHubProvider();
     // Step 1: Check for existing PR on this branch
     const existingPRInfo = github.viewPRByBranchSync(branch, worktreePath);
@@ -886,21 +967,10 @@ export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose,
     const isBug = labels?.some((l) => /^bug/i.test(l));
     const prefix = isBug ? "fix" : "feat";
     const prTitle = `${prefix}(#${issueNumber}): ${issueTitle}`;
-    const bodyLines = [
-        `## Summary`,
-        ``,
-        `Automated PR for issue #${issueNumber}.`,
-        ``,
-        `Fixes #${issueNumber}`,
-        ``,
-    ];
-    // #605 AC-4: emit stack manifest before the trailer so reviewers see the
-    // chain at the top of the body. Manifest is only set under --stacked.
-    if (stackOptions?.stackManifest) {
-        bodyLines.push(stackOptions.stackManifest, ``);
-    }
-    bodyLines.push(`---`, `🤖 Generated by \`sequant run\``);
-    const prBody = bodyLines.join("\n");
+    const prBody = buildAutomatedPRBody(issueNumber, {
+        stackManifest: stackOptions?.stackManifest,
+        qaVerdict,
+    });
     const prResult = github.createPRCliSync(prTitle, prBody, branch, worktreePath, stackOptions?.prBase);
     if (prResult.exitCode !== 0) {
         const prError = prResult.stderr.trim() || "Unknown error";

package/dist/src/mcp/tools/run.d.ts

@@ -32,6 +32,8 @@ interface RunToolResponse {
         total: number;
         passed: number;
         failed: number;
+        /** Issues that ended `partial` — timed out, no failure, no recovery (#766). */
+        partial: number;
         durationSeconds: number;
     };
     phases: string;

package/dist/src/mcp/tools/run.js

@@ -182,6 +182,7 @@ export function buildStructuredResponse(runLog, rawOutput, overallStatus, exitCo
             total: runLog.summary.totalIssues,
             passed: runLog.summary.passed,
             failed: runLog.summary.failed,
+            partial: runLog.summary.partial ?? 0,
             durationSeconds: runLog.summary.totalDurationSeconds,
         },
         phases: phasesRan || runLog.config.phases.join(","),
@@ -232,6 +233,7 @@ function buildFallbackResponse(stdout, issueNumbers, overallStatus, phases, exit
             total: issueNumbers.length,
             passed: overallStatus === "success" ? issueNumbers.length : 0,
             failed: overallStatus === "failure" ? issueNumbers.length : 0,
+            partial: 0,
             durationSeconds: 0,
         },
         phases,

package/dist/src/ui/tui/theme.d.ts

@@ -12,8 +12,10 @@ import type { IssueStatus, PhaseStatus } from "../../lib/workflow/run-state.js";
  *   - `BRAND_GREEN` is the accent/success green (`--color-accent`).
  *
  * Used to brand the two color signals that matter most at a glance — the
- * live/active phase and success — while issue-distinction (border rotation),
- * failure (red), and dividers (gray) stay on robust named ANSI colors.
+ * live/active phase and success — while issue-distinction (border rotation)
+ * and failure (red) stay on robust named ANSI colors. The muted gray for
+ * secondary chrome is a fixed mid-gray (`DIVIDER_COLOR`) chosen for WCAG
+ * contrast rather than the too-dim ANSI bright-black.
  *
  * Ink/chalk auto-downsamples hex to the nearest ANSI color on terminals
  * without truecolor, and `NO_COLOR` still strips all color, so these degrade
@@ -24,8 +26,20 @@ export declare const BRAND_GREEN: "#10b981";
 /** Border-color palette rotated by issue start order. */
 export declare const BORDER_ROTATION: readonly ["cyan", "magenta", "blue", "yellow"];
 export type BorderColor = (typeof BORDER_ROTATION)[number] | typeof BRAND_GREEN | typeof BRAND_ORANGE | "red" | "gray";
-/** Gray used for horizontal dividers inside each box. */
-export declare const DIVIDER_COLOR: "gray";
+/**
+ * Muted gray for secondary chrome: dividers, field labels (`branch`/`now`/
+ * `log`), the `phase N/total` + elapsed line, the `last activity` stamp, and
+ * the terminal status line.
+ *
+ * Lifted off ANSI `"gray"` (bright-black), which the brand's own dark theme
+ * renders at ~2.4:1 — below WCAG AA (4.5) and even the 3.0 large-text/UI floor.
+ * This fixed mid-gray clears AA (~4.9:1) on the dark theme while staying above
+ * 3.0 on light terminals (~3.4:1). It still degrades gracefully: chalk
+ * downsamples the hex to the nearest ANSI color on non-truecolor terminals, and
+ * `NO_COLOR` strips it entirely. The not-yet-started phase glyph stays on ANSI
+ * `"gray"` (see `phaseStatusColor`) so pending work remains the most recessed.
+ */
+export declare const DIVIDER_COLOR: "#8B8B9A";
 /** Brand orange for the live/active phase spinner — the one element the eye
  *  tracks. Border rotation still distinguishes concurrent issues. */
 export declare const ACTIVE_PHASE_COLOR: "#FF8012";

package/dist/src/ui/tui/theme.js

@@ -11,8 +11,10 @@
  *   - `BRAND_GREEN` is the accent/success green (`--color-accent`).
  *
  * Used to brand the two color signals that matter most at a glance — the
- * live/active phase and success — while issue-distinction (border rotation),
- * failure (red), and dividers (gray) stay on robust named ANSI colors.
+ * live/active phase and success — while issue-distinction (border rotation)
+ * and failure (red) stay on robust named ANSI colors. The muted gray for
+ * secondary chrome is a fixed mid-gray (`DIVIDER_COLOR`) chosen for WCAG
+ * contrast rather than the too-dim ANSI bright-black.
  *
  * Ink/chalk auto-downsamples hex to the nearest ANSI color on terminals
  * without truecolor, and `NO_COLOR` still strips all color, so these degrade
@@ -22,8 +24,20 @@ export const BRAND_ORANGE = "#FF8012";
 export const BRAND_GREEN = "#10b981";
 /** Border-color palette rotated by issue start order. */
 export const BORDER_ROTATION = ["cyan", "magenta", "blue", "yellow"];
-/** Gray used for horizontal dividers inside each box. */
-export const DIVIDER_COLOR = "gray";
+/**
+ * Muted gray for secondary chrome: dividers, field labels (`branch`/`now`/
+ * `log`), the `phase N/total` + elapsed line, the `last activity` stamp, and
+ * the terminal status line.
+ *
+ * Lifted off ANSI `"gray"` (bright-black), which the brand's own dark theme
+ * renders at ~2.4:1 — below WCAG AA (4.5) and even the 3.0 large-text/UI floor.
+ * This fixed mid-gray clears AA (~4.9:1) on the dark theme while staying above
+ * 3.0 on light terminals (~3.4:1). It still degrades gracefully: chalk
+ * downsamples the hex to the nearest ANSI color on non-truecolor terminals, and
+ * `NO_COLOR` strips it entirely. The not-yet-started phase glyph stays on ANSI
+ * `"gray"` (see `phaseStatusColor`) so pending work remains the most recessed.
+ */
+export const DIVIDER_COLOR = "#8B8B9A";
 /** Brand orange for the live/active phase spinner — the one element the eye
  *  tracks. Border rotation still distinguishes concurrent issues. */
 export const ACTIVE_PHASE_COLOR = BRAND_ORANGE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sequant",
-  "version": "2.7.0",
+  "version": "2.9.0",
   "description": "AI coding agent orchestrator — resolve GitHub issues end-to-end with isolated git worktrees, quality gates, and an MCP server. Works with Claude Code or Aider.",
   "type": "module",
   "bin": {
@@ -25,10 +25,11 @@
     "dev": "tsx bin/cli.ts",
     "test": "vitest run",
     "lint": "eslint src/ bin/ --max-warnings 0",
-    "sync:skills": "cp -r templates/skills/* .claude/skills/",
+    "sync:skills": "npx tsx scripts/check-skill-sync.ts --fix",
     "sync:hooks": "bash scripts/sync-hooks.sh",
-    "validate:skills": "for skill in templates/skills/*/; do npx skills-ref validate \"$skill\"; done",
+    "validate:skills": "for skill in templates/skills/*/; do case \"$skill\" in *_shared*|*/references/*) continue;; esac; npx skills-ref validate \"$skill\"; done",
     "lint:skill-calls": "npx tsx scripts/lint-skill-calls.ts",
+    "lint:skill-sync": "npx tsx scripts/check-skill-sync.ts",
     "prepare:marketplace": "npx tsx scripts/prepare-marketplace.ts",
     "validate:marketplace": "npx tsx scripts/prepare-marketplace.ts --validate-only",
     "prepublishOnly": "npm run build"
@@ -96,7 +97,6 @@
     "cli-table3": "^0.6.5",
     "commander": "^14.0.3",
     "diff": "^9.0.0",
-    "gradient-string": "^3.0.0",
     "hono": "^4.12.1",
     "ink": "^7.0.1",
     "inquirer": "^14.0.1",
@@ -111,9 +111,8 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/gradient-string": "^1.1.6",
     "@types/inquirer": "^9.0.7",
-    "@types/node": "^25.4.0",
+    "@types/node": "^26.0.1",
     "@types/react": "^19.2.14",
     "@typescript-eslint/eslint-plugin": "^8.58.0",
     "@typescript-eslint/parser": "^8.58.0",

package/templates/hooks/post-tool.sh

@@ -51,13 +51,28 @@ fi
 
 _TMPDIR="${TMPDIR:-/tmp}"
 
-# Use CLAUDE_PLUGIN_DATA for persistent logs (survives plugin updates)
-if [[ -n "${CLAUDE_PLUGIN_DATA}" ]]; then
+# Log sink (#763 AC-5c: blocked-command history must survive to be a useful
+# regression corpus, so $TMPDIR — which macOS purges — is a last resort only).
+#
+# This block MUST stay identical to the one in pre-tool.sh. The two hooks
+# write the *same* claude-timing.log (START there, END here) and the same
+# claude-quality.log, so any divergence silently splits every START/END pair
+# across two files.
+#
+# Every candidate is absolute and lives outside the repo. A repo-local or
+# relative path is wrong three times over: it resolves against the hook's cwd
+# (which Claude Code does not pin), it yields one sink per directory instead
+# of the single corpus AC-5 asks for, and — worst — creating it inside a repo
+# makes `git status --porcelain` non-empty, which silently defeats pre-tool.sh's
+# no-changes guard that reads exactly that output.
+if [[ -n "${CLAUDE_PLUGIN_DATA:-}" ]]; then
   _LOG_DIR="${CLAUDE_PLUGIN_DATA}/logs"
-  mkdir -p "$_LOG_DIR"
+elif [[ -n "${HOME:-}" ]]; then
+  _LOG_DIR="${HOME}/.sequant/logs"
 else
   _LOG_DIR="${_TMPDIR}"
 fi
+mkdir -p "$_LOG_DIR" 2>/dev/null || _LOG_DIR="${_TMPDIR}"
 
 TIMING_LOG="${_LOG_DIR}/claude-timing.log"
 QUALITY_LOG="${_LOG_DIR}/claude-quality.log"