sequant 2.4.0 → 2.5.0

package/dist/src/commands/ready.js

@@ -0,0 +1,243 @@
+/**
+ * sequant ready <issue> — post-resolve A+ QA gate (#683)
+ *
+ * Runs a full-weight `qa → loop → qa` pipeline against an issue's existing
+ * worktree, reproducing the maintainer's manual fresh-session A+ pass
+ * deterministically, then STOPS at a human merge gate. It NEVER merges.
+ *
+ * Gate policy (flag > settings.ready.policy > "ac"):
+ * - `ac`    (default) — loop until ACs are objectively met; report (not fix)
+ *                        quality gaps and Non-Goal-touching findings.
+ * - `a-plus` (opt-in)  — loop toward READY_FOR_MERGE, auto-fixing quality gaps.
+ *
+ * Terminates in `waiting_for_human_merge` (when ready) or `blocked` (needs
+ * human / no implementation), persists that state, and emits a structured gap
+ * report. See `src/lib/workflow/ready-gate.ts` for the engine.
+ */
+import { ui, colors } from "../lib/cli-ui.js";
+import { getSettings } from "../lib/settings.js";
+import { listWorktrees } from "../lib/workflow/worktree-manager.js";
+import { GitHubProvider } from "../lib/workflow/platforms/github.js";
+import { getStateManager } from "../lib/workflow/state-manager.js";
+import { executePhaseWithRetry } from "../lib/workflow/phase-executor.js";
+import { buildProgressWiring } from "./run-progress.js";
+import { ReadySnapshotAdapter } from "./ready-tui-adapter.js";
+import { runReadyGate, parseNonGoals, } from "../lib/workflow/ready-gate.js";
+/**
+ * Exit code from a ready result.
+ * - 0: ready (awaiting human merge)
+ * - 1: not ready — needs human intervention (budget/iterations/stagnation)
+ * - 2: not ready — no implementation (#534) or hard error
+ */
+export function getReadyExitCode(result) {
+    if (result.ready)
+        return 0;
+    if (result.reason === "NO_IMPLEMENTATION")
+        return 2;
+    return 1;
+}
+/**
+ * Resolve the gate policy: `--policy` flag > settings.ready.policy > "ac".
+ * Invalid flag values fall back to the settings/default value.
+ *
+ * @internal Exported for testing only.
+ */
+export function resolvePolicy(flag, settingsPolicy) {
+    if (flag === "ac" || flag === "a-plus")
+        return flag;
+    return settingsPolicy;
+}
+/**
+ * Locate the worktree path for an issue from `git worktree list`.
+ *
+ * @internal Exported for testing only.
+ */
+export function resolveWorktreePath(issueNumber) {
+    const match = listWorktrees().find((w) => w.issue === issueNumber);
+    return match?.path ?? null;
+}
+export async function readyCommand(issueArg, options) {
+    const issueNumber = parseInt(issueArg, 10);
+    if (isNaN(issueNumber)) {
+        if (options.json) {
+            console.log(JSON.stringify({ error: `Invalid issue: ${issueArg}` }));
+        }
+        else {
+            console.error(ui.errorBox("Invalid issue", `"${issueArg}" is not a number`));
+        }
+        process.exitCode = 2;
+        return;
+    }
+    const settings = await getSettings();
+    const policy = resolvePolicy(options.policy, settings.ready.policy);
+    const maxIterations = typeof options.maxIterations === "number" && options.maxIterations > 0
+        ? options.maxIterations
+        : settings.run.maxIterations;
+    const tokenBudget = typeof options.budget === "number" && options.budget > 0
+        ? options.budget
+        : undefined;
+    const phaseTimeout = typeof options.timeout === "number" && options.timeout > 0
+        ? options.timeout
+        : settings.run.timeout;
+    const mcp = options.mcp !== false;
+    // Resolve the issue's existing worktree (reuses run/state worktree infra).
+    const worktreePath = resolveWorktreePath(issueNumber);
+    if (!worktreePath) {
+        const msg = `No worktree found for issue #${issueNumber}. ` +
+            `Run \`sequant run ${issueNumber}\` first (or create one with ./scripts/new-feature.sh).`;
+        if (options.json) {
+            console.log(JSON.stringify({ error: msg }));
+        }
+        else {
+            console.error(ui.errorBox("No worktree", msg));
+        }
+        process.exitCode = 2;
+        return;
+    }
+    // Parse the issue's Non-Goals so `ac` mode can mark touching findings
+    // report-only. Best-effort: an unavailable body just yields no Non-Goals.
+    const gh = new GitHubProvider();
+    const body = gh.fetchIssueBodySync(String(issueNumber));
+    const nonGoals = body ? parseNonGoals(body) : [];
+    // Live progress UI (non-`--json` only, so no live writes corrupt piped JSON):
+    //   - TTY      → #699: the boxed Ink TUI, driven by a single-issue snapshot
+    //                adapter fed by the gate's `onProgress` (supersedes #697's
+    //                plain renderer on this path).
+    //   - non-TTY  → #697: the plain phase-matrix renderer, which degrades to
+    //                line mode off a TTY. Static-report fallback, unchanged.
+    const useTui = !options.json && Boolean(process.stdout.isTTY);
+    let renderer = null;
+    let heartbeat = null;
+    let onProgress;
+    let adapter = null;
+    let tuiHandle = null;
+    if (!options.json) {
+        console.log(ui.headerBox("SEQUANT READY"));
+        console.log("");
+        console.log(colors.muted(`Issue #${issueNumber} · policy: ${policy} · max iterations: ${maxIterations}` +
+            (tokenBudget
+                ? ` · budget: ${tokenBudget.toLocaleString()} tokens`
+                : "") +
+            `\nWorktree: ${worktreePath}`));
+        console.log(colors.muted("Full-weight QA (pre-flight checks ON). Never merges — stops at the human gate."));
+        console.log("");
+    }
+    if (useTui) {
+        // Build the snapshot adapter and mount the Ink TUI against it. The gate's
+        // `onProgress` events drive the single box; `markDone` (below) flips the
+        // snapshot's `done` flag so the polling `App` unmounts.
+        const title = gh.fetchIssueTitleSync(String(issueNumber)) ?? `Issue #${issueNumber}`;
+        const branch = listWorktrees().find((w) => w.issue === issueNumber)?.branch ?? "";
+        adapter = new ReadySnapshotAdapter({ issueNumber, title, branch });
+        onProgress = adapter.onProgress;
+        const { renderTui } = await import("../ui/tui/index.js");
+        tuiHandle = renderTui(adapter);
+    }
+    else if (!options.json) {
+        // Stream phases as they fire (no `basePhases`): the ready pipeline length
+        // is dynamic (1–N qa/loop passes), so a fixed seed would leave a stuck-
+        // pending `loop` cell when the gate stops after the first qa.
+        ({ renderer, heartbeat, onProgress } = buildProgressWiring({
+            tuiEnabled: false,
+            quiet: false,
+            issueNumbers: [issueNumber],
+            phaseTimeoutSeconds: phaseTimeout,
+            maxLoopIterations: maxIterations,
+        }));
+    }
+    // SIGINT: tear down the live zone (TUI unmount or renderer dispose) before
+    // ShutdownManager writes its cleanup banner so the two don't collide on
+    // stdout (mirror run.ts SIGINT ordering).
+    const sigintHandler = () => {
+        tuiHandle?.unmount();
+        renderer?.dispose();
+    };
+    if (renderer || tuiHandle)
+        process.once("SIGINT", sigintHandler);
+    // Real phase runner: wraps executePhaseWithRetry against the worktree. The
+    // renderer doubles as the PhasePauseHandle (7th arg) so `--verbose` streaming
+    // pauses/resumes the live zone instead of double-rendering (AC-5).
+    const runPhase = (phase, config, wt) => executePhaseWithRetry(issueNumber, phase, config, undefined, wt, undefined, renderer ?? undefined);
+    let result;
+    try {
+        result = await runReadyGate({
+            issueNumber,
+            worktreePath,
+            policy,
+            maxIterations,
+            tokenBudget,
+            nonGoals,
+            phaseTimeout,
+            mcp,
+            verbose: options.verbose,
+            runPhase,
+            onProgress,
+        });
+    }
+    catch (error) {
+        // Tear down the live zone on the error path too — not just the happy path
+        // (Derived AC: cleanup on ALL exit paths). For the TUI, mark done + unmount
+        // so ink restores the terminal before the error box prints.
+        adapter?.markDone(false);
+        tuiHandle?.unmount();
+        renderer?.dispose();
+        heartbeat?.dispose();
+        if (renderer || tuiHandle)
+            process.off("SIGINT", sigintHandler);
+        const message = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            console.log(JSON.stringify({ error: message }));
+        }
+        else {
+            console.error(ui.errorBox("Ready gate failed", message));
+        }
+        process.exitCode = 2;
+        return;
+    }
+    // Persist the terminal state so `sequant status` reflects it (Derived AC).
+    // Best-effort: initialize the issue in state if a prior run didn't track it.
+    try {
+        const stateManager = getStateManager();
+        const existing = await stateManager.getIssueState(issueNumber);
+        if (!existing) {
+            const title = gh.fetchIssueTitleSync(String(issueNumber)) ?? `Issue #${issueNumber}`;
+            await stateManager.initializeIssue(issueNumber, title, {
+                worktree: worktreePath,
+            });
+        }
+        await stateManager.updateIssueStatus(issueNumber, result.issueStatus);
+    }
+    catch {
+        // State persistence is non-fatal — the report is the primary output.
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            issue: result.issueNumber,
+            policy: result.policy,
+            ready: result.ready,
+            reason: result.reason,
+            status: result.issueStatus,
+            iterations: result.iterations,
+            finalVerdict: result.finalVerdict,
+            autoFixed: result.autoFixed,
+            remaining: result.remaining,
+            tokensUsed: result.tokensUsed,
+        }, null, 2));
+    }
+    else {
+        // #699 AC-3 / #697 AC-6: tear the live zone DOWN before printing the report
+        // so the markdown lands in clean scrollback. For the TUI, flip `done` so the
+        // polling App unmounts, await that unmount (which also emits the durable
+        // teardown summary, AC-5), then print the report below it.
+        if (tuiHandle) {
+            adapter?.markDone(result.ready);
+            await tuiHandle.done;
+        }
+        renderer?.dispose();
+        console.log(result.report);
+    }
+    heartbeat?.dispose();
+    if (renderer || tuiHandle)
+        process.off("SIGINT", sigintHandler);
+    process.exitCode = getReadyExitCode(result);
+}

