sequant 2.11.0 → 2.13.0

package/dist/src/lib/workflow/run-log-schema.d.ts

@@ -129,6 +129,50 @@ export declare const ErrorContextSchema: z.ZodObject<{
     isRetryable: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ErrorContext = z.infer<typeof ErrorContextSchema>;
+/**
+ * Finite taxonomy for a single gap finding surfaced by `/qa` (#937).
+ *
+ * Replaces the lossy prose-scrape gap channel (`parseListSection` against
+ * `**Issues:**`/`**Gaps**` headers, which misses AC-table NOT_MET rows, §6d
+ * Adversarial Re-Read findings, and §5 Risk Assessment). `evidence` is
+ * required so a finding can't be speculative — see #608's 0%-action-rate
+ * result for open-ended "what might we be missing" findings.
+ */
+export declare const GapCategorySchema: z.ZodEnum<{
+    requirement_gap: "requirement_gap";
+    dependency_gap: "dependency_gap";
+    test_gap: "test_gap";
+    repository_gap: "repository_gap";
+    risk_gap: "risk_gap";
+    execution_gap: "execution_gap";
+}>;
+export type GapCategory = z.infer<typeof GapCategorySchema>;
+export declare const GapActionSchema: z.ZodEnum<{
+    fix_now: "fix_now";
+    document: "document";
+    pause_for_human: "pause_for_human";
+}>;
+export type GapAction = z.infer<typeof GapActionSchema>;
+export declare const GapFindingSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        requirement_gap: "requirement_gap";
+        dependency_gap: "dependency_gap";
+        test_gap: "test_gap";
+        repository_gap: "repository_gap";
+        risk_gap: "risk_gap";
+        execution_gap: "execution_gap";
+    }>;
+    evidence: z.ZodString;
+    description: z.ZodString;
+    recommendedAction: z.ZodEnum<{
+        fix_now: "fix_now";
+        document: "document";
+        pause_for_human: "pause_for_human";
+    }>;
+    affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nonGoal: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type GapFinding = z.infer<typeof GapFindingSchema>;
 /**
  * Condensed QA verdict summary for structured log output (#434).
  *
@@ -141,6 +185,25 @@ export declare const QaSummarySchema: z.ZodObject<{
     acTotal: z.ZodNumber;
     gaps: z.ZodArray<z.ZodString>;
     suggestions: z.ZodArray<z.ZodString>;
+    findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        category: z.ZodEnum<{
+            requirement_gap: "requirement_gap";
+            dependency_gap: "dependency_gap";
+            test_gap: "test_gap";
+            repository_gap: "repository_gap";
+            risk_gap: "risk_gap";
+            execution_gap: "execution_gap";
+        }>;
+        evidence: z.ZodString;
+        description: z.ZodString;
+        recommendedAction: z.ZodEnum<{
+            fix_now: "fix_now";
+            document: "document";
+            pause_for_human: "pause_for_human";
+        }>;
+        affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        nonGoal: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type QaSummary = z.infer<typeof QaSummarySchema>;
 /**
@@ -175,6 +238,25 @@ export declare const PhaseLogSchema: z.ZodObject<{
         acTotal: z.ZodNumber;
         gaps: z.ZodArray<z.ZodString>;
         suggestions: z.ZodArray<z.ZodString>;
+        findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            category: z.ZodEnum<{
+                requirement_gap: "requirement_gap";
+                dependency_gap: "dependency_gap";
+                test_gap: "test_gap";
+                repository_gap: "repository_gap";
+                risk_gap: "risk_gap";
+                execution_gap: "execution_gap";
+            }>;
+            evidence: z.ZodString;
+            description: z.ZodString;
+            recommendedAction: z.ZodEnum<{
+                fix_now: "fix_now";
+                document: "document";
+                pause_for_human: "pause_for_human";
+            }>;
+            affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            nonGoal: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     commitHash: z.ZodOptional<z.ZodString>;
     fileDiffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -255,6 +337,25 @@ export declare const IssueLogSchema: z.ZodObject<{
             acTotal: z.ZodNumber;
             gaps: z.ZodArray<z.ZodString>;
             suggestions: z.ZodArray<z.ZodString>;
+            findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                category: z.ZodEnum<{
+                    requirement_gap: "requirement_gap";
+                    dependency_gap: "dependency_gap";
+                    test_gap: "test_gap";
+                    repository_gap: "repository_gap";
+                    risk_gap: "risk_gap";
+                    execution_gap: "execution_gap";
+                }>;
+                evidence: z.ZodString;
+                description: z.ZodString;
+                recommendedAction: z.ZodEnum<{
+                    fix_now: "fix_now";
+                    document: "document";
+                    pause_for_human: "pause_for_human";
+                }>;
+                affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                nonGoal: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>;
         commitHash: z.ZodOptional<z.ZodString>;
         fileDiffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -390,6 +491,25 @@ export declare const RunLogSchema: z.ZodObject<{
                 acTotal: z.ZodNumber;
                 gaps: z.ZodArray<z.ZodString>;
                 suggestions: z.ZodArray<z.ZodString>;
+                findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    category: z.ZodEnum<{
+                        requirement_gap: "requirement_gap";
+                        dependency_gap: "dependency_gap";
+                        test_gap: "test_gap";
+                        repository_gap: "repository_gap";
+                        risk_gap: "risk_gap";
+                        execution_gap: "execution_gap";
+                    }>;
+                    evidence: z.ZodString;
+                    description: z.ZodString;
+                    recommendedAction: z.ZodEnum<{
+                        fix_now: "fix_now";
+                        document: "document";
+                        pause_for_human: "pause_for_human";
+                    }>;
+                    affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    nonGoal: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>>;
             }, z.core.$strip>>;
             commitHash: z.ZodOptional<z.ZodString>;
             fileDiffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/dist/src/lib/workflow/run-log-schema.js

@@ -129,6 +129,39 @@ export const ErrorContextSchema = z.object({
     /** Whether this error type is retryable (AC-9) */
     isRetryable: z.boolean().optional(),
 });
