sequant 2.8.0 → 2.9.0

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sequant",
-  "version": "2.8.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": {
@@ -97,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",
@@ -112,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"