package/dist/src/commands/status.js

@@ -65,6 +65,8 @@ function colorStatus(status, resolvedAt) {
             return chalk.blue(status);
         case "waiting_for_qa_gate":
             return chalk.yellow(status);
+        case "waiting_for_human_merge":
+            return chalk.green(status);
         case "ready_for_merge":
             return chalk.green(status);
         case "merged":
@@ -152,6 +154,7 @@ function displayIssueSummary(issues) {
     const byStatus = {
         in_progress: [],
         waiting_for_qa_gate: [],
+        waiting_for_human_merge: [],
         ready_for_merge: [],
         blocked: [],
         not_started: [],
@@ -165,6 +168,7 @@ function displayIssueSummary(issues) {
     const statusOrder = [
         "in_progress",
         "waiting_for_qa_gate",
+        "waiting_for_human_merge",
         "ready_for_merge",
         "blocked",
         "not_started",

package/dist/src/lib/cli-ui/run-renderer.d.ts

@@ -236,7 +236,13 @@ export declare class TTYRenderer extends BaseRenderer {
     private statusCellLines;
     private runHeader;
     private rollupLine;
-    private drawKeyValueTable;
+    /**
+     * Single-issue layout: indented `label  value` lines, no box drawing. The
+     * label is cyan and padded to `labelW`; continuation lines (multi-line
+     * status cells) align under the value column with a blank label. See
+     * `renderSingleIssueFrame` for why the bordered grid was dropped.
+     */
+    private drawKeyValueLines;
     private drawIssueGrid;
 }
 export interface CreateRendererOptions extends RenderOptions {

package/dist/src/lib/cli-ui/run-renderer.js

@@ -922,21 +922,25 @@ export class TTYRenderer extends BaseRenderer {
         return lines.join("\n");
     }
     renderSingleIssueFrame(cols) {
-        // AC-11: Single-issue runs use a key:value full-grid table.
+        // AC-11: single-issue runs render as indented `label  value` lines — not a
+        // box-drawing grid.
+        //
+        // The grid was the dominant source of `log-update` `eraseLines` stranding
+        // (#647 / #655): a multi-line bordered frame whose top survives in
+        // scrollback when the erase undershoots, leaving a frozen first paint (the
+        // classic "0s elapsed" ghost with no bottom border). Indented labels keep
+        // the same information at a shorter, border-free height that clears
+        // cleanly, and match the repo's move away from box-drawing in human output
+        // (see feedback_llm_hostile_formatting). Multi-issue still uses the grid.
         const state = [...this.issues.values()][0];
         const c = colorize(this.noColor);
         const header = `SEQUANT WORKFLOW · #${state.issueNumber} · ${formatElapsedTime((this.now() - this.runStartedAt) / 1000)} elapsed`;
-        // #647 AC-3: cap at 78 (not 110) so the rendered grid stays narrower than
-        // any standard 80-col terminal even when the reported `cols` is wider than
-        // the actual terminal (e.g. cached `process.stdout.columns`, TTY emulation
-        // layers, `npx` piped stdout). Total drawn width is
-        // `labelWidth + valueWidth + 9` (2 leading spaces + 3 box-drawing
-        // intersection chars + 4 cell-padding spaces); the prior `- 7` formula
-        // additionally produced rows 2 chars wider than `cols`, compounding the
-        // wrap. Both errors removed.
-        const labelWidth = 10;
-        const innerWidth = Math.max(40, Math.min(cols, 78) - labelWidth - 9);
-        const valueWidth = innerWidth;
+        // Label column fits the widest label ("Worktree"); value column is the
+        // remaining width after the 2-space indent + 2-space gap. Capped the same
+        // way the grid was so wide / misreported terminals can't push values past a
+        // standard 80-col reader.
+        const labelWidth = 8;
+        const valueWidth = Math.max(40, Math.min(cols, 100) - labelWidth - 4);
         const rows = [];
         const titleSuffix = state.title ? ` — ${state.title}` : "";
         rows.push([
@@ -953,7 +957,7 @@ export class TTYRenderer extends BaseRenderer {
         const lines = [c.bold(header), ""];
         if (this.banner)
             lines.push(c.yellow(this.banner), "");
-        lines.push(this.drawKeyValueTable(rows, labelWidth, valueWidth));
+        lines.push(this.drawKeyValueLines(rows, labelWidth));
         return lines.join("\n");
     }
     renderMultiIssueFrame(cols) {
@@ -1172,26 +1176,22 @@ export class TTYRenderer extends BaseRenderer {
         return c.dim(`${done} done · ${running} running · ${queued} queued · ${failed} failed`);
     }
     // ---------------- Box drawing ----------------
-    drawKeyValueTable(rows, labelW, valueW) {
+    /**
+     * Single-issue layout: indented `label  value` lines, no box drawing. The
+     * label is cyan and padded to `labelW`; continuation lines (multi-line
+     * status cells) align under the value column with a blank label. See
+     * `renderSingleIssueFrame` for why the bordered grid was dropped.
+     */
+    drawKeyValueLines(rows, labelW) {
         const c = colorize(this.noColor);
-        const dim = c.dim;
-        const total = labelW + valueW + 3;
-        const top = dim("  ┌" + "─".repeat(labelW + 2) + "┬" + "─".repeat(valueW + 2) + "┐");
-        const sep = dim("  ├" + "─".repeat(labelW + 2) + "┼" + "─".repeat(valueW + 2) + "┤");
-        const bottom = dim("  └" + "─".repeat(labelW + 2) + "┴" + "─".repeat(valueW + 2) + "┘");
-        const out = [top];
-        rows.forEach(([label, lines], i) => {
+        const out = [];
+        for (const [label, lines] of rows) {
             const labelPadded = padEndVisible(label, labelW);
             lines.forEach((line, idx) => {
                 const labelCell = idx === 0 ? c.cyan(labelPadded) : " ".repeat(labelW);
-                const valuePadded = padEndVisible(line, valueW);
-                out.push(`  ${dim("│")} ${labelCell} ${dim("│")} ${valuePadded} ${dim("│")}`);
+                out.push(`  ${labelCell}  ${line}`);
             });
-            if (i < rows.length - 1)
-                out.push(sep);
-        });
-        out.push(bottom);
-        void total;
+        }
         return out.join("\n");
     }
     drawIssueGrid(rows, issueW, statusW) {

package/dist/src/lib/settings.d.ts

@@ -235,6 +235,24 @@ export interface QASettings {
      */
     markdownOnlySafeCiPatterns: string[];
 }
+/**
+ * Gate policy for the `sequant ready` post-resolve A+ QA gate (#683).
+ *
+ * - `ac` (default): loop stops once no `AC_NOT_MET` verdict remains (ACs
+ *   objectively met). Remaining quality/polish gaps are documented in the gap
+ *   report but NOT auto-fixed — predictable, scope-respecting behavior for a
+ *   team engineer with a fixed agenda.
+ * - `a-plus` (opt-in): loop continues until `READY_FOR_MERGE`, auto-fixing
+ *   quality gaps along the way — max-quality behavior for a solo maintainer.
+ */
+export type ReadyPolicy = "ac" | "a-plus";
+/**
+ * Settings for the `sequant ready` command (#683).
+ */
+export interface ReadySettings {
+    /** Default gate policy. Overridable per-invocation with `--policy`. */
+    policy: ReadyPolicy;
+}
 /**
  * Full settings schema
  */
@@ -249,6 +267,8 @@ export interface SequantSettings {
     scopeAssessment: ScopeAssessmentSettings;
     /** QA skill settings */
     qa: QASettings;
+    /** `sequant ready` gate settings (#683) */
+    ready: ReadySettings;
 }
 /** Zod schema for RotationSettings */
 export declare const RotationSettingsSchema: z.ZodObject<{
@@ -346,6 +366,13 @@ export declare const QASettingsSchema: z.ZodObject<{
     markdownOnlyCiRelaxed: z.ZodDefault<z.ZodBoolean>;
     markdownOnlySafeCiPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
+/** Zod schema for ReadySettings (#683) */
+export declare const ReadySettingsSchema: z.ZodObject<{
+    policy: z.ZodDefault<z.ZodEnum<{
+        ac: "ac";
+        "a-plus": "a-plus";
+    }>>;
+}, z.core.$strip>;
 /**
  * Zod schema for the full SequantSettings (AC-1, AC-5).
  *
@@ -428,6 +455,12 @@ export declare const SettingsSchema: z.ZodObject<{
         markdownOnlyCiRelaxed: z.ZodDefault<z.ZodBoolean>;
         markdownOnlySafeCiPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
+    ready: z.ZodDefault<z.ZodObject<{
+        policy: z.ZodDefault<z.ZodEnum<{
+            ac: "ac";
+            "a-plus": "a-plus";
+        }>>;
+    }, z.core.$strip>>;
 }, z.core.$loose>;
 /** A single validation warning about an unknown or invalid setting */
 export interface SettingsWarning {
@@ -477,6 +510,7 @@ export declare const DEFAULT_SCOPE_ASSESSMENT_SETTINGS: ScopeAssessmentSettings;
  * Default QA settings
  */
 export declare const DEFAULT_QA_SETTINGS: QASettings;
+export declare const DEFAULT_READY_SETTINGS: ReadySettings;
 /**
  * Default settings
  */

package/dist/src/lib/settings.js

@@ -127,6 +127,10 @@ export const QASettingsSchema = z.object({
         .array(z.string())
         .default(["build (*)", "Plugin Structure Validation"]),
 });
+/** Zod schema for ReadySettings (#683) */
+export const ReadySettingsSchema = z.object({
+    policy: z.enum(["ac", "a-plus"]).default("ac"),
+});
 /**
  * Zod schema for the full SequantSettings (AC-1, AC-5).
  *
@@ -144,6 +148,7 @@ export const SettingsSchema = z
     agents: AgentSettingsSchema.default(() => AgentSettingsSchema.parse({})),
     scopeAssessment: ScopeAssessmentSettingsSchema.default(() => ScopeAssessmentSettingsSchema.parse({})),
     qa: QASettingsSchema.default(() => QASettingsSchema.parse({})),
+    ready: ReadySettingsSchema.default(() => ReadySettingsSchema.parse({})),
 })
     .passthrough();
 /**
@@ -151,7 +156,7 @@ export const SettingsSchema = z
  * Used to detect unknown/misspelled keys and produce warnings.
  */
 const KNOWN_KEYS = {
-    "": new Set(["version", "run", "agents", "scopeAssessment", "qa"]),
+    "": new Set(["version", "run", "agents", "scopeAssessment", "qa", "ready"]),
     run: new Set([
         "logJson",
         "logPath",
@@ -186,6 +191,7 @@ const KNOWN_KEYS = {
         "markdownOnlyCiRelaxed",
         "markdownOnlySafeCiPatterns",
     ]),
+    ready: new Set(["policy"]),
     "run.rotation": new Set(["enabled", "maxSizeMB", "maxFiles"]),
     "run.aider": new Set(["model", "editFormat", "extraArgs"]),
     "scopeAssessment.trivialThresholds": new Set([
@@ -323,6 +329,9 @@ export const DEFAULT_QA_SETTINGS = {
     markdownOnlyCiRelaxed: true,
     markdownOnlySafeCiPatterns: ["build (*)", "Plugin Structure Validation"],
 };
+export const DEFAULT_READY_SETTINGS = {
+    policy: "ac",
+};
 /**
  * Default settings
  */
@@ -348,6 +357,7 @@ export const DEFAULT_SETTINGS = {
     agents: DEFAULT_AGENT_SETTINGS,
     scopeAssessment: DEFAULT_SCOPE_ASSESSMENT_SETTINGS,
     qa: DEFAULT_QA_SETTINGS,
+    ready: DEFAULT_READY_SETTINGS,
 };
 /**
  * Validate aider-specific settings.
@@ -499,6 +509,12 @@ export function generateSettingsJsonc(settings) {
     lines.push(`    "model": ${JSON.stringify(settings.agents.model)},`);
     lines.push(`    // Isolate parallel agent groups in separate worktrees`);
     lines.push(`    "isolateParallel": ${JSON.stringify(settings.agents.isolateParallel)}`);
+    lines.push(`  },`);
+    lines.push("");
+    lines.push(`  // sequant ready — post-resolve A+ QA gate (#683)`);
+    lines.push(`  "ready": {`);
+    lines.push(`    // Gate policy: "ac" (stop at ACs met, report quality gaps) or "a-plus" (loop to READY_FOR_MERGE)`);
+    lines.push(`    "policy": ${JSON.stringify(settings.ready.policy)}`);
     lines.push(`  }`);
     lines.push("}");
     lines.push("");
@@ -646,6 +662,12 @@ Each threshold has \`yellow\` (warning) and \`red\` (split recommended) values:
 | \`markdownOnlyCiRelaxed\` | boolean | \`true\` | When diff touches only \`.md\` files, treat pending CI checks matching \`markdownOnlySafeCiPatterns\` as informational |
 | \`markdownOnlySafeCiPatterns\` | string[] | \`["build (*)", "Plugin Structure Validation"]\` | Glob patterns for CI checks that are safe to ignore when pending on a markdown-only diff |
 
+## \`ready\` — \`sequant ready\` Gate Settings (#683)
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| \`policy\` | enum | \`"ac"\` | Gate policy. \`"ac"\` loops until ACs are objectively met (no \`AC_NOT_MET\`), reporting but not auto-fixing quality gaps. \`"a-plus"\` loops until \`READY_FOR_MERGE\`, auto-fixing quality gaps. Override per-run with \`--policy ac\\|a-plus\`. |
+
 ---
 
 *Unknown keys are preserved but logged as warnings. This allows forward compatibility

package/dist/src/lib/workflow/phase-executor.js

@@ -106,8 +106,16 @@ export function parseQaVerdict(output) {
     // - "**Verdict:** X" (bold label with colon inside)
     // - "**Verdict:** **X**" (bold label and bold value)
     // - "Verdict: X" (plain)
-    // Case insensitive, handles optional markdown formatting
-    const verdictMatch = output.match(/(?:###?\s*)?(?:\*\*)?Verdict:?\*?\*?\s*\*?\*?\s*(READY_FOR_MERGE|AC_MET_BUT_NOT_A_PLUS|AC_NOT_MET|NEEDS_VERIFICATION)\*?\*?/i);
+    // - "Verdict: ✅ X" (emoji-prefixed value — QA agents commonly write this)
+    // The gap between "Verdict:" and the token tolerates any run of
+    // non-alphanumeric characters (emoji, ✅/❌/⚠️, asterisks, whitespace). A
+    // negated ASCII class (not an emoji literal class) keeps this ReDoS-safe and
+    // avoids the no-misleading-character-class lint, matching parseQaSummary's
+    // approach below. Without this, `Verdict: ✅ READY_FOR_MERGE` parsed as null
+    // and a genuine PASS was recorded as "completed without a parseable verdict"
+    // (live repro: `sequant run 687 --phases exec,qa`, 2026-06-01).
+    // Case insensitive, handles optional markdown formatting.
+    const verdictMatch = output.match(/(?:###?\s*)?(?:\*\*)?Verdict:?[^A-Za-z0-9_]*(READY_FOR_MERGE|AC_MET_BUT_NOT_A_PLUS|AC_NOT_MET|NEEDS_VERIFICATION)\*?\*?/i);
     if (!verdictMatch)
         return null;
     // Normalize to uppercase with underscores
@@ -508,6 +516,13 @@ async function executePhase(issueNumber, phase, config, resumeHandle, worktreePa
     // Skills can check these to skip redundant pre-flight checks
     env.SEQUANT_ORCHESTRATOR = "sequant-run";
     env.SEQUANT_PHASE = phase;
+    // #683: force full-weight QA. `sequant ready` sets config.fullQa so its QA
+    // pass runs the standalone branch-freshness / process-state pre-flight checks
+    // even though SEQUANT_ORCHESTRATOR is set unconditionally above. Scoped to the
+    // qa phase — the loop/exec phases don't have a git-trust skip to override.
+    if (config.fullQa && phase === "qa") {
+        env.SEQUANT_FULL_QA = "1";
+    }
     // Propagate issue type for skills to adapt behavior (e.g., lighter QA for docs)
     if (config.issueType) {
         env.SEQUANT_ISSUE_TYPE = config.issueType;

package/dist/src/lib/workflow/platforms/github.d.ts

@@ -105,6 +105,12 @@ export declare class GitHubProvider implements PlatformProvider {
      * Used by merge-check and worktree-discovery.
      */
     fetchIssueTitleSync(issueId: string): string | null;
+    /**
+     * Fetch an issue's raw body markdown. Used by `sequant ready` (#683) to parse
+     * the Non-Goals section for report-only gap classification. Returns null when
+     * gh is unavailable, the issue can't be fetched, or the body is empty.
+     */
+    fetchIssueBodySync(issueId: string): string | null;
     /**
      * Check if the `gh` CLI binary is installed (not auth, just available).
      * Used by upstream/assessment.ts for pre-flight checks.

package/dist/src/lib/workflow/platforms/github.js

@@ -249,6 +249,23 @@ export class GitHubProvider {
             return null;
         }
     }
+    /**
+     * Fetch an issue's raw body markdown. Used by `sequant ready` (#683) to parse
+     * the Non-Goals section for report-only gap classification. Returns null when
+     * gh is unavailable, the issue can't be fetched, or the body is empty.
+     */
+    fetchIssueBodySync(issueId) {
+        try {
+            const result = spawnSync("gh", ["issue", "view", issueId, "--json", "body", "--jq", ".body"], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 10000 });
+            if (result.status !== 0)
+                return null;
+            const body = result.stdout ?? "";
+            return body.trim() ? body : null;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Check if the `gh` CLI binary is installed (not auth, just available).
      * Used by upstream/assessment.ts for pre-flight checks.