+/**
+ * Finite taxonomy for a single gap finding surfaced by `/qa` (#937).
+ *
+ * Replaces the lossy prose-scrape gap channel (`parseListSection` against
+ * `**Issues:**`/`**Gaps**` headers, which misses AC-table NOT_MET rows, §6d
+ * Adversarial Re-Read findings, and §5 Risk Assessment). `evidence` is
+ * required so a finding can't be speculative — see #608's 0%-action-rate
+ * result for open-ended "what might we be missing" findings.
+ */
+export const GapCategorySchema = z.enum([
+    "requirement_gap",
+    "dependency_gap",
+    "test_gap",
+    "repository_gap",
+    "risk_gap",
+    "execution_gap",
+]);
+export const GapActionSchema = z.enum([
+    "fix_now",
+    "document",
+    "pause_for_human",
+]);
+export const GapFindingSchema = z.object({
+    category: GapCategorySchema,
+    /** Concrete observation grounding the finding — never speculation. */
+    evidence: z.string().min(1),
+    description: z.string().min(1),
+    recommendedAction: GapActionSchema,
+    /** ACs this finding relates to, e.g. ["AC-3"]. */
+    affectedAcs: z.array(z.string()).optional(),
+    /** True when the finding overlaps one of the issue's Non-Goals. */
+    nonGoal: z.boolean().optional(),
+});
 /**
  * Condensed QA verdict summary for structured log output (#434).
  *
@@ -145,6 +178,13 @@ export const QaSummarySchema = z.object({
     gaps: z.array(z.string()),
     /** List of improvement suggestions from QA */
     suggestions: z.array(z.string()),
