sequant 2.4.0 → 2.6.0

package/.claude-plugin/marketplace.json

@@ -7,8 +7,8 @@
   "plugins": [
     {
       "name": "sequant",
-      "description": "Structured workflow system for Claude Code - GitHub issue resolution with spec, exec, test, and QA phases. Includes 17 skills, MCP server with workflow tools, and pre/post-tool hooks.",
-      "version": "2.4.0",
+      "description": "AI coding agent orchestrator for Claude Code — resolve GitHub issues end-to-end with isolated git worktrees, quality gates, and an MCP server. Includes 17 skills, workflow MCP tools, and pre/post-tool hooks.",
+      "version": "2.6.0",
       "author": {
         "name": "sequant-io",
         "email": "hello@sequant.io"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "sequant",
-  "description": "Structured workflow system for Claude Code - GitHub issue resolution with spec, exec, test, and QA phases",
-  "version": "2.4.0",
+  "description": "AI coding agent orchestrator for Claude Code — resolve GitHub issues end-to-end with isolated git worktrees and quality gates, through spec → exec → qa phases.",
+  "version": "2.6.0",
   "author": {
     "name": "sequant-io",
     "email": "hello@sequant.io"

package/README.md

@@ -1,87 +1,96 @@
 # Sequant
 
-**Workflow automation for AI coding agents.**
+**Spec-driven AI coding agents — every acceptance criterion verified, stops at the human merge gate.**
 
-Solve GitHub issues with structured phases and quality gates — from issue to merge-ready PR.
+For teams that can't ship un-reviewed AI code. Solve GitHub issues with structured phases and quality gates — from issue to merge-ready PR.
 
 **[sequant.io](https://sequant.io)** — docs, guides, and getting started.
 
 [![npm version](https://img.shields.io/npm/v/sequant.svg)](https://www.npmjs.com/package/sequant)
+[![npm downloads](https://img.shields.io/npm/dm/sequant.svg)](https://www.npmjs.com/package/sequant)
+[![GitHub stars](https://img.shields.io/github/stars/sequant-io/sequant.svg)](https://github.com/sequant-io/sequant/stargazers)
+[![CI](https://github.com/sequant-io/sequant/actions/workflows/ci.yml/badge.svg)](https://github.com/sequant-io/sequant/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 
-### What's new in 2.x
+AI coding agents write code well, but leave you to run the workflow around it — planning, isolation, review, and merge safety. Sequant wraps an agent in a structured **spec → exec → qa** pipeline with isolated git worktrees and quality gates, taking a GitHub issue from triage to a merge-ready PR without babysitting each step.
 
-- **MCP server** — `sequant serve` exposes workflow orchestration as MCP tools (`sequant_run`, `sequant_status`, `sequant_logs`). Any MCP client can drive Sequant headlessly.
-- **`/assess` unification** — `/solve` is merged into `/assess` with a 6-action vocabulary (PROCEED, CLOSE, MERGE, REWRITE, CLARIFY, PARK). `/solve` still works as an alias.
-- **Parallel execution with per-issue locks** — multi-issue runs are concurrent by default (`--concurrency`); `.sequant/locks/` prevents two sessions from clobbering the same issue.
-- **Stacked PRs** — `sequant run --stacked` chains issue PRs onto their predecessor branch so reviewers see the incremental diff per issue instead of the cumulative chain diff.
-- **Live run dashboard + cohort analytics** — unified renderer with a two-zone TTY grid (active issues + append-only events log); `sequant stats --label <name> --since YYYY-MM-DD` filters runs for measuring feature- or class-specific success rates.
-- **Interactive relay** — `sequant prompt <issue> "<message>"` sends queries or directives into a running headless `sequant run`, and `sequant watch <issue>` tails the replies. Bidirectional communication with detached and CI-driven sessions.
-- **Worktree isolation for parallel agents** — `sequant run --isolate-parallel` gives each parallel `/exec` agent group its own sub-worktree with merge-back via `git merge --no-ff`, eliminating file conflicts between concurrent agents structurally rather than by convention.
-- **GitHub Actions & multi-agent backends** — label-triggered and comment-triggered CI workflows out of the box; `--agent aider` for non-Claude-Code execution.
+See the [CHANGELOG](CHANGELOG.md) for release notes, or the [migration guide](CHANGELOG.md#migration-from-v1x) if upgrading from v1.x.
 
-Upgrading from v1.x? See the [migration guide](CHANGELOG.md#migration-from-v1x).
+### What's new in 2.5
+
+- **`sequant ready <issue>`** — a post-resolve A+ QA gate that drives a resolved issue through a full-weight `qa → loop → qa` pass and **stops at the human merge gate — it never merges**.
+- **Live phase-matrix TUI** — `sequant ready` and `sequant run` render the active phase and quality-loop iteration in place (boxed Ink dashboard on a TTY by default), so a long run is never indistinguishable from a hang. Opt out with `--no-tui` (line renderer) or `-s`/`--quiet` (heartbeat-only); non-TTY output auto-degrades.
+- **Per-issue concurrency locks** — a second session on the same issue is skipped with a clear message instead of clobbering the first; `sequant locks` inspects and clears them.
 
 ## Quick Start
 
-### Option A: Plugin (interactive users)
+### Prerequisites
 
-In Claude Code:
+**An AI coding agent — one of:**
+- [Claude Code](https://claude.ai/code) — default agent
+- [Aider](https://aider.chat/) — alternative, via `--agent aider`
+
+**Always required (both):**
+- [GitHub CLI](https://cli.github.com/) — run `gh auth login`
+- Git — for worktree-based isolation
+
+**For the npm/CLI install path:** Node.js 22.12+
+
+**Optional MCP (Model Context Protocol) servers — enhanced features:**
+- `chrome-devtools` — enables `/test` for browser-based UI testing
+- `sequential-thinking` — enhanced reasoning for complex decisions
+- `context7` — library documentation lookup
+
+> **Note:** Sequant is optimized for Node.js/TypeScript projects. The worktree workflow works with any git repository.
+
+### Install
+
+Pick the path that matches **where you run Sequant**:
+
+**Inside Claude Code (plugin)** — skills, hooks, and MCP tools, no npm required:
 ```
 /plugin install sequant@sequant-io/sequant
 /sequant:setup
 ```
 
-You get skills, hooks, and MCP tools — no npm required.
+**Headless / CI (npm package)** — drive runs from the terminal or a CI job:
+```bash
+npm install sequant          # or: pnpm add / yarn add / bun add sequant
+npx sequant init             # install skills into your project
+npx sequant doctor           # verify setup
+```
 
-### Option B: Package install (power users / CI)
+### Your first run
 
-```bash
-npm install sequant          # npm
-pnpm add sequant             # pnpm
-yarn add sequant             # yarn
-bun add sequant              # bun
+Inside Claude Code, solve an issue end-to-end:
+```
+/fullsolve 123
 ```
 
-Then initialize:
+Or headless from the terminal (`-Q` runs the quality loop):
 ```bash
-npx sequant init     # Install skills to your project
-npx sequant doctor   # Verify setup
+npx sequant run 123 -Q
 ```
 
-### Start Using
+Either way, Sequant creates an isolated worktree, posts a plan comment to the issue, and opens a merge-ready PR.
 
-Then in Claude Code:
+### What a run looks like
 
-```
-/fullsolve 123    # Solve issue #123 end-to-end
-```
+A real `/fullsolve 683` (the run that built `sequant ready` itself):
 
-Or step-by-step:
+```text
+SEQUANT WORKFLOW · #683
+  spec   ✔  9 ACs extracted · plan posted to the issue
+  exec   ✔  29 tests + docs + lint fix · committed to the feature branch
+  qa     ✔  full build + suite · 8/9 ACs MET · 1 manual AC marked PENDING (not faked)
+  pr     ✔  opened #686 · 7/7 checks green · MERGEABLE
 
+  → stops at the human merge gate · never auto-merges · run `merge` to land it
 ```
-/spec 123    # Plan implementation
-/exec 123    # Build in isolated worktree
-/qa 123      # Review before merge
-```
-
-### Prerequisites
-
-**Required (one of):**
-- [Claude Code](https://claude.ai/code) — default agent
-- [Aider](https://aider.chat/) — alternative via `--agent aider`
-- [GitHub CLI](https://cli.github.com/) — run `gh auth login`
-- Git (for worktree-based isolation)
 
-**For npm installation:**
-- Node.js 22.12+
+QA findings post back to the issue as comments, with each acceptance criterion re-checked independently.
 
-**Optional MCP servers (enhanced features):**
-- `chrome-devtools` — enables `/test` for browser-based UI testing
-- `sequential-thinking` — enhanced reasoning for complex decisions
-- `context7` — library documentation lookup
-
-> **Note:** Sequant is optimized for Node.js/TypeScript projects. The worktree workflow works with any git repository.
+> 📹 A recorded demo GIF of the live run grid is coming — tracked in [#695](https://github.com/sequant-io/sequant/issues/695).
 
 ---
 
@@ -135,159 +144,111 @@ When checks fail, `/loop` automatically fixes and re-runs (up to 3x).
 
 ---
 
-## Two Ways to Use
+## Using Sequant
 
-### Interactive (Slash Commands)
+### Solve one issue (the 80% path)
 
-Type commands in Claude Code or any MCP-connected client:
+The most common invocation — no flags. Auto-creates a worktree, posts a plan comment to the issue, and opens a PR.
 
+In Claude Code:
 ```
-/fullsolve 123              # Complete pipeline
-/spec 123 → /exec → /qa     # Step by step
+/fullsolve 123
 ```
 
-### Headless (CLI)
-
-Run without Claude Code UI:
-
+Headless (`-Q` runs the quality loop):
 ```bash
-npx sequant run 123              # Single issue
-npx sequant run 1 2 3            # Batch (parallel)
-npx sequant run 123 --quality-loop
-npx sequant run 123 --base feature/dashboard  # Custom base branch
-npx sequant merge --check        # Verify batch before merging
+npx sequant run 123 -Q
 ```
 
----
-
-## Commands
+> `sequant run --help` is the authoritative flag list. There is **no** `--skip-spec` — to skip the plan phase, use `--phases exec,qa`.
 
-### Core Workflow
+### Batch: triage, then run
 
-| Command | Purpose |
-|---------|---------|
-| `/spec` | Plan implementation, draft acceptance criteria |
-| `/exec` | Implement in isolated git worktree |
-| `/test` | Browser-based UI testing (optional) |
-| `/qa` | Code review and quality gate |
+For several issues at once, the ritual is `/assess` → paste the commands it emits:
 
-### Automation
+```
+/assess 101 102 103
+```
 
-| Command | Purpose |
-|---------|---------|
-| `/fullsolve` | Complete pipeline in one command |
-| `/assess` | Triage issue, recommend workflow (6-action vocabulary) |
-| `/loop` | Fix iteration when checks fail |
+`/assess` returns a dashboard (PROCEED / PARK / CLOSE per issue), dependency ordering, and ready-to-paste commands like `npx sequant run 101 -Q`. The quality loop (`-Q`) is part of every command it generates.
 
-### Integration
+### From Claude Code, via the MCP server
 
-| Command | Purpose |
-|---------|---------|
-| `/merger` | Multi-issue merge coordination |
-| `/testgen` | Generate test stubs from spec |
-| `/verify` | CLI/script execution verification |
-| `/setup` | Initialize Sequant in a project |
+With the plugin installed, drive runs through the MCP server from inside Claude Code:
 
-### Utilities
+```
+use sequant plugin to fullsolve 123
+```
 
-| Command | Purpose |
-|---------|---------|
-| `/docs` | Generate feature documentation |
-| `/clean` | Repository cleanup |
-| `/improve` | Codebase analysis and improvement discovery |
-| `/security-review` | Deep security analysis |
-| `/reflect` | Workflow improvement analysis |
+You get back a structured phase-timing table and verdict. The same tools — `sequant_run`, `sequant_status`, `sequant_logs` — are available to any MCP client; `npx sequant serve` exposes them headlessly.
 
----
+### QA on the issue
 
-## CLI Commands
+Re-verify a resolved issue or PR. Findings land as **issue comments**, with each acceptance criterion independently re-checked:
 
-```bash
-npx sequant init              # Initialize in project
-npx sequant update            # Update skill templates
-npx sequant doctor            # Check installation
-npx sequant status            # Show version and config
-npx sequant run <issues...>   # Execute workflow
-npx sequant merge <issues...> # Batch integration QA before merging
-npx sequant state <cmd>       # Manage workflow state (init/rebuild/clean)
-npx sequant locks <cmd>       # Inspect/clear per-issue concurrency locks
-npx sequant stats             # View local workflow analytics
-npx sequant dashboard         # Launch real-time workflow dashboard
+```
+123 any gaps?     # re-QA issue #123
+/qa pr488         # re-QA a PR
 ```
 
-Cohort filtering: `npx sequant stats --label docs --since 2026-01-01`. See [Analytics — Filtering by Label or Date](docs/reference/analytics.md#filtering-by-label-or-date) for details.
+### Merge
 
-See [Run Command Options](docs/reference/run-command.md), [Merge Command](docs/reference/merge-command.md), [State Command](docs/reference/state-command.md), and [Analytics](docs/reference/analytics.md) for details.
+```
+merge             # squash-merge + sync main + worktree cleanup + post-merge build/test
+```
 
 ---
 
-## Concurrency
+## Command Reference
 
-Sequant prevents two sessions from working on the same GitHub issue at the
-same time. When `sequant run` starts, each issue claims a per-issue lock at
-`.sequant/locks/<issue>.lock` containing the holder's PID, hostname, start
-time, and command. A second session attempting the same issue is skipped
-with a clear error and the rest of the batch continues.
+Most work goes through a handful of top-level commands. The rest are either pipeline internals (run for you) or occasional tools.
 
-**Stale recovery.** Locks are auto-cleared in three situations:
+### Everyday
 
-1. Same host, PID no longer alive → cleared immediately (covers SIGKILL and
-   crashes).
-2. Cross-host, lock older than 2 hours → cleared by age.
-3. Manual: `sequant locks clear <issue>` (with safety check by default).
+| Command | What it does |
+|---------|--------------|
+| `/fullsolve <issue>` | Complete spec → exec → qa pipeline; opens a PR. The 80% path. |
+| `/assess <issues…>` | Triage one or more issues; emits a dashboard + ready-to-paste `run` commands (6-action vocabulary). |
+| `npx sequant run <issues…>` | Headless equivalent of `/fullsolve`; batches run in parallel. Add `-Q` for the quality loop. |
+| `/qa <issue>` | Code review + quality gate; posts findings as issue comments. |
+| `npx sequant merge <issues…>` | Batch integration QA before merging. |
 
-**Taking over an active session.** `sequant run --force <issue>` writes a
-new lock claiming the issue. Add `--signal-other` to also SIGTERM the prior
-PID (same host, alive only). Plain `--force` does not signal — use it when
-you already know the other session is dead.
+### Pipeline internals
 
-**Inspecting locks.**
+`/spec`, `/exec`, `/loop`, `/testgen`, `/test` are the phases that `/fullsolve` and `sequant run` orchestrate for you. You can invoke them directly, but rarely need to.
 
-```bash
-npx sequant locks list                # Show every active lock
-npx sequant locks clear 123           # Clear lock for #123 (refuses fresh)
-npx sequant locks clear 123 --force   # Clear unconditionally
-```
+### Occasional / advanced
 
-**Skill wiring** (`/fullsolve`, `/assess`). The `/fullsolve` skill claims the
-lock at Phase 0.3, releases it at Phase 5.5, AND releases on every halt
-branch (spec failure, exec exhausted, etc.) so an aborted run frees the
-lock immediately. `/assess` probes it read-only and surfaces a dashboard
-warning when any issue is in use. Both use these subcommands directly from
-bash:
+| Command | What it does |
+|---------|--------------|
+| `sequant ready <issue>` | Post-resolve full-weight A+ QA gate; drives to merge-readiness, then stops at the human merge gate (never merges). |
+| `/merger` | Multi-issue merge coordination. |
+| `/improve` | Codebase analysis and improvement discovery. |
+| `/security-review` | Deep security analysis. |
+| `/verify` | CLI/script execution verification. |
+| `/docs` · `/clean` · `/reflect` | Feature docs, repo cleanup, workflow reflection. |
+
+### CLI utilities
 
 ```bash
-npx sequant locks acquire 123 --command="/fullsolve 123" --skip-pid-check
-npx sequant locks release 123                    # idempotent; safe on every error path
-npx sequant locks check   123 --json             # exit 1 when held, prints holder JSON
-npx sequant locks check-batch 100 101 102        # /assess: emits ⚠ lines for held issues only
+npx sequant init              # initialize in project
+npx sequant update            # update skill templates
+npx sequant doctor            # check installation
+npx sequant status            # show version and config
+npx sequant state <cmd>       # manage workflow state (init/rebuild/clean)
+npx sequant locks <cmd>       # inspect/clear per-issue concurrency locks
+npx sequant stats             # local workflow analytics (cohort filter: --label / --since)
+npx sequant dashboard         # real-time workflow dashboard
+npx sequant serve             # expose workflow tools over MCP
 ```
 
-`--skip-pid-check` is required for skill shells: the Node process that runs
-`locks acquire` exits immediately, so its PID is dead before the lock is
-released. With the flag set, stale detection falls back to age-only on the
-holder's own host. The default skill-lock TTL is **6h** (separate from the
-2h cross-host TTL) — long enough to cover virtually every `/fullsolve` run
-including multi-iteration QA loops. Override per-process via
-`SEQUANT_SKILL_LOCK_TTL_MS=<milliseconds>`.
-
-A skill that crashes mid-run leaves at most a 6h orphan; clear it manually
-with `sequant locks clear <issue>` to recover sooner. The skill's explicit
-release calls on every halt branch (see `.claude/skills/fullsolve/SKILL.md`
-Phase 0.3 release contract) mean this corner case should be rare in practice.
+See [Run Command Options](docs/reference/run-command.md), [Merge Command](docs/reference/merge-command.md), [State Command](docs/reference/state-command.md), and [Analytics](docs/reference/analytics.md) for details.
 
-**Read-only commands** (`status`, `merge`, `/assess`) warn when an issue is
-locked but do not block.
+---
 
-**MCP / orchestrator mode.** When the `SEQUANT_ORCHESTRATOR` env var is set
-(in-process or remote MCP-driven runs), all lock operations are no-ops —
-the orchestrator caller is responsible for any coordination.
+## Concurrency
 
-**Caveats.** The lock relies on `open(O_CREAT | O_EXCL)` and is reliable on
-local filesystems. NFS and other network filesystems may not honor those
-semantics; users on networked repos may see false positives. The
-`SEQUANT_LOCKS_DIR` env var overrides the lock directory (used in tests
-and unusual layouts).
+Multi-issue runs are parallel by default, and a per-issue lock (`.sequant/locks/<issue>.lock`) stops two sessions from clobbering the same issue — see [Concurrency & Per-Issue Locks](docs/reference/concurrency.md) for stale recovery, takeover (`--force`), and `sequant locks` subcommands.
 
 ---
 
@@ -328,6 +289,7 @@ See [Customization Guide](docs/guides/customization.md) for all options.
 - [What Is Sequant](docs/concepts/what-is-sequant.md) — Elevator pitch, pipeline diagram, architecture
 - [Workflow Concepts](docs/concepts/workflow-phases.md)
 - [Run Command](docs/reference/run-command.md)
+- [Concurrency & Per-Issue Locks](docs/reference/concurrency.md)
 - [Git Workflows](docs/guides/git-workflows.md)
 - [Customization](docs/guides/customization.md)
 - [Troubleshooting](docs/troubleshooting.md)

package/dist/bin/cli.js

@@ -4,7 +4,7 @@
  *
  * Sequential AI phases with quality gates for any codebase.
  */
-import { Command, InvalidArgumentError } from "commander";
+import { Command, InvalidArgumentError, Option } from "commander";
 import chalk from "chalk";
 import { fileURLToPath } from "url";
 import { dirname, resolve } from "path";
@@ -46,6 +46,7 @@ import { dashboardCommand } from "../src/commands/dashboard.js";
 import { stateInitCommand, stateRebuildCommand, stateCleanCommand, } from "../src/commands/state.js";
 import { syncCommand, areSkillsOutdated } from "../src/commands/sync.js";
 import { mergeCommand } from "../src/commands/merge.js";
+import { readyCommand, } from "../src/commands/ready.js";
 import { conventionsCommand } from "../src/commands/conventions.js";
 import { locksListCommand, locksClearCommand, locksAcquireCommand, locksReleaseCommand, locksCheckCommand, locksCheckBatchCommand, } from "../src/commands/locks.js";
 import { promptCommand } from "../src/commands/prompt.js";
@@ -172,13 +173,18 @@ program
     .option("--no-log", "Disable JSON logging for this run")
     .option("--log-path <path>", "Custom log directory path")
     .option("-Q, --quality-loop", "Enable quality loop with auto-retry")
+    // #705: `-q` is a hidden alias for the quality loop (Commander 14 allows only
+    // one short flag per Option, so it can't live on --quality-loop directly).
+    // `runCommand` ORs `qualityLoopAlias` into `qualityLoop`. `-q` no longer maps
+    // to --quiet, which moved to `-s` to end the `-q`/`-Q` collision.
+    .addOption(new Option("-q, --quality-loop-alias", "Alias for -Q/--quality-loop").hideHelp())
     .option("--max-iterations <n>", "Max iterations for quality loop (default: 3)", parseInt)
     .option("--batch <issues>", 'Group of issues to run together (e.g., --batch "1 2" --batch "3")', (value, prev) => prev.concat([value]), [])
     .option("--smart-tests", "Enable smart test detection (default)")
     .option("--no-smart-tests", "Disable smart test detection")
     .option("--testgen", "Run testgen phase after spec")
     .option("--security-review", "Run security-review phase after spec")
-    .option("-q, --quiet", "Suppress version warnings and non-essential output")
+    .option("-s, --quiet", "Suppress version warnings and non-essential output (heartbeat-only)")
     .option("--chain", "Chain issues: each branches from previous (implies --sequential)")
     .option("--stacked", "Stack PRs: middle PRs target predecessor branch instead of main; first/last target main (implies --chain)")
     .option("--qa-gate", "Wait for QA pass before starting next issue in chain (requires --chain)")
@@ -194,7 +200,12 @@ program
     .option("--isolate-parallel", "Isolate parallel agent groups in separate worktrees (prevents file conflicts)")
     .option("--reflect", "Analyze run results and suggest improvements")
     .option("--agent <name>", 'Agent driver for phase execution (default: "claude-code")')
-    .option("--experimental-tui", "Render live multi-issue dashboard (requires TTY; falls back to linear output when piped)")
+    // #705: the boxed Ink TUI is now the default on a TTY. `--no-tui` opts out to
+    // the line-based phase-matrix renderer; non-TTY / piped output auto-degrades.
+    .option("--no-tui", "Disable the boxed Ink dashboard; use the line-based phase-matrix renderer")
+    // #705: `--experimental-tui` is now a hidden no-op alias (the TUI is the
+    // default) so existing scripts and muscle-memory keep parsing.
+    .addOption(new Option("--experimental-tui").hideHelp())
     .option("--no-relay", "Disable interactive relay (#383); `sequant prompt` cannot reach this run")
     .action(runCommand);
 program
@@ -255,6 +266,18 @@ program
     .option("--json", "Output as JSON")
     .option("-v, --verbose", "Enable verbose output")
     .action(mergeCommand);
+program
+    .command("ready")
+    .description("Post-resolve A+ QA gate — drive an issue to merge-readiness, then stop at the human merge gate (never merges)")
+    .argument("<issue>", "Issue number to drive to readiness")
+    .option("--policy <policy>", "Gate policy: 'ac' (default, stop at ACs met) or 'a-plus' (loop to READY_FOR_MERGE)")
+    .option("--max-iterations <n>", "Max QA passes before halting for human review (default: settings.run.maxIterations)", parseInt)
+    .option("--budget <tokens>", "Token budget; halt cleanly with a 'needs human' message on exhaustion", parseInt)
+    .option("--timeout <seconds>", "Timeout per phase in seconds", parseInt)
+    .option("--no-mcp", "Disable MCP server injection in headless mode")
+    .option("--json", "Output as JSON")
+    .option("-v, --verbose", "Enable verbose output")
+    .action((issue, options) => readyCommand(issue, options));
 program
     .command("conventions")
     .description("View and manage codebase conventions")

package/dist/dashboard/server.js

@@ -346,6 +346,7 @@ function renderIssuesList(issues) {
     const byStatus = {
         in_progress: [],
         waiting_for_qa_gate: [],
+        waiting_for_human_merge: [],
         ready_for_merge: [],
         blocked: [],
         not_started: [],

package/dist/marketplace/external_plugins/sequant/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "sequant",
-  "description": "Structured workflow system for Claude Code - GitHub issue resolution with spec, exec, test, and QA phases",
-  "version": "2.0.1",
+  "description": "AI coding agent orchestrator for Claude Code — resolve GitHub issues end-to-end with isolated git worktrees and quality gates, through spec → exec → qa phases.",
+  "version": "2.6.0",
   "author": {
     "name": "sequant-io",
     "email": "hello@sequant.io"

package/dist/marketplace/external_plugins/sequant/README.md

@@ -1,12 +1,12 @@
 # Sequant
 
-Structured workflow system for Claude Code — GitHub issue resolution with spec, exec, test, and QA phases.
+AI coding agent orchestrator for Claude Code — resolve GitHub issues end-to-end with isolated git worktrees and quality gates, through spec → exec → qa phases.
 
 ## Prerequisites
 
 - **Git** with a GitHub remote
 - **GitHub CLI** (`gh`) authenticated (`gh auth status`)
-- **Node.js 20+** (for MCP server via `npx`)
+- **Node.js 22.12+** (for MCP server via `npx`)
 
 ## Installation
 
@@ -47,7 +47,7 @@ sequant init
 | `/improve` | Codebase analysis and improvement |
 | `/clean` | Repository cleanup |
 | `/security-review` | Deep security analysis |
-| `/release` | Automated release workflow |
+| `/solve` | Generate the recommended workflow for one or more issues |
 | `/merger` | Multi-issue integration and merge |
 | `/setup` | Project initialization for plugin users |
 
@@ -74,10 +74,13 @@ sequant init
 ## Quick Start
 
 ```
+sequant ready        # Boxed pre-flight: which issues are ready to run?
 /assess 123          # Analyze issue, get recommended workflow
 /fullsolve 123       # End-to-end: spec → exec → qa → PR
 ```
 
+See the [`sequant ready` command reference](https://github.com/sequant-io/sequant/blob/main/docs/reference/ready-command.md) for the full pre-flight readiness check.
+
 ## Documentation
 
 - [Getting Started](https://github.com/sequant-io/sequant/tree/main/docs/getting-started)

package/dist/marketplace/external_plugins/sequant/hooks/post-tool.sh

@@ -13,6 +13,17 @@ if [[ "${CLAUDE_HOOKS_DISABLED:-}" == "true" ]]; then
     exit 0
 fi
 
+# === RELAY CHECK (#383) ===
+# Sourced only when SEQUANT_RELAY=true. The check itself is a single env-var
+# comparison when relay is disabled (default), so non-relay runs incur no cost.
+if [[ "${SEQUANT_RELAY:-}" == "true" ]]; then
+    _RELAY_CHECK="$(dirname "${BASH_SOURCE[0]:-$0}")/relay-check.sh"
+    if [[ -f "${_RELAY_CHECK}" ]]; then
+        # shellcheck source=relay-check.sh disable=SC1091
+        source "${_RELAY_CHECK}" || true
+    fi
+fi
+
 # === READ INPUT FROM STDIN ===
 # Claude Code passes tool data as JSON via stdin, not environment variables
 INPUT_JSON=$(cat)
@@ -216,6 +227,60 @@ if [[ "$TOOL_NAME" == "Bash" ]] && echo "$TOOL_INPUT" | grep -qE '(npm run build
     fi
 fi
 
+# === TEST COVERAGE ANALYSIS (P3) ===
+# Opt-in: Set CLAUDE_HOOKS_COVERAGE=true to enable
+# Automatically appends coverage analysis to npm test output
+# Logs which changed files have/don't have corresponding tests
+if [[ "${CLAUDE_HOOKS_COVERAGE:-}" == "true" ]]; then
+    if [[ "$TOOL_NAME" == "Bash" ]] && echo "$TOOL_INPUT" | grep -qE '(npm (test|run test)|bun (test|run test)|yarn (test|run test)|pnpm (test|run test))'; then
+        # Only run if tests passed (don't clutter failure output)
+        if ! echo "$TOOL_OUTPUT" | grep -qE '(FAIL|failed|Error:)'; 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)
+
+            if [[ -n "$changed_files" ]]; then
+                echo "$(date +%H:%M:%S) COVERAGE_ANALYSIS: Checking test coverage for changed files" >> "$QUALITY_LOG"
+
+                files_with_tests=0
+                files_without_tests=0
+                critical_without_tests=""
+
+                while IFS= read -r file; do
+                    [[ -z "$file" ]] && continue
+                    base=$(basename "$file" .ts | sed 's/\.tsx$//')
+
+                    # Check for test file
+                    if find . -name "${base}.test.*" -o -name "${base}.spec.*" 2>/dev/null | grep -q .; then
+                        ((files_with_tests++))
+                    else
+                        ((files_without_tests++))
+                        # Check if critical path
+                        if echo "$file" | grep -qE 'auth|payment|security|server-action|middleware|admin'; then
+                            critical_without_tests="$critical_without_tests $file"
+                        fi
+                    fi
+                done <<< "$changed_files"
+
+                total=$((files_with_tests + files_without_tests))
+
+                # Log coverage summary
+                echo "$(date +%H:%M:%S) COVERAGE: $files_with_tests/$total changed files have tests" >> "$COVERAGE_LOG"
+
+                if [[ -n "$critical_without_tests" ]]; then
+                    echo "$(date +%H:%M:%S) ⚠️ CRITICAL_NO_TESTS:$critical_without_tests" >> "$COVERAGE_LOG"
+                    echo "$(date +%H:%M:%S) CRITICAL_NO_TESTS:$critical_without_tests" >> "$QUALITY_LOG"
+                fi
+
+                if [[ $files_without_tests -gt 0 ]]; then
+                    echo "$(date +%H:%M:%S) COVERAGE_GAP: $files_without_tests files without tests" >> "$QUALITY_LOG"
+                fi
+            fi
+        fi
+    fi
+fi
+
 # === SMART TEST RUNNING (P3) ===
 # Opt-in: Set CLAUDE_HOOKS_SMART_TESTS=true to enable
 # Runs related tests asynchronously after file edits
@@ -300,4 +365,31 @@ if [[ -n "${CLAUDE_HOOKS_WEBHOOK_URL:-}" ]]; then
     fi
 fi
 
+# === POST-MERGE WORKTREE CLEANUP ===
+# Clean up worktree AFTER `gh pr merge` succeeds (not before).
+# Previous approach removed worktree pre-merge, which lost work if merge failed.
+if [[ "$TOOL_NAME" == "Bash" ]] && echo "$TOOL_INPUT" | grep -qE 'gh pr merge'; then
+    # Only clean up if merge succeeded (output contains merge confirmation)
+    if echo "$TOOL_OUTPUT" | grep -qiE '(merged|Merged pull request|Pull request .* merged)'; then
+        PR_NUM=$(echo "$TOOL_INPUT" | grep -oE 'gh pr merge [0-9]+' | grep -oE '[0-9]+')
+
+        if [[ -n "$PR_NUM" ]]; then
+            BRANCH_NAME=$(gh pr view "$PR_NUM" --json headRefName --jq '.headRefName' 2>/dev/null || true)
+
+            if [[ -n "$BRANCH_NAME" ]]; then
+                # Note: worktree line is 2 lines before branch line in porcelain output
+                WORKTREE_PATH=$(git worktree list --porcelain 2>/dev/null | grep -B2 "branch refs/heads/$BRANCH_NAME" | grep "^worktree " | sed 's/^worktree //' || true)
+
+                if [[ -n "$WORKTREE_PATH" && -d "$WORKTREE_PATH" ]]; then
+                    git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
+                    echo "POST-MERGE: Removed worktree $WORKTREE_PATH for branch $BRANCH_NAME" >> "${_LOG_DIR}/claude-hook.log"
+                fi
+
+                # Clean up local branch
+                git branch -D "$BRANCH_NAME" 2>/dev/null || true
+            fi
+        fi
+    fi
+fi
+
 exit 0