sequant 2.9.0 → 2.10.0

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

@@ -8,7 +8,8 @@ import chalk from "chalk";
 import { spawnSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import path from "path";
-import { PM_CONFIG } from "../stacks.js";
+import { resolvePackageManager, resolvePackageManagerConfig, } from "../stacks.js";
+import { resolveDiffBase } from "./git-diff-utils.js";
 import { getResumablePhasesForIssue } from "./phase-detection.js";
 import { GitHubProvider } from "./platforms/github.js";
 /**
@@ -155,7 +156,11 @@ export function checkWorktreeFreshness(worktreePath, verbose, baseBranch = "main
         const countResult = spawnSync("git", ["-C", worktreePath, "rev-list", "--count", `${mergeBase}..${baseHead}`], { stdio: "pipe" });
         if (countResult.status === 0) {
             result.commitsBehind = parseInt(countResult.stdout.toString().trim(), 10);
-            // Consider stale if more than 5 commits behind (configurable threshold)
+            // Consider stale if more than 5 commits behind. NOT configurable — the
+            // threshold is the literal below, and a stale-but-clean worktree is
+            // force-removed and rebuilt on the strength of it (see the recreate
+            // branch in `ensureWorktree`). Surfaced in #810; left as a literal here
+            // because making it configurable is a behavior change, not a comment fix.
             result.isStale = result.commitsBehind > 5;
         }
     }
@@ -231,7 +236,8 @@ export function listWorktrees() {
  * Get changed files in a worktree compared to main
  */
 export function getWorktreeChangedFiles(worktreePath) {
-    const result = spawnSync("git", ["-C", worktreePath, "diff", "--name-only", "main...HEAD"], { stdio: "pipe" });
+    const diffBase = resolveDiffBase(worktreePath, "main");
+    const result = spawnSync("git", ["-C", worktreePath, "diff", "--name-only", `${diffBase}...HEAD`], { stdio: "pipe" });
     if (result.status !== 0)
         return [];
     return result.stdout
@@ -245,7 +251,8 @@ export function getWorktreeChangedFiles(worktreePath) {
  * Returns aggregate metrics only - no file paths to preserve privacy
  */
 export function getWorktreeDiffStats(worktreePath) {
-    const result = spawnSync("git", ["-C", worktreePath, "diff", "--stat", "main...HEAD"], { stdio: "pipe" });
+    const diffBase = resolveDiffBase(worktreePath, "main");
+    const result = spawnSync("git", ["-C", worktreePath, "diff", "--stat", `${diffBase}...HEAD`], { stdio: "pipe" });
     if (result.status !== 0) {
         return { filesChanged: 0, linesAdded: 0 };
     }
@@ -314,6 +321,63 @@ export function filterResumedPhases(issueNumber, phases, resume) {
     const skipped = phases.filter((p) => !resumable.includes(p));
     return { phases: resumable, skipped };
 }
+/**
+ * Run the frozen dependency install for a freshly provisioned worktree and
+ * surface (rather than swallow) a failed install.
+ *
+ * Mirrors the status check in `reinstallIfLockfileChanged` (#846): a plain
+ * `npm install` self-heals a stale/absent lockfile, but the frozen `npm ci`
+ * hard-fails (exit 1, no node_modules). Without this check a failing install
+ * left a silently dependency-less worktree whose breakage only surfaced later
+ * as a confusing phase error. The warning names the resolved command so the
+ * user can rerun it by hand.
+ *
+ * @returns true if the install succeeded, false if it failed (warn-and-continue)
+ * @internal Exported for testing
+ */
+export function installWorktreeDeps(worktreePath, packageManager, verbose) {
+    if (verbose) {
+        console.log(chalk.gray(`    Installing dependencies...`));
+    }
+    // Two independent questions, resolved in order against the worktree itself.
+    //
+    // WHICH manager: the manifest's packageManager is a snapshot and may be
+    // absent, so fall back to the worktree's own lockfile — that keeps this in
+    // agreement with what new-feature.sh would run for the same project (#870).
+    //
+    // WHICH commands for it: yarn's frozen install differs between classic
+    // (`--frozen-lockfile`) and berry (`--immutable`), and both majors use
+    // `yarn.lock`, so the manager's identity alone cannot say which (#871).
+    //
+    // The worktree is checked out by now, so its package.json / .yarnrc.yml /
+    // yarn.lock are all readable here.
+    const pmConfig = resolvePackageManagerConfig(resolvePackageManager(packageManager, worktreePath), worktreePath);
+    // ciInstall, not installSilent: a plain `npm install` normalizes and
+    // rewrites package-lock.json (observed: npm 10 strips the `libc` fields a
+    // newer npm committed), so every provisioned worktree started dirty. That
+    // one unstaged file cascaded: rebaseBeforePR refused to run, stale
+    // worktrees read as having "uncommitted changes" and were never recreated,
+    // and chain checkpoints skipped on an out-of-scope dirty file. A frozen
+    // install never touches the lockfile. Same substitution #803 made for
+    // merge-check's combined-branch test. The `!existsSync(node_modules)`
+    // guard at the call site means `npm ci`'s wipe-and-reinstall has nothing
+    // to wipe.
+    const [cmd, ...args] = pmConfig.ciInstall.split(" ");
+    const command = [cmd, ...args].join(" ");
+    const installResult = spawnSync(cmd, args, {
+        cwd: worktreePath,
+        stdio: "pipe",
+    });
+    if (installResult.status !== 0) {
+        // stderr may be empty on some failures — the resolved command alone is
+        // enough to act on, so always name it (AC-2).
+        const error = installResult.stderr?.toString().trim() ?? "";
+        const detail = error ? `: ${error}` : "";
+        console.log(chalk.yellow(`    !  Dependency install failed (${command})${detail}`));
+        return false;
+    }
+    return true;
+}
 /**
  * Create or reuse a worktree for an issue
  * @param baseBranch - Optional branch to use as base instead of origin/main (for chain mode)
@@ -513,17 +577,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
     // Install dependencies if needed
     const nodeModulesPath = path.join(worktreePath, "node_modules");
     if (!existsSync(nodeModulesPath)) {
-        if (verbose) {
-            console.log(chalk.gray(`    Installing dependencies...`));
-        }
-        // Use detected package manager or default to npm
-        const pm = packageManager || "npm";
-        const pmConfig = PM_CONFIG[pm];
-        const [cmd, ...args] = pmConfig.installSilent.split(" ");
-        spawnSync(cmd, args, {
-            cwd: worktreePath,
-            stdio: "pipe",
-        });
+        installWorktreeDeps(worktreePath, packageManager, verbose);
     }
     if (verbose) {
         console.log(chalk.green(`    ✔ Worktree ready: ${worktreePath}`));
@@ -742,9 +796,14 @@ export function reinstallIfLockfileChanged(worktreePath, packageManager, verbose
     }
     // Re-run install to sync node_modules with updated lockfile
     console.log(chalk.blue(`    Reinstalling dependencies (lockfile changed)...`));
-    const pm = packageManager || "npm";
-    const pmConfig = PM_CONFIG[pm];
-    const [cmd, ...args] = pmConfig.installSilent.split(" ");
+    // Same two-step resolution as installWorktreeDeps: manifest-or-lockfile for
+    // the manager (#870), then classic-vs-berry for its commands (#871).
+    const pmConfig = resolvePackageManagerConfig(resolvePackageManager(packageManager, worktreePath), worktreePath);
+    // ciInstall for the same reason as provisioning (see ensureWorktree): this
+    // reinstall exists because a rebase pulled in a NEW lockfile, so installing
+    // exactly what that lockfile says — never rewriting it — is the semantic
+    // the function's own name promises.
+    const [cmd, ...args] = pmConfig.ciInstall.split(" ");
     const installResult = spawnSync(cmd, args, {
         cwd: worktreePath,
         stdio: "pipe",
@@ -888,6 +947,9 @@ function qaVerdictNote(verdict) {
  * @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).
+ * @param opts.readyGateReport Rendered `sequant ready` gap report (#817). Set
+ *   only when the run used `--ready-gate`; surfaces the gate outcome (threshold
+ *   reached vs guard halt) in the PR body the same way `sequant ready` does.
  * @internal Exported for testing
  */
 export function buildAutomatedPRBody(issueNumber, opts) {
@@ -901,9 +963,18 @@ export function buildAutomatedPRBody(issueNumber, opts) {
     ];
     // #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, ``);
+    //
+    // #817: when the ready gate ran, its report already carries the terminal
+    // verdict and stop reason (a superset of the #749 note), so prefer it and
+    // suppress the standalone note to avoid a contradictory double-headline.
+    if (opts?.readyGateReport) {
+        bodyLines.push(opts.readyGateReport, ``);
+    }
+    else {
+        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.
@@ -917,7 +988,11 @@ export function buildAutomatedPRBody(issueNumber, opts) {
  * 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.
+ *
+ * Returns `{ success: false, error }` on failure. As of #879 the caller
+ * (`runIssueWithLogging`) treats an attempted-but-failed PR as a run failure:
+ * a passing run that produced no PR is not a success. This function itself
+ * still only reports — it never throws — so relay teardown runs regardless.
  *
  * @param worktreePath Path to the worktree
  * @param issueNumber Issue number
@@ -928,10 +1003,13 @@ export function buildAutomatedPRBody(issueNumber, opts) {
  * @param stackOptions When set under --stacked, `prBase` overrides the default
  *   PR target (otherwise gh defaults to the repo's default branch) and
  *   `stackManifest` is appended to the PR body. (#605)
+ * @param qaVerdict QA verdict surfaced in the PR body when non-A+ (#749).
+ * @param readyGateReport Rendered `sequant ready` gap report, set only when the
+ *   run used `--ready-gate` (#817).
  * @returns PRCreationResult with PR info or error
  * @internal Exported for testing
  */
-export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose, labels, stackOptions, qaVerdict) {
+export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose, labels, stackOptions, qaVerdict, readyGateReport) {
     const github = new GitHubProvider();
     // Step 1: Check for existing PR on this branch
     const existingPRInfo = github.viewPRByBranchSync(branch, worktreePath);
@@ -970,6 +1048,7 @@ export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose,
     const prBody = buildAutomatedPRBody(issueNumber, {
         stackManifest: stackOptions?.stackManifest,
         qaVerdict,
+        readyGateReport,
     });
     const prResult = github.createPRCliSync(prTitle, prBody, branch, worktreePath, stackOptions?.prBase);
     if (prResult.exitCode !== 0) {

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

@@ -94,13 +94,21 @@ export declare function parseRunIdLine(line: string): string | null;
 export interface ProgressEvent {
     issue: number;
     phase: string;
-    event: "start" | "complete" | "failed";
+    event: "start" | "complete" | "failed" | "waiting";
     durationSeconds?: number;
     error?: string;
+    /** #860: epoch ms of the auto-wait wake; absent on the terminal notice. */
+    wakeAtMs?: number;
+    /** #860: ms remaining in the auto-wait (0 on the terminal notice). */
+    remainingMs?: number;
 }
 /**
  * Parse a SEQUANT_PROGRESS line emitted by the batch executor.
  * Returns the parsed event or null if the line isn't a progress line.
+ *
+ * `waiting` events (#860) are the auto-wait liveness signal: a run paused on
+ * a rate-limit window emits one per minute so an MCP client sees a deliberate
+ * pause with a wake time rather than silence indistinguishable from a hang.
  */
 export declare function parseProgressLine(line: string): ProgressEvent | null;
 /**

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

@@ -11,6 +11,7 @@ import { resolve, dirname, join } from "path";
 import { existsSync } from "fs";
 import { readdir, readFile } from "fs/promises";
 import { homedir } from "os";
+import { formatResetTime } from "../../lib/errors.js";
 import { LOG_PATHS, RunLogSchema } from "../../lib/workflow/run-log-schema.js";
 import { registerRun, unregisterRun } from "../run-registry.js";
 /** Maximum total response size in bytes (64 KB) */
@@ -261,6 +262,10 @@ export function parseRunIdLine(line) {
 /**
  * Parse a SEQUANT_PROGRESS line emitted by the batch executor.
  * Returns the parsed event or null if the line isn't a progress line.
+ *
+ * `waiting` events (#860) are the auto-wait liveness signal: a run paused on
+ * a rate-limit window emits one per minute so an MCP client sees a deliberate
+ * pause with a wake time rather than silence indistinguishable from a hang.
  */
 export function parseProgressLine(line) {
     if (!line.startsWith(PROGRESS_LINE_PREFIX))
@@ -272,7 +277,8 @@ export function parseProgressLine(line) {
             typeof json.event === "string" &&
             (json.event === "start" ||
                 json.event === "complete" ||
-                json.event === "failed")) {
+                json.event === "failed" ||
+                json.event === "waiting")) {
             const result = {
                 issue: json.issue,
                 phase: json.phase,
@@ -284,6 +290,12 @@ export function parseProgressLine(line) {
             if (typeof json.error === "string") {
                 result.error = json.error;
             }
+            if (typeof json.wakeAtMs === "number") {
+                result.wakeAtMs = json.wakeAtMs;
+            }
+            if (typeof json.remainingMs === "number") {
+                result.remainingMs = json.remainingMs;
+            }
             return result;
         }
         return null;
@@ -341,6 +353,13 @@ export function formatProgressMessage(event) {
             const reason = event.error ? ` \u2014 ${event.error}` : "";
             return `${prefix}: ${event.phase} \u2717${reason}`;
         }
+        case "waiting": {
+            // #860: name the wake time so a paused run reads as deliberate.
+            if (event.wakeAtMs === undefined) {
+                return `${prefix}: ${event.phase} auto-wait complete \u2014 resuming`;
+            }
+            return `${prefix}: ${event.phase} \u23f8 rate-limit window \u2014 resuming at ${formatResetTime(event.wakeAtMs)}`;
+        }
     }
 }
 /**

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

@@ -97,6 +97,12 @@ export function registerStatusTool(server) {
                             phases: issueState.phases,
                             worktree: issueState.worktree,
                             pr: issueState.pr,
+                            // #860: surfaced so MCP pollers see a deliberate rate-limit
+                            // pause (with its wake time) instead of a stale in-progress.
+                            autoWait: issueState.autoWait,
+                            // #892: a durable window halt — resumable via `sequant
+                            // resume` after `resumeAt` — is a pause, not a failure.
+                            windowHalt: issueState.windowHalt,
                             lastActivity: issueState.lastActivity,
                             nextAction: getNextActionHint(issueState),
                             lastSynced: reconcileResult.lastSynced,

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

@@ -1,10 +1,19 @@
 import { type JSX } from "react";
 /**
- * Per-issue elapsed timer. Owns its own interval so tick-driven re-renders
- * are scoped to this leaf component and do not propagate to `IssueBox`.
+ * Per-issue elapsed timer. Reads the shared 1 Hz `now` that `App` already owns
+ * and threads through `IssueBox`, rather than running its own interval: `App`'s
+ * snapshot poller re-renders the whole tree every tick regardless, so a
+ * per-issue clock bought no re-render scoping.
+ *
+ * When `completedAt` is set, the duration freezes at `completedAt - startedAt`.
+ * This is computed in render (not by tearing down an interval on mount), so an
+ * issue that transitions running → passed on the same mounted component freezes
+ * at the transition without a remount.
  */
-export declare function ElapsedTimer({ startedAt }: {
+export declare function ElapsedTimer({ startedAt, completedAt, now, }: {
     startedAt?: Date;
+    completedAt?: Date;
+    now: number;
 }): JSX.Element;
 /** Format an absolute timestamp as the "last activity Xs ago" stamp. */
 export declare function formatSinceActivity(now: number, activityAt: Date): string;

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

@@ -1,19 +1,21 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState } from "react";
 import { Text } from "ink";
 /**
- * Per-issue elapsed timer. Owns its own interval so tick-driven re-renders
- * are scoped to this leaf component and do not propagate to `IssueBox`.
+ * Per-issue elapsed timer. Reads the shared 1 Hz `now` that `App` already owns
+ * and threads through `IssueBox`, rather than running its own interval: `App`'s
+ * snapshot poller re-renders the whole tree every tick regardless, so a
+ * per-issue clock bought no re-render scoping.
+ *
+ * When `completedAt` is set, the duration freezes at `completedAt - startedAt`.
+ * This is computed in render (not by tearing down an interval on mount), so an
+ * issue that transitions running → passed on the same mounted component freezes
+ * at the transition without a remount.
  */
-export function ElapsedTimer({ startedAt }) {
-    const [now, setNow] = useState(() => Date.now());
-    useEffect(() => {
-        const id = setInterval(() => setNow(Date.now()), 1000);
-        return () => clearInterval(id);
-    }, []);
+export function ElapsedTimer({ startedAt, completedAt, now, }) {
     if (!startedAt)
         return _jsx(Text, { children: "--:--" });
-    const secs = Math.max(0, Math.floor((now - startedAt.getTime()) / 1000));
+    const end = completedAt?.getTime() ?? now;
+    const secs = Math.max(0, Math.floor((end - startedAt.getTime()) / 1000));
     const mm = Math.floor(secs / 60)
         .toString()
         .padStart(2, "0");

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { ACTIVE_PHASE_COLOR, DIVIDER_COLOR, PHASE_GLYPHS, borderColorForIssue, phaseStatusColor, } from "./theme.js";
+import { ACTIVE_PHASE_COLOR, DIVIDER_COLOR, PHASE_GLYPHS, borderColorForIssue, isTerminalStatus, phaseStatusColor, } from "./theme.js";
 import { Spinner } from "./Spinner.js";
 import { ElapsedTimer, formatSinceActivity } from "./ElapsedTimer.js";
 import { truncateToWidth } from "./truncate.js";
@@ -20,7 +20,15 @@ export function IssueBox({ state, slot, width, now, }) {
     const displayPhaseN = activePhaseIndex >= 0 ? activePhaseIndex + 1 : doneCount;
     const total = state.phases.length;
     const headerTitle = truncateToWidth(`#${state.number}  ${state.title}`, Math.max(10, innerWidth - 20));
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: border, paddingX: 1, marginBottom: 1, width: width, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: border, children: headerTitle }), _jsxs(Text, { color: DIVIDER_COLOR, children: ["phase ", displayPhaseN, "/", total, " \u2022", " ", _jsx(ElapsedTimer, { startedAt: state.startedAt })] })] }), _jsx(Divider, { width: innerWidth }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "branch " }), _jsx(Text, { children: truncateToWidth(state.branch, innerWidth - 8) })] }), _jsx(PhaseProgression, { phases: state.phases, activeColor: ACTIVE_PHASE_COLOR }), state.currentPhase?.logPath ? (_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "log " }), _jsx(Text, { children: truncateToWidth(state.currentPhase.logPath, innerWidth - 8) })] })) : null] }), _jsx(Divider, { width: innerWidth }), _jsx(Box, { flexDirection: "column", children: state.currentPhase ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "now " }), _jsx(Spinner, { color: ACTIVE_PHASE_COLOR }), _jsxs(Text, { children: ["  ", truncateToWidth(state.currentPhase.nowLine, innerWidth - 12)] })] }), _jsx(Box, { children: _jsxs(Text, { color: DIVIDER_COLOR, children: ["        └ last activity ", formatSinceActivity(now, state.currentPhase.lastActivityAt)] }) })] })) : (_jsx(Text, { color: DIVIDER_COLOR, children: statusLine(state) })) })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: border, paddingX: 1, marginBottom: 1, width: width, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: border, children: headerTitle }), _jsxs(Text, { color: DIVIDER_COLOR, children: ["phase ", displayPhaseN, "/", total, " \u2022", " ", _jsx(ElapsedTimer, { startedAt: state.startedAt, 
+                                // #866: only a terminal status may freeze the clock. Mirrors the
+                                // plain renderer, which branches on status *before* reading
+                                // `completedAt` (`run-renderer.ts` `statusHeader`) and so always
+                                // measures a running issue against the live clock. Without this
+                                // gate a stale `completedAt` on a running issue — what the #766
+                                // quality-loop recovery used to publish — freezes the header while
+                                // the issue is visibly working.
+                                completedAt: isTerminalStatus(state.status) ? state.completedAt : undefined, now: now })] })] }), _jsx(Divider, { width: innerWidth }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "branch " }), _jsx(Text, { children: truncateToWidth(state.branch, innerWidth - 8) })] }), _jsx(PhaseProgression, { phases: state.phases, activeColor: ACTIVE_PHASE_COLOR }), state.currentPhase?.logPath ? (_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "log " }), _jsx(Text, { children: truncateToWidth(state.currentPhase.logPath, innerWidth - 8) })] })) : null] }), _jsx(Divider, { width: innerWidth }), _jsx(Box, { flexDirection: "column", children: state.currentPhase ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "now " }), _jsx(Spinner, { color: ACTIVE_PHASE_COLOR }), _jsxs(Text, { children: ["  ", truncateToWidth(state.currentPhase.nowLine, innerWidth - 12)] })] }), _jsx(Box, { children: _jsxs(Text, { color: DIVIDER_COLOR, children: ["        └ last activity ", formatSinceActivity(now, state.currentPhase.lastActivityAt)] }) })] })) : (_jsx(Text, { color: DIVIDER_COLOR, children: statusLine(state) })) })] }));
 }
 function statusLine(state) {
     switch (state.status) {

package/dist/src/ui/tui/row-cap.js

@@ -12,6 +12,7 @@
  * bottom margin). `LINES_PER_BOX` is sized accordingly so the dynamic cap
  * reflects how many boxes actually fit.
  */
+import { isTerminalStatus } from "./theme.js";
 /** Static row cap (matches the plain renderer's default). */
 export const DEFAULT_TUI_ROW_CAP = 10;
 /**
@@ -27,7 +28,7 @@ export const TUI_LINES_PER_BOX = 11;
 const FIXED_OVERHEAD = 4;
 /** A queued or running issue is "active"; passed/failed are terminal. */
 function isActive(issue) {
-    return issue.status === "queued" || issue.status === "running";
+    return !isTerminalStatus(issue.status);
 }
 /**
  * Effective cap: the smaller of the static cap and a dynamic terminal-height

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

@@ -46,6 +46,13 @@ export declare const ACTIVE_PHASE_COLOR: "#FF8012";
 /** Brand green for the rolled-up `✔ N done` summary line (#699, parity with the
  *  plain renderer's #624 rollup). */
 export declare const ROLLUP_COLOR: "#10b981";
+/**
+ * `passed`/`failed` are terminal; `queued`/`running` mean the issue is still
+ * live. The single definition of that split for the TUI — `row-cap` uses it to
+ * decide which issues can roll up, and `IssueBox` uses it to decide whether the
+ * elapsed clock may freeze (#866).
+ */
+export declare function isTerminalStatus(status: IssueStatus): boolean;
 /**
  * Pick the border color for an issue.
  * Failed / passed states win over rotation; otherwise rotate by slot.

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

@@ -44,6 +44,15 @@ export const ACTIVE_PHASE_COLOR = BRAND_ORANGE;
 /** Brand green for the rolled-up `✔ N done` summary line (#699, parity with the
  *  plain renderer's #624 rollup). */
 export const ROLLUP_COLOR = BRAND_GREEN;
+/**
+ * `passed`/`failed` are terminal; `queued`/`running` mean the issue is still
+ * live. The single definition of that split for the TUI — `row-cap` uses it to
+ * decide which issues can roll up, and `IssueBox` uses it to decide whether the
+ * elapsed clock may freeze (#866).
+ */
+export function isTerminalStatus(status) {
+    return status === "passed" || status === "failed";
+}
 /**
  * Pick the border color for an issue.
  * Failed / passed states win over rotation; otherwise rotate by slot.

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "sequant",
-  "version": "2.9.0",
+  "version": "2.10.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": {
     "sequant": "dist/bin/cli.js"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
     }
   },
   "files": [
@@ -21,7 +21,7 @@
     ".claude-plugin"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist/src dist/bin dist/dashboard && tsc && chmod +x dist/bin/cli.js",
     "dev": "tsx bin/cli.ts",
     "test": "vitest run",
     "lint": "eslint src/ bin/ --max-warnings 0",
@@ -29,6 +29,7 @@
     "sync:hooks": "bash scripts/sync-hooks.sh",
     "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-gates": "npx tsx scripts/lint-skill-gates.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",
@@ -78,7 +79,7 @@
   },
   "homepage": "https://sequant.io",
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=22.13.0"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1"

package/templates/hooks/parallel-marker.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# Shared naming contract for /exec parallel-group marker files (#881).
+#
+# One writer (the /exec skill) and two readers (pre-tool.sh, post-tool.sh) must
+# agree on (a) the marker filename and (b) how the owning project is identified.
+# Before #881 the filename was a global constant, so a parallel group in ONE
+# project silently redirected worktree enforcement for EVERY concurrent Claude
+# session on the machine — the first matching marker in the shared temp dir won,
+# regardless of which project wrote it. Keeping the scheme in this single sourced
+# file is what stops the writer and the readers from drifting apart (AC-4).
+#
+# Marker filename: ${TMPDIR}/claude-parallel-<project-hash>-<group-id>.marker
+# Marker contents: line 1 = worktree path, line 2 = owning project root.
+
+# parallel_marker_project_root — the canonical identity of the current project,
+# derived identically in skill-context and hook-context. CLAUDE_PROJECT_DIR is
+# set by Claude Code for both the skill's shell and the hook's shell within the
+# same session; the git-toplevel fallback resolves to the same worktree when it
+# is unset. A mismatch here would silently re-introduce the cross-project
+# collision this fix exists to close, so the two contexts MUST agree.
+parallel_marker_project_root() {
+    if [[ -n "${CLAUDE_PROJECT_DIR:-}" ]]; then
+        printf '%s' "$CLAUDE_PROJECT_DIR"
+    else
+        git rev-parse --show-toplevel 2>/dev/null || printf '%s' "$PWD"
+    fi
+}
+
+# parallel_marker_hash — a stable per-project hash used in the marker filename so
+# two projects running parallel groups at once cannot collide (AC-1). Reuses the
+# md5-with-md5sum-fallback idiom already used for the per-file lock in
+# pre-tool.sh. printf (no trailing newline) keeps writer and reader identical.
+parallel_marker_hash() {
+    local root
+    root="$(parallel_marker_project_root)"
+    printf '%s' "$root" | md5 -q 2>/dev/null || printf '%s' "$root" | md5sum | cut -d' ' -f1
+}
+
+# parallel_marker_prefix — the ${TMPDIR}-anchored, project-scoped filename prefix
+# that both the writer and the readers glob on (AC-2). Honors $TMPDIR (macOS's
+# per-user temp) with a /tmp fallback, matching the hooks' own _TMPDIR.
+parallel_marker_prefix() {
+    local tmp="${TMPDIR:-/tmp}"
+    printf '%s/claude-parallel-%s-' "$tmp" "$(parallel_marker_hash)"
+}
+
+# parallel_marker_path <group-id> — the full marker path for one group.
+parallel_marker_path() {
+    printf '%s%s.marker' "$(parallel_marker_prefix)" "$1"
+}

package/templates/hooks/post-tool.sh

@@ -77,22 +77,35 @@ mkdir -p "$_LOG_DIR" 2>/dev/null || _LOG_DIR="${_TMPDIR}"
 TIMING_LOG="${_LOG_DIR}/claude-timing.log"
 QUALITY_LOG="${_LOG_DIR}/claude-quality.log"
 TESTS_LOG="${_LOG_DIR}/claude-tests.log"
-PARALLEL_MARKER_PREFIX="${_TMPDIR}/claude-parallel-"
+
+# Parallel-group marker naming (#881). Source the shared helper next to this
+# hook so the project-scoped prefix stays identical to the writer and pre-tool.sh.
+_MARKER_HELPER="$(dirname "${BASH_SOURCE[0]:-$0}")/parallel-marker.sh"
+if [[ -f "$_MARKER_HELPER" ]]; then
+    # shellcheck source=parallel-marker.sh disable=SC1091
+    source "$_MARKER_HELPER"
+    PARALLEL_MARKER_PREFIX="$(parallel_marker_prefix)"
+else
+    PARALLEL_MARKER_PREFIX="${_TMPDIR}/claude-parallel-"
+fi
 
 # === AGENT ID DETECTION ===
-# For parallel agents, detect group ID from marker files
-# Format: ${_TMPDIR}/claude-parallel-<group-id>.marker
+# For parallel agents, detect group ID from marker files. The glob is scoped to
+# the current project's marker prefix (#881) so a foreign project's marker never
+# labels this session's timing rows.
 AGENT_ID=""
 IS_PARALLEL_AGENT="false"
+_MARKER_BASE=$(basename "$PARALLEL_MARKER_PREFIX")
 # Find marker files using find (works in both bash and zsh)
 while IFS= read -r marker; do
     if [[ -n "$marker" && -f "$marker" ]]; then
-        # Extract group ID from marker filename
-        AGENT_ID=$(basename "$marker" | sed 's/claude-parallel-//' | sed 's/\.marker//')
+        # Extract group ID: strip the project-scoped prefix and the suffix.
+        AGENT_ID=$(basename "$marker" .marker)
+        AGENT_ID=${AGENT_ID#"$_MARKER_BASE"}
         IS_PARALLEL_AGENT="true"
         break
     fi
-done < <(find "${_TMPDIR}" -maxdepth 1 -name "claude-parallel-*.marker" 2>/dev/null)
+done < <(find "${_TMPDIR}" -maxdepth 1 -name "${_MARKER_BASE}*.marker" 2>/dev/null)
 
 # === TIMING END ===
 # Include agent ID in log format if available (AC-4)
@@ -253,7 +266,7 @@ if [[ "${CLAUDE_HOOKS_COVERAGE:-}" == "true" ]]; then
             COVERAGE_LOG="${_LOG_DIR}/claude-coverage.log"
 
             # Get changed source files (excluding tests)
-            changed_files=$(git diff main...HEAD --name-only 2>/dev/null | grep -E '\.(ts|tsx|js|jsx)$' | grep -v -E '\.test\.|\.spec\.|__tests__' || true)
+            changed_files=$(git diff origin/main...HEAD --name-only 2>/dev/null | grep -E '\.(ts|tsx|js|jsx)$' | grep -v -E '\.test\.|\.spec\.|__tests__' || true)
 
             if [[ -n "$changed_files" ]]; then
                 echo "$(date +%H:%M:%S) COVERAGE_ANALYSIS: Checking test coverage for changed files" >> "$QUALITY_LOG"