+    /**
+     * Structured gap findings parsed from the `SEQUANT_QA_GAPS` marker (#937).
+     * Present only when the marker was found and validated; `gaps` above
+     * always carries the union of marker + prose descriptions (dedupe'd) so
+     * marker-unaware consumers never regress.
+     */
+    findings: z.array(GapFindingSchema).optional(),
 });
 /**
  * Log entry for a single phase execution

package/dist/src/lib/workflow/run-orchestrator.d.ts

@@ -16,6 +16,7 @@ import type { LockFile } from "../locks/index.js";
 import { type ChainResumePlan } from "./chain-resume.js";
 import { WorkflowEventEmitter } from "./event-emitter.js";
 import type { SequantSettings } from "../settings.js";
+import { type PhasePolicy } from "./config-resolver.js";
 /**
  * Build the stack-manifest line emitted into PR bodies under --stacked.
  *
@@ -172,6 +173,23 @@ export interface RunResult {
      */
     wallClockDurationSeconds: number;
 }
+/**
+ * Merge per-phase `resolvedModel` from execution results into the static
+ * phasePolicies map before it is written to metrics (#975 AC-4).
+ *
+ * `config.phasePolicies` carries the model alias resolved at config time (e.g.
+ * `"sonnet"`). The concrete model ID only becomes known after execution, from
+ * the driver's `modelUsage` map. This function enriches each phase entry with
+ * that runtime-observed value so benchmark comparisons across roster changes
+ * (#916/#944) see the actual model dispatched, not just the alias.
+ *
+ * `requestedModel` (the pre-resolution role string, e.g. `"role:fast"`) flows
+ * through from `config.phasePolicies` unchanged — it is already set by
+ * `resolvePhasePolicies` for role references and absent for raw strings.
+ *
+ * @internal Exported for testing only.
+ */
+export declare function enrichPhasePoliciesFromResults(phasePolicies: Record<string, PhasePolicy> | undefined, results: IssueResult[]): Record<string, PhasePolicy> | undefined;
 /**
  * CLI-free workflow execution engine.
  *

package/dist/src/lib/workflow/run-orchestrator.js

@@ -82,7 +82,7 @@ import { MetricsWriter } from "./metrics-writer.js";
 import { WorkflowEventEmitter } from "./event-emitter.js";
 import { determineOutcome } from "./metrics-schema.js";
 import { getTokenUsageForRun } from "./token-utils.js";
-import { resolveRunOptions, buildExecutionConfig } from "./config-resolver.js";
+import { resolveRunOptions, buildExecutionConfig, } from "./config-resolver.js";
 import { pipelineHasFailed } from "./status-derivation.js";
 /**
  * Build the stack-manifest line emitted into PR bodies under --stacked.
@@ -96,6 +96,40 @@ export function buildStackManifest(issueNumbers, currentIndex) {
     const parts = issueNumbers.map((n, i) => i === currentIndex ? `#${n} (this)` : `#${n}`);
     return `Part of stack: ${parts.join(" → ")}`;
 }
+// ── Metrics helpers ─────────────────────────────────────────────────────────
+/**
+ * Merge per-phase `resolvedModel` from execution results into the static
+ * phasePolicies map before it is written to metrics (#975 AC-4).
+ *
+ * `config.phasePolicies` carries the model alias resolved at config time (e.g.
+ * `"sonnet"`). The concrete model ID only becomes known after execution, from
+ * the driver's `modelUsage` map. This function enriches each phase entry with
+ * that runtime-observed value so benchmark comparisons across roster changes
+ * (#916/#944) see the actual model dispatched, not just the alias.
+ *
+ * `requestedModel` (the pre-resolution role string, e.g. `"role:fast"`) flows
+ * through from `config.phasePolicies` unchanged — it is already set by
+ * `resolvePhasePolicies` for role references and absent for raw strings.
+ *
+ * @internal Exported for testing only.
+ */
+export function enrichPhasePoliciesFromResults(phasePolicies, results) {
+    const resolvedByPhase = new Map();
+    for (const result of results) {
+        for (const pr of result.phaseResults) {
+            if (pr.resolvedModel) {
+                resolvedByPhase.set(pr.phase, pr.resolvedModel);
+            }
+        }
+    }
+    if (resolvedByPhase.size === 0)
+        return phasePolicies;
+    const enriched = { ...(phasePolicies ?? {}) };
+    for (const [phase, resolvedModel] of resolvedByPhase.entries()) {
+        enriched[phase] = { ...enriched[phase], resolvedModel };
+    }
+    return enriched;
+}
 // ── Orchestrator ────────────────────────────────────────────────────────────
 /**
  * CLI-free workflow execution engine.
@@ -1239,7 +1273,9 @@ export class RunOrchestrator {
             flags: cliFlags,
             failureCategory,
             // #914: resolved per-phase model/effort, when any phase had one.
-            phasePolicies: config.phasePolicies,
+            // #975: enriched with resolvedModel from execution (modelUsage) and
+            // requestedModel already flows through from resolvePhasePolicies.
+            phasePolicies: enrichPhasePoliciesFromResults(config.phasePolicies, results),
             // #915: escalated tiers, when any phase execution escalated.
             effortEscalations,
             metrics: {

package/dist/src/lib/workflow/state-cleanup.d.ts

@@ -58,7 +58,7 @@ export interface ReconcileOptions {
 export interface ReconcileResult {
     /** Whether reconciliation was successful */
     success: boolean;
