sequant 2.4.0 → 2.5.0

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

@@ -1,25 +1,39 @@
 /**
  * Experimental multi-issue TUI entry point.
  *
- * Mounts an `ink` app that polls `RunOrchestrator.getSnapshot()` at 10 Hz.
- * Unmounts when the orchestrator reports `done` so the shell returns
+ * Mounts an `ink` app that polls a snapshot provider's `getSnapshot()` at
+ * 10 Hz. Unmounts when the snapshot reports `done` so the shell returns
  * cleanly. Only safe to call when `process.stdout.isTTY` is true.
+ *
+ * The provider is structural (`{ getSnapshot(): RunSnapshot }`) so any source
+ * of run state can drive the TUI — `RunOrchestrator` for `sequant run`, or the
+ * single-issue adapter `sequant ready` owns (#699). The TUI only ever reads
+ * `getSnapshot()`, never the orchestrator's batch lifecycle.
  */
 import { createElement } from "react";
 import { render } from "ink";
 import { App } from "./App.js";
-export function renderTui(orchestrator) {
+import { composeTeardownSummary } from "./teardown.js";
+export function renderTui(provider) {
     let resolveDone;
     const done = new Promise((resolve) => {
         resolveDone = resolve;
     });
     const instance = render(createElement(App, {
-        getSnapshot: () => orchestrator.getSnapshot(),
+        getSnapshot: () => provider.getSnapshot(),
         onDone: () => {
             instance.unmount();
         },
     }), { exitOnCtrlC: false });
-    instance.waitUntilExit().then(() => resolveDone());
+    instance.waitUntilExit().then(() => {
+        // #699 AC-5: ink leaves no per-issue history on unmount, so write a durable
+        // `✔/✘` transcript from the final snapshot into scrollback. Runs before
+        // `done` resolves so the caller's own report (e.g. `ready`'s) prints after.
+        const summary = composeTeardownSummary(provider.getSnapshot());
+        if (summary)
+            process.stdout.write(summary + "\n");
+        resolveDone();
+    });
     return {
         done,
         unmount: () => {

package/dist/src/ui/tui/row-cap.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Row cap + frame-height clamp for the Ink TUI (#699 AC-4).
+ *
+ * Parity with the plain renderer's #624 behavior (`run-renderer.ts`
+ * `applyRowCap` / `effectiveRowCap`): N issues must never render more boxes
+ * than the terminal can hold. Keep every active (queued/running) issue, fill
+ * the remaining slots with the most-recently-completed issues, and roll older
+ * completed issues into a single `✔ N done` summary line.
+ *
+ * The TUI difference is vertical density: each plain-grid issue is ~3 lines,
+ * but a full Ink box is ~9–11 lines (round border + 3 cells + 2 dividers +
+ * bottom margin). `LINES_PER_BOX` is sized accordingly so the dynamic cap
+ * reflects how many boxes actually fit.
+ */
+import type { IssueRuntimeState } from "../../lib/workflow/run-state.js";
+/** Static row cap (matches the plain renderer's default). */
+export declare const DEFAULT_TUI_ROW_CAP = 10;
+/**
+ * Approximate height of one rendered Ink box, in terminal rows: round border
+ * top/bottom (2) + header (1) + two dividers (2) + context cell (~3) +
+ * activity cell (~2) + bottom margin (1) ≈ 11.
+ */
+export declare const TUI_LINES_PER_BOX = 11;
+/**
+ * Effective cap: the smaller of the static cap and a dynamic terminal-height
+ * ceiling. Mirrors `run-renderer.ts` `effectiveRowCap`, but with a box-height
+ * `linesPerBox` rather than the plain grid's 3.
+ *
+ * When `rows` is unknown (no TTY size), trust the static cap directly rather
+ * than guessing a height — the same "don't over-clamp" intent as the plain
+ * renderer's tall default, without picking an arbitrary fallback row count.
+ *
+ * @internal Exported for testing.
+ */
+export declare function effectiveTuiRowCap(rows: number | undefined, staticCap?: number, linesPerBox?: number): number;
+export interface VisibleSelection {
+    /** Boxes to render, in order: active issues first, then recent done. */
+    visible: IssueRuntimeState[];
+    /** Older completed issues collapsed into the `✔ N done` summary (0 if none). */
+    rolledUpDoneCount: number;
+}
+/**
+ * Select which issue boxes to render so the frame never exceeds the terminal
+ * height. Parity with `run-renderer.ts` `applyRowCap`.
+ *
+ * - Under the cap → render everything, no rollup.
+ * - Over the cap → keep all active issues; fill remaining slots (minus one
+ *   reserved for the rollup line) with the most-recently-completed issues;
+ *   the rest roll up into `rolledUpDoneCount`.
+ */
+export declare function selectVisibleIssues(issues: IssueRuntimeState[], rows: number | undefined, staticCap?: number, linesPerBox?: number): VisibleSelection;

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

@@ -0,0 +1,76 @@
+/**
+ * Row cap + frame-height clamp for the Ink TUI (#699 AC-4).
+ *
+ * Parity with the plain renderer's #624 behavior (`run-renderer.ts`
+ * `applyRowCap` / `effectiveRowCap`): N issues must never render more boxes
+ * than the terminal can hold. Keep every active (queued/running) issue, fill
+ * the remaining slots with the most-recently-completed issues, and roll older
+ * completed issues into a single `✔ N done` summary line.
+ *
+ * The TUI difference is vertical density: each plain-grid issue is ~3 lines,
+ * but a full Ink box is ~9–11 lines (round border + 3 cells + 2 dividers +
+ * bottom margin). `LINES_PER_BOX` is sized accordingly so the dynamic cap
+ * reflects how many boxes actually fit.
+ */
+/** Static row cap (matches the plain renderer's default). */
+export const DEFAULT_TUI_ROW_CAP = 10;
+/**
+ * Approximate height of one rendered Ink box, in terminal rows: round border
+ * top/bottom (2) + header (1) + two dividers (2) + context cell (~3) +
+ * activity cell (~2) + bottom margin (1) ≈ 11.
+ */
+export const TUI_LINES_PER_BOX = 11;
+/**
+ * Fixed vertical overhead outside the issue boxes: the Header block plus the
+ * rolled-up `✔ N done` summary line.
+ */
+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";
+}
+/**
+ * Effective cap: the smaller of the static cap and a dynamic terminal-height
+ * ceiling. Mirrors `run-renderer.ts` `effectiveRowCap`, but with a box-height
+ * `linesPerBox` rather than the plain grid's 3.
+ *
+ * When `rows` is unknown (no TTY size), trust the static cap directly rather
+ * than guessing a height — the same "don't over-clamp" intent as the plain
+ * renderer's tall default, without picking an arbitrary fallback row count.
+ *
+ * @internal Exported for testing.
+ */
+export function effectiveTuiRowCap(rows, staticCap = DEFAULT_TUI_ROW_CAP, linesPerBox = TUI_LINES_PER_BOX) {
+    if (!rows || rows <= 0)
+        return staticCap;
+    const dynamicCap = Math.max(1, Math.floor((rows - FIXED_OVERHEAD) / Math.max(1, linesPerBox)));
+    return Math.min(staticCap, dynamicCap);
+}
+/**
+ * Select which issue boxes to render so the frame never exceeds the terminal
+ * height. Parity with `run-renderer.ts` `applyRowCap`.
+ *
+ * - Under the cap → render everything, no rollup.
+ * - Over the cap → keep all active issues; fill remaining slots (minus one
+ *   reserved for the rollup line) with the most-recently-completed issues;
+ *   the rest roll up into `rolledUpDoneCount`.
+ */
+export function selectVisibleIssues(issues, rows, staticCap = DEFAULT_TUI_ROW_CAP, linesPerBox = TUI_LINES_PER_BOX) {
+    const cap = effectiveTuiRowCap(rows, staticCap, linesPerBox);
+    if (issues.length <= cap) {
+        return { visible: issues, rolledUpDoneCount: 0 };
+    }
+    const active = issues.filter(isActive);
+    const done = issues
+        .filter((i) => !isActive(i))
+        .sort((a, b) => (b.completedAt?.getTime() ?? 0) - (a.completedAt?.getTime() ?? 0));
+    // Reserve one slot for the rollup line; the rest go to visible boxes.
+    const visibleSlots = Math.max(1, cap - 1);
+    const remainingForDone = Math.max(0, visibleSlots - active.length);
+    const visibleDone = done.slice(0, remainingForDone);
+    const rolledUpDoneCount = done.length - visibleDone.length;
+    return {
+        visible: [...active, ...visibleDone],
+        rolledUpDoneCount,
+    };
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Durable teardown summary for the Ink TUI (#699 AC-5).
+ *
+ * Ink repaints a live region in place; unlike the plain renderer it appends no
+ * per-issue `✔/✘` history when it unmounts. So on teardown we compose a compact
+ * transcript line per issue from the final snapshot and write it to stdout
+ * (outside ink's managed region) so a completed run leaves a record in
+ * scrollback. Emitting it here in the shared entry point means both `run` and
+ * `sequant ready` inherit it.
+ */
+import type { RunSnapshot } from "../../lib/workflow/run-state.js";
+/**
+ * Compose the durable teardown summary from a final snapshot.
+ *
+ * Returns a newline-joined block of one line per issue, or an empty string when
+ * there are no issues (nothing to record).
+ *
+ * @internal Exported for testing.
+ */
+export declare function composeTeardownSummary(snapshot: RunSnapshot): string;

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

@@ -0,0 +1,29 @@
+/**
+ * Durable teardown summary for the Ink TUI (#699 AC-5).
+ *
+ * Ink repaints a live region in place; unlike the plain renderer it appends no
+ * per-issue `✔/✘` history when it unmounts. So on teardown we compose a compact
+ * transcript line per issue from the final snapshot and write it to stdout
+ * (outside ink's managed region) so a completed run leaves a record in
+ * scrollback. Emitting it here in the shared entry point means both `run` and
+ * `sequant ready` inherit it.
+ */
+/** One transcript line per issue, e.g. `✔ #699 Upgrade ready to the Ink TUI`. */
+function issueLine(issue) {
+    const glyph = issue.status === "failed" ? "✘" : "✔";
+    const title = issue.title ? ` ${issue.title}` : "";
+    return `${glyph} #${issue.number}${title}`;
+}
+/**
+ * Compose the durable teardown summary from a final snapshot.
+ *
+ * Returns a newline-joined block of one line per issue, or an empty string when
+ * there are no issues (nothing to record).
+ *
+ * @internal Exported for testing.
+ */
+export function composeTeardownSummary(snapshot) {
+    if (!snapshot.issues.length)
+        return "";
+    return snapshot.issues.map(issueLine).join("\n");
+}

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

@@ -11,6 +11,9 @@ export declare const BORDER_ROTATION: readonly ["cyan", "magenta", "blue", "yell
 export type BorderColor = (typeof BORDER_ROTATION)[number] | "green" | "red" | "gray";
 /** Gray used for horizontal dividers inside each box. */
 export declare const DIVIDER_COLOR: "gray";
+/** Green used for the rolled-up `✔ N done` summary line (#699, parity with the
+ *  plain renderer's #624 rollup). */
+export declare const ROLLUP_COLOR: "green";
 /**
  * Pick the border color for an issue.
  * Failed / passed states win over rotation; otherwise rotate by slot.

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

@@ -9,6 +9,9 @@
 export const BORDER_ROTATION = ["cyan", "magenta", "blue", "yellow"];
 /** Gray used for horizontal dividers inside each box. */
 export const DIVIDER_COLOR = "gray";
+/** Green used for the rolled-up `✔ N done` summary line (#699, parity with the
+ *  plain renderer's #624 rollup). */
+export const ROLLUP_COLOR = "green";
 /**
  * Pick the border color for an issue.
  * Failed / passed states win over rotation; otherwise rotate by slot.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sequant",
-  "version": "2.4.0",
-  "description": "Quantize your development workflow - Sequential AI phases with quality gates",
+  "version": "2.5.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"
@@ -34,26 +34,37 @@
     "prepublishOnly": "npm run build"
   },
   "keywords": [
-    "ai",
     "claude",
     "claude-code",
+    "claude-code-plugin",
     "aider",
     "mcp",
+    "mcp-server",
     "cli",
+    "headless",
+    "ci",
     "workflow",
     "automation",
+    "parallel",
     "coding-agent",
-    "agent",
+    "ai-coding-agent",
+    "agent-orchestrator",
+    "autonomous-agent",
+    "agentic",
     "github",
     "github-issues",
+    "pull-request",
+    "issue-resolution",
+    "spec-driven",
+    "acceptance-criteria",
+    "human-in-the-loop",
+    "code-review",
     "quality-gates",
     "code-quality",
     "orchestrator",
+    "git-worktree",
     "developer-tools",
-    "anthropic",
-    "llm",
-    "ai-coding",
-    "copilot"
+    "ai-coding"
   ],
   "author": "Sequant Contributors",
   "license": "MIT",

package/templates/skills/qa/SKILL.md

@@ -48,6 +48,7 @@ When running as part of an orchestrated workflow (e.g., `sequant run` or `/fulls
 | `SEQUANT_PHASE` | Current phase in the workflow | `qa` |
 | `SEQUANT_ISSUE` | Issue number being processed | `123` |
 | `SEQUANT_WORKTREE` | Path to the feature worktree | `/path/to/worktrees/feature/...` |
+| `SEQUANT_FULL_QA` | Force full-weight (standalone) QA pre-flight even under an orchestrator (#683) | `1` |
 
 **Behavior when orchestrated (SEQUANT_ORCHESTRATOR is set):**
 
@@ -57,6 +58,8 @@ When running as part of an orchestrated workflow (e.g., `sequant run` or `/fulls
 4. **Reduce GitHub comment frequency** - Defer updates to orchestrator
 5. **Trust git state** - Orchestrator verified branch status
 
+> **Full-weight override (`SEQUANT_FULL_QA=1`, #683).** When this flag is set (e.g. by `sequant ready`), do NOT take the git-state shortcuts above. Run the **standalone** pre-flight sync check, the stale-branch detection, and the process-state inspection (uncommitted work, divergent/zero-commit branches) even though `SEQUANT_ORCHESTRATOR` is set — this is the deliberate fresh full-weight pass that catches the no-implementation / divergent-branch class. The other orchestrated behaviors (skip issue fetch, reduced GitHub comments) still apply.
+
 **Behavior when standalone (SEQUANT_ORCHESTRATOR is NOT set):**
 
 - Perform pre-flight sync check
@@ -230,7 +233,7 @@ If the cache is corrupted or unreadable:
 
 ### Pre-flight Sync Check
 
-**Skip this section if `SEQUANT_ORCHESTRATOR` is set** - the orchestrator has already verified sync status.
+**Skip this section if `SEQUANT_ORCHESTRATOR` is set** (the orchestrator has already verified sync status) — **unless `SEQUANT_FULL_QA=1`**, in which case run this check even under an orchestrator (#683).
 
 Before starting QA (standalone mode), verify the local branch is in sync with remote:
 
@@ -251,7 +254,7 @@ git pull origin main  # Or merge origin/main if pull fails
 
 ### Stale Branch Detection
 
-**Skip this section if `SEQUANT_ORCHESTRATOR` is set** - the orchestrator handles branch freshness checks.
+**Skip this section if `SEQUANT_ORCHESTRATOR` is set** (the orchestrator handles branch freshness checks) — **unless `SEQUANT_FULL_QA=1`**, in which case run the branch-freshness check even under an orchestrator (#683).
 
 **Purpose:** Detect when the feature branch is significantly behind main, which can lead to:
 - QA cycles wasted reviewing code that won't cleanly merge