sequant 2.8.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)
@@ -365,21 +429,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 +447,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,
@@ -523,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}`));
@@ -700,9 +744,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}`));
@@ -751,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",
@@ -766,6 +816,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,11 +915,84 @@ 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).
+ * @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) {
+    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+.
+    //
+    // #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.
+    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.
  *
  * 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
@@ -847,10 +1003,13 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
  * @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) {
+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);
@@ -886,21 +1045,11 @@ 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,
+        readyGateReport,
+    });
     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;
@@ -92,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) */
@@ -182,6 +183,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 +234,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,
@@ -259,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))
@@ -270,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,
@@ -282,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;
@@ -339,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.