-    /** Issues advanced to `merged` (from `ready_for_merge`, `in_progress`, or `waiting_for_qa_gate`) */
+    /** Issues advanced to `merged` (from `ready_for_merge`, `in_progress`, `waiting_for_qa_gate`, `waiting_for_human_merge`, or `awaiting_verification`) */
     advanced: number[];
     /** Issues checked but not yet merged (status unchanged) */
     stillPending: number[];
@@ -68,9 +68,9 @@ export interface ReconcileResult {
 /**
  * Lightweight state reconciliation at run start
  *
- * Checks issues in `ready_for_merge`, `in_progress`, or `waiting_for_qa_gate`
- * state and advances them to `merged` if their PRs are merged or their branches
- * are in main.
+ * Checks issues in `ready_for_merge`, `in_progress`, `waiting_for_qa_gate`,
+ * `waiting_for_human_merge`, or `awaiting_verification` state and advances
+ * them to `merged` if their PRs are merged or their branches are in main.
  *
  * Including `in_progress` covers the case where a PR was merged outside
  * this sequant session (separate process, `gh pr merge`, web UI) — without

package/dist/src/lib/workflow/state-cleanup.js

@@ -188,9 +188,9 @@ export async function cleanupStaleEntries(options = {}) {
 /**
  * Lightweight state reconciliation at run start
  *
- * Checks issues in `ready_for_merge`, `in_progress`, or `waiting_for_qa_gate`
- * state and advances them to `merged` if their PRs are merged or their branches
- * are in main.
+ * Checks issues in `ready_for_merge`, `in_progress`, `waiting_for_qa_gate`,
+ * `waiting_for_human_merge`, or `awaiting_verification` state and advances
+ * them to `merged` if their PRs are merged or their branches are in main.
  *
  * Including `in_progress` covers the case where a PR was merged outside
  * this sequant session (separate process, `gh pr merge`, web UI) — without
@@ -227,14 +227,18 @@ export async function reconcileStateAtStartup(options = {}) {
         // waiting_for_human_merge covers #817's `--ready-gate` terminal: a gated
         // issue never reaches ready_for_merge, so without it a gated issue whose PR
         // a human then merged stayed here forever and never advanced to merged
-        // (#837). Note this list is deliberately WIDER than `isCompletedIssueStatus`
+        // (#837). awaiting_verification covers the same shape for #972: the issue
+        // has an open PR pending human verification, and the human may verify and
+        // merge it directly instead of re-running qa first.
+        // Note this list is deliberately WIDER than `isCompletedIssueStatus`
         // — it asks "might this have a merged PR?", not "is this done?", which is
         // why in_progress belongs here but not there.
         for (const [issueNumStr, issueState] of Object.entries(state.issues)) {
             if (issueState.status !== "ready_for_merge" &&
                 issueState.status !== "in_progress" &&
                 issueState.status !== "waiting_for_qa_gate" &&
-                issueState.status !== "waiting_for_human_merge") {
+                issueState.status !== "waiting_for_human_merge" &&
+                issueState.status !== "awaiting_verification") {
                 continue;
             }
             const issueNum = parseInt(issueNumStr, 10);

package/dist/src/lib/workflow/state-schema.d.ts

@@ -47,6 +47,7 @@ export declare const IssueStatusSchema: z.ZodEnum<{
     not_started: "not_started";
     waiting_for_qa_gate: "waiting_for_qa_gate";
     waiting_for_human_merge: "waiting_for_human_merge";
+    awaiting_verification: "awaiting_verification";
     ready_for_merge: "ready_for_merge";
     blocked: "blocked";
     abandoned: "abandoned";
@@ -72,6 +73,8 @@ export declare const PhaseMarkerSchema: z.ZodObject<{
     pr: z.ZodOptional<z.ZodNumber>;
     error: z.ZodOptional<z.ZodString>;
     commitSHA: z.ZodOptional<z.ZodString>;
+    requestedModel: z.ZodOptional<z.ZodString>;
+    resolvedModel: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type PhaseMarker = z.infer<typeof PhaseMarkerSchema>;
 /**
@@ -149,6 +152,7 @@ export declare const AcceptanceCriterionSchema: z.ZodObject<{
     }>;
     verifiedAt: z.ZodOptional<z.ZodString>;
     notes: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type AcceptanceCriterion = z.infer<typeof AcceptanceCriterionSchema>;
 /**
@@ -172,6 +176,7 @@ export declare const AcceptanceCriteriaSchema: z.ZodObject<{
         }>;
         verifiedAt: z.ZodOptional<z.ZodString>;
         notes: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     extractedAt: z.ZodString;
     summary: z.ZodObject<{
@@ -233,6 +238,7 @@ export declare const IssueStateSchema: z.ZodObject<{
         not_started: "not_started";
         waiting_for_qa_gate: "waiting_for_qa_gate";
         waiting_for_human_merge: "waiting_for_human_merge";
+        awaiting_verification: "awaiting_verification";
         ready_for_merge: "ready_for_merge";
         blocked: "blocked";
         abandoned: "abandoned";
@@ -281,6 +287,7 @@ export declare const IssueStateSchema: z.ZodObject<{
             }>;
             verifiedAt: z.ZodOptional<z.ZodString>;
             notes: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         extractedAt: z.ZodString;
         summary: z.ZodObject<{
@@ -382,6 +389,7 @@ export declare const WorkflowStateSchema: z.ZodObject<{
             not_started: "not_started";
             waiting_for_qa_gate: "waiting_for_qa_gate";
             waiting_for_human_merge: "waiting_for_human_merge";
+            awaiting_verification: "awaiting_verification";
             ready_for_merge: "ready_for_merge";
             blocked: "blocked";
             abandoned: "abandoned";
@@ -430,6 +438,7 @@ export declare const WorkflowStateSchema: z.ZodObject<{
                 }>;
                 verifiedAt: z.ZodOptional<z.ZodString>;
                 notes: z.ZodOptional<z.ZodString>;
+                evidence: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
             extractedAt: z.ZodString;
             summary: z.ZodObject<{
@@ -538,7 +547,7 @@ export declare function createPhaseState(status?: PhaseStatus): PhaseState;
 /**
  * Create acceptance criterion
  */
-export declare function createAcceptanceCriterion(id: string, description: string, verificationMethod?: ACVerificationMethod): AcceptanceCriterion;
+export declare function createAcceptanceCriterion(id: string, description: string, verificationMethod?: ACVerificationMethod, evidence?: string): AcceptanceCriterion;
 /**
  * Create acceptance criteria tracking structure
  */

package/dist/src/lib/workflow/state-schema.js

@@ -47,6 +47,7 @@ export const IssueStatusSchema = z.enum([
     "in_progress", // Actively being worked on
     "waiting_for_qa_gate", // QA completed, waiting for gate approval in chain mode
     "waiting_for_human_merge", // `sequant ready` (#683) finished its A+ gate; awaiting human merge decision (never auto-merges)
+    "awaiting_verification", // QA returned NEEDS_VERIFICATION; human must execute ACs before QA re-run (#972)
     "ready_for_merge", // All phases passed, PR ready for review
     "merged", // PR merged, work complete
     "blocked", // Waiting on external input or dependency
@@ -72,6 +73,10 @@ export const PhaseMarkerSchema = z.object({
     error: z.string().optional(),
     /** Git HEAD SHA at time of phase completion (used for incremental QA) */
     commitSHA: z.string().optional(),
+    /** Role string or raw model string as configured for this phase (#975). */
+    requestedModel: z.string().optional(),
+    /** Concrete model ID from `modelUsage` after phase execution (#975). */
+    resolvedModel: z.string().optional(),
 });
 /**
  * Individual phase state within an issue
@@ -149,6 +154,12 @@ export const AcceptanceCriterionSchema = z.object({
     verifiedAt: z.string().datetime().optional(),
     /** Additional notes about verification */
     notes: z.string().optional(),
+    /**
+     * Explicit `Evidence:` clause declared on the AC line (#938). When present,
+     * this is what verificationMethod was resolved from instead of keyword
+     * inference — see `resolveVerificationMethod` in ac-parser.ts.
+     */
+    evidence: z.string().optional(),
 });
 /**
  * Acceptance criteria tracking for an issue
@@ -369,12 +380,13 @@ export function createPhaseState(status = "pending") {
 /**
  * Create acceptance criterion
  */
-export function createAcceptanceCriterion(id, description, verificationMethod = "manual") {
+export function createAcceptanceCriterion(id, description, verificationMethod = "manual", evidence) {
     return {
         id,
         description,
         verificationMethod,
         status: "pending",
+        ...(evidence !== undefined ? { evidence } : {}),
     };
 }
 /**

package/dist/src/lib/workflow/types.d.ts

@@ -83,6 +83,15 @@ export interface ExecutionConfig {
     dryRun: boolean;
     /** Enable MCP servers in headless mode (true by default, false if --no-mcp flag used) */
     mcp: boolean;
+    /**
+     * Claude Desktop MCP server names explicitly opted in via
+     * `settings.run.mcpAllowlist` (#936). Both `ExecutionConfig` producers
+     * (`buildExecutionConfig`, `ready-gate.ts`'s `buildPhaseConfig`) read
+     * this from settings the same way, so it cannot drift between them the
+     * way #833's `phaseTimeout` once did. `phase-executor.ts` forwards it
+     * verbatim onto `AgentExecutionConfig.mcpAllowlist`.
+     */
+    mcpAllowlist?: string[];
     /**
      * Enable automatic retry with MCP fallback.
      * When true (default), failed phases are retried with MCP disabled.
@@ -278,6 +287,12 @@ export interface PhaseResult {
         base: string;
         escalated: string;
     };
+    /**
+     * Concrete model ID from the SDK `modelUsage` map for this phase execution
+     * (#975). First key of `modelUsage` — records the actual model dispatched,
+     * distinct from the configured alias. Used to populate metrics `phasePolicies`.
+     */
+    resolvedModel?: string;
 }
 /**
  * Result of executing all phases for an issue
@@ -705,4 +720,9 @@ export interface IssueExecutionContext {
      * around verbose Claude streaming.
      */
     phasePauseHandle?: PhasePauseHandle;
+    /**
+     * @internal Test seam for the #964 qa-verdict comment post. Defaults to a
+     * real `GitHubProvider().postComment` when unset.
+     */
+    postComment?: (issueNumber: number, body: string) => Promise<void>;
 }

