sequant 2.3.0 → 2.5.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.3.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.5.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.3.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.5.0",
   "author": {
     "name": "sequant-io",
     "email": "hello@sequant.io"

package/README.md

@@ -1,84 +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.0
+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** — multi-issue runs are concurrent by default with `--concurrency`.
-- **Multi-agent** — `--agent aider` as an alternative backend, with a driver interface for future agents.
-- **GitHub Actions** — label-triggered and comment-triggered CI workflows out of the box.
+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), so a long run is never indistinguishable from a hang.
+- **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 20+
+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).
 
 ---
 
@@ -132,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.
 
 ---
 
@@ -325,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 } from "commander";
+import { Command, InvalidArgumentError } from "commander";
 import chalk from "chalk";
 import { fileURLToPath } from "url";
 import { dirname, resolve } from "path";
@@ -46,11 +46,34 @@ 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";
 import { watchCommand } from "../src/commands/watch.js";
+import { abortCommand } from "../src/commands/abort.js";
 import { getManifest } from "../src/lib/manifest.js";
+import { phaseRegistry } from "../src/lib/workflow/phase-registry.js";
+/**
+ * Validate `--phases` argument against the phase registry.
+ *
+ * Splits a comma-separated phase list, checks each name against
+ * `phaseRegistry`, and exits with a clear error message if any phase
+ * is unknown. Returns the original string unchanged so downstream
+ * `RunOptions.phases` parsing in `config-resolver.ts` is undisturbed.
+ */
+function validatePhasesFlag(value) {
+    const names = value
+        .split(",")
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+    const unknown = names.filter((n) => !phaseRegistry.has(n));
+    if (unknown.length > 0) {
+        const available = phaseRegistry.names().join(", ");
+        throw new InvalidArgumentError(`Unknown phase '${unknown[0]}'. Available: ${available}`);
+    }
+    return value;
+}
 const program = new Command();
 // Handle --no-color before parsing
 if (process.argv.includes("--no-color")) {
@@ -141,7 +164,7 @@ program
     .command("run")
     .description("Execute workflow for GitHub issues using Claude Agent SDK")
     .argument("[issues...]", "Issue numbers to process")
-    .option("--phases <list>", "Phases to run (default: spec,exec,qa)")
+    .option("--phases <list>", "Phases to run (default: spec,exec,qa)", validatePhasesFlag)
     .option("--sequential", "Stop on first issue failure (default: continue)")
     .option("-d, --dry-run", "Preview without execution")
     .option("-v, --verbose", "Verbose output with streaming")
@@ -149,14 +172,14 @@ program
     .option("--log-json", "Enable structured JSON logging (default: true)")
     .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")
+    .option("-Q, --quality-loop", "Enable quality loop with auto-retry")
     .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("--quiet", "Suppress version warnings and non-essential output")
+    .option("-q, --quiet", "Suppress version warnings and non-essential output")
     .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)")
@@ -180,12 +203,14 @@ program
     .description("Send a message into a running headless sequant session (#383)")
     .argument("[args...]", '[<issue>] "<message>"')
     .option("--type <type>", "Message type: query (default), directive, abort", "query")
+    .option("--wait <seconds>", "Block until a reply arrives or the timeout elapses (#645, Gap 4)", parseInt)
     .option("--json", "Output as JSON")
     .action((args, options) => {
     return promptCommand({
         args,
         options: {
             type: options.type,
+            waitSeconds: typeof options.wait === "number" ? options.wait : undefined,
             json: Boolean(options.json),
         },
     });
@@ -201,6 +226,24 @@ program
         options: { json: Boolean(options.json) },
     });
 });
+program
+    .command("abort")
+    .description("Out-of-band abort: signal a running sequant session directly (#645)")
+    .argument("[issue]", "Issue number (auto-resolved when a single run is active)")
+    .option("--force", "Skip the SIGINT grace period; SIGTERM immediately")
+    .option("--grace <seconds>", "Seconds to wait after SIGINT before escalating (default: 10)", parseInt)
+    .option("--json", "Output as JSON")
+    .action((issueArg, options) => {
+    const args = issueArg === undefined ? [] : [issueArg];
+    return abortCommand({
+        args,
+        options: {
+            force: Boolean(options.force),
+            graceSeconds: typeof options.grace === "number" ? options.grace : undefined,
+            json: Boolean(options.json),
+        },
+    });
+});
 program
     .command("merge")
     .description("Batch-level integration QA — verify feature branches before merging")
@@ -213,6 +256,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.5.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)