package/dist/src/mcp/tools/run.js

@@ -390,6 +390,12 @@ const runToolInputSchema = {
         .boolean()
         .optional()
         .describe("Enable auto-retry on QA failure"),
+    force: z
+        .boolean()
+        .optional()
+        .describe("Re-run even if the issue is already in a completed state such as " +
+        "ready_for_merge (mirrors CLI --force). Not needed after a " +
+        "NEEDS_VERIFICATION verdict: awaiting_verification re-runs freely."),
     agent: z
         .string()
         .optional()
@@ -410,7 +416,7 @@ export function registerRunTool(server) {
             openWorldHint: true,
         },
         inputSchema: runToolInputSchema,
-    }, (async ({ issues, phases, qualityLoop, agent, }, extra) => {
+    }, (async ({ issues, phases, qualityLoop, force, agent, }, extra) => {
         if (!issues || issues.length === 0) {
             return {
                 content: [
@@ -435,6 +441,9 @@ export function registerRunTool(server) {
         if (qualityLoop) {
             args.push("--quality-loop");
         }
+        if (force) {
+            args.push("--force");
+        }
         if (agent) {
             args.push("--agent", agent);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sequant",
-  "version": "2.11.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.",
+  "version": "2.13.0",
+  "description": "AI coding agent orchestrator that proves its work — GitHub issues to merge-ready PRs with every acceptance criterion verified, isolated git worktrees, quality gates, an MCP server, and a human merge gate. Works with Claude Code or Aider.",
   "type": "module",
   "bin": {
     "sequant": "dist/bin/cli.js"
@@ -31,6 +31,7 @@
     "typecheck:scripts": "tsc --noEmit -p tsconfig.scripts.json",
     "lint:skill-calls": "npx tsx scripts/lint-skill-calls.ts",
     "lint:skill-gates": "npx tsx scripts/lint-skill-gates.ts",
+    "lint:constitution-dod": "npx tsx scripts/check-constitution-dod.ts",
     "lint:skill-sync": "npx tsx scripts/check-skill-sync.ts",
     "prepare:marketplace": "npx tsx scripts/prepare-marketplace.ts",
     "validate:marketplace": "npx tsx scripts/prepare-marketplace.ts --validate-only",
@@ -91,17 +92,17 @@
     }
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.142",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.242",
     "@hono/node-server": "^2.0.0",
     "boxen": "^8.0.1",
-    "chalk": "^5.3.0",
+    "chalk": "^6.0.0",
     "chokidar": "^5.0.0",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.3",
     "diff": "^9.0.0",
-    "hono": "^4.12.1",
+    "hono": "^4.13.4",
     "ink": "^7.0.1",
-    "inquirer": "^14.0.1",
+    "inquirer": "^14.1.0",
     "log-update": "^7.0.1",
     "open": "^11.0.0",
     "ora": "^9.3.0",
@@ -114,16 +115,16 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/inquirer": "^9.0.7",
-    "@types/node": "^26.0.1",
+    "@types/node": "^26.3.0",
     "@types/react": "^19.2.14",
-    "@typescript-eslint/eslint-plugin": "^8.58.0",
-    "@typescript-eslint/parser": "^8.58.0",
-    "eslint": "^10.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.68.0",
+    "@typescript-eslint/parser": "^8.68.0",
+    "eslint": "^10.9.1",
     "globals": "^17.0.0",
     "ink-testing-library": "^4.0.0",
     "tsx": "^4.19.2",
     "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.0",
-    "vitest": "^4.1.0"
+    "typescript-eslint": "^8.68.0",
+    "vitest": "^4.1.11"
   }
 }