sequant 1.20.2 → 2.0.0

package/dist/src/lib/mcp-config.js

@@ -0,0 +1,172 @@
+/**
+ * MCP client detection and configuration
+ *
+ * Detects installed MCP clients (Claude Desktop, Cursor, VS Code)
+ * and generates appropriate configuration entries for Sequant MCP server.
+ */
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+/** Path to the project-level MCP config file used by Claude Code */
+export const PROJECT_MCP_JSON = ".mcp.json";
+/**
+ * Clients that need an explicit cwd because they don't run from the project directory.
+ */
+const CLIENTS_NEEDING_CWD = new Set([
+    "claude-desktop",
+    "vscode-continue",
+]);
+/**
+ * Sequant MCP server configuration entry.
+ *
+ * @param options.projectDir - Absolute project path (used as cwd for clients that need it)
+ * @param options.clientType - Target client; determines whether cwd/env are included
+ */
+export function getSequantMcpConfig(options) {
+    const config = {
+        command: "npx",
+        args: ["sequant@latest", "serve"],
+    };
+    // Add cwd for clients that don't run from the project directory
+    if (options?.clientType && CLIENTS_NEEDING_CWD.has(options.clientType)) {
+        config.cwd = options.projectDir ?? process.cwd();
+    }
+    // Only include ANTHROPIC_API_KEY for global client configs (not .mcp.json,
+    // which is committed to git and must never contain secrets).
+    if (options?.clientType && process.env.ANTHROPIC_API_KEY) {
+        config.env = { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY };
+    }
+    return config;
+}
+/**
+ * Detect which MCP-compatible clients are installed
+ */
+export function detectMcpClients() {
+    const clients = [];
+    const home = os.homedir();
+    // Claude Desktop
+    const claudeDesktopConfig = process.platform === "darwin"
+        ? path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+        : process.platform === "win32"
+            ? path.join(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json")
+            : path.join(home, ".config", "claude", "claude_desktop_config.json");
+    clients.push({
+        name: "Claude Desktop",
+        clientType: "claude-desktop",
+        configPath: claudeDesktopConfig,
+        exists: fs.existsSync(claudeDesktopConfig),
+    });
+    // Cursor
+    const cursorConfig = path.join(process.cwd(), ".cursor", "mcp.json");
+    clients.push({
+        name: "Cursor",
+        clientType: "cursor",
+        configPath: cursorConfig,
+        exists: fs.existsSync(path.join(process.cwd(), ".cursor")),
+    });
+    // VS Code (Continue extension uses .continue/config.json)
+    const vscodeConfig = path.join(home, ".continue", "config.json");
+    clients.push({
+        name: "VS Code + Continue",
+        clientType: "vscode-continue",
+        configPath: vscodeConfig,
+        exists: fs.existsSync(vscodeConfig),
+    });
+    return clients;
+}
+/**
+ * Add Sequant MCP server to a client's config file.
+ * Returns true if written, false if already configured.
+ */
+export function addSequantToMcpConfig(configPath, clientType) {
+    const sequantConfig = getSequantMcpConfig({
+        projectDir: process.cwd(),
+        clientType,
+    });
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        }
+        catch {
+            // Corrupt or empty file — start fresh
+        }
+    }
+    // Initialize mcpServers if needed (Array.isArray guard: typeof [] === "object")
+    if (!config.mcpServers ||
+        typeof config.mcpServers !== "object" ||
+        Array.isArray(config.mcpServers)) {
+        config.mcpServers = {};
+    }
+    const servers = config.mcpServers;
+    // Check if already configured
+    if (servers.sequant) {
+        return false;
+    }
+    servers.sequant = sequantConfig;
+    // Ensure parent directory exists
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    return true;
+}
+/**
+ * Check whether .mcp.json already has a sequant server entry.
+ */
+export function isSequantInProjectMcpJson(projectDir) {
+    const mcpJsonPath = path.resolve(projectDir ?? ".", PROJECT_MCP_JSON);
+    if (!fs.existsSync(mcpJsonPath))
+        return false;
+    try {
+        const config = JSON.parse(fs.readFileSync(mcpJsonPath, "utf-8"));
+        return !!config?.mcpServers?.sequant;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create or update .mcp.json in the project root for Claude Code.
+ *
+ * - If .mcp.json doesn't exist → create it with the sequant server entry
+ * - If .mcp.json exists with a sequant entry → skip (already configured)
+ * - If .mcp.json exists without a sequant entry → merge it in
+ *
+ * Unlike global client configs, .mcp.json does NOT include cwd or env
+ * because Claude Code runs from the project root.
+ */
+export function createProjectMcpJson(projectDir) {
+    const mcpJsonPath = path.resolve(projectDir ?? ".", PROJECT_MCP_JSON);
+    const sequantConfig = getSequantMcpConfig(); // No clientType → no cwd/env
+    let config = {};
+    let fileExisted = false;
+    if (fs.existsSync(mcpJsonPath)) {
+        fileExisted = true;
+        try {
+            config = JSON.parse(fs.readFileSync(mcpJsonPath, "utf-8"));
+        }
+        catch {
+            // Corrupt or empty file — start fresh
+            config = {};
+        }
+    }
+    // Initialize mcpServers if needed (Array.isArray guard: typeof [] === "object")
+    if (!config.mcpServers ||
+        typeof config.mcpServers !== "object" ||
+        Array.isArray(config.mcpServers)) {
+        config.mcpServers = {};
+    }
+    const servers = config.mcpServers;
+    // Already configured — skip
+    if (servers.sequant) {
+        return { created: false, merged: false, skipped: true };
+    }
+    servers.sequant = sequantConfig;
+    fs.writeFileSync(mcpJsonPath, JSON.stringify(config, null, 2) + "\n");
+    if (fileExisted) {
+        return { created: false, merged: true, skipped: false };
+    }
+    return { created: true, merged: false, skipped: false };
+}

package/dist/src/lib/merge-check/index.js

@@ -8,6 +8,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import { spawnSync } from "child_process";
+import { GitHubProvider } from "../workflow/platforms/github.js";
 import { RunLogSchema, LOG_PATHS, } from "../workflow/run-log-schema.js";
 import { getGitDiffStats } from "../workflow/git-diff-utils.js";
 import { DEFAULT_MIRROR_PAIRS } from "./types.js";
@@ -125,7 +126,9 @@ export function resolveBranches(issueNumbers, repoRoot, runLog) {
                 : [];
         }
         const info = issueInfo.get(issueNumber);
-        const title = info?.title ?? fetchIssueTitle(issueNumber) ?? `Issue #${issueNumber}`;
+        const title = info?.title ??
+            ghProvider.fetchIssueTitleSync(String(issueNumber)) ??
+            `Issue #${issueNumber}`;
         branches.push({
             issueNumber,
             title,
@@ -137,17 +140,8 @@ export function resolveBranches(issueNumbers, repoRoot, runLog) {
     }
     return branches;
 }
-/**
- * Fetch issue title from GitHub via gh CLI.
- * Returns null if gh is not available or the issue doesn't exist.
- */
-function fetchIssueTitle(issueNumber) {
-    const result = spawnSync("gh", ["issue", "view", String(issueNumber), "--json", "title", "--jq", ".title"], { stdio: "pipe", encoding: "utf-8", timeout: 10_000 });
-    if (result.status !== 0 || !result.stdout?.trim()) {
-        return null;
-    }
-    return result.stdout.trim();
-}
+/** Shared GitHubProvider instance for issue title lookups. */
+const ghProvider = new GitHubProvider();
 /**
  * Determine which checks to run based on command options.
  *

package/dist/src/lib/merge-check/types.d.ts

@@ -3,6 +3,7 @@
  *
  * Shared type definitions for batch-level integration QA checks.
  */
+import { z } from "zod";
 /**
  * Information about a feature branch in a batch
  */
@@ -21,13 +22,25 @@ export interface BranchInfo {
     filesModified: string[];
 }
 /**
- * Per-issue verdict from a check
- */
-export type CheckVerdict = "PASS" | "WARN" | "FAIL";
-/**
- * Batch-level verdict
- */
-export type BatchVerdict = "READY" | "NEEDS_ATTENTION" | "BLOCKED";
+ * Per-issue verdict from a check (Zod schema + inferred type)
+ */
+export declare const CHECK_VERDICTS: readonly ["PASS", "WARN", "FAIL"];
+export declare const CheckVerdictSchema: z.ZodEnum<{
+    PASS: "PASS";
+    WARN: "WARN";
+    FAIL: "FAIL";
+}>;
+export type CheckVerdict = z.infer<typeof CheckVerdictSchema>;
+/**
+ * Batch-level verdict (Zod schema + inferred type)
+ */
+export declare const BATCH_VERDICTS: readonly ["READY", "NEEDS_ATTENTION", "BLOCKED"];
+export declare const BatchVerdictSchema: z.ZodEnum<{
+    READY: "READY";
+    NEEDS_ATTENTION: "NEEDS_ATTENTION";
+    BLOCKED: "BLOCKED";
+}>;
+export type BatchVerdict = z.infer<typeof BatchVerdictSchema>;
 /**
  * A single finding from a check
  */

package/dist/src/lib/merge-check/types.js

@@ -3,6 +3,17 @@
  *
  * Shared type definitions for batch-level integration QA checks.
  */
+import { z } from "zod";
+/**
+ * Per-issue verdict from a check (Zod schema + inferred type)
+ */
+export const CHECK_VERDICTS = ["PASS", "WARN", "FAIL"];
+export const CheckVerdictSchema = z.enum(CHECK_VERDICTS);
+/**
+ * Batch-level verdict (Zod schema + inferred type)
+ */
+export const BATCH_VERDICTS = ["READY", "NEEDS_ATTENTION", "BLOCKED"];
+export const BatchVerdictSchema = z.enum(BATCH_VERDICTS);
 /**
  * Default mirror pairs for this project
  */

package/dist/src/lib/phase-signal.d.ts

@@ -3,7 +3,7 @@
  *
  * Provides types for tracking where phase recommendations come from
  * and logic for merging signals with priority:
- * Labels > Solve Comment > Title > Body
+ * Labels > Assess Comment > Title > Body
  *
  * @example
  * ```typescript
@@ -23,7 +23,7 @@ import type { Phase } from "./workflow/types.js";
 /**
  * Source of a phase signal, ordered by priority (highest first)
  */
-export type SignalSource = "label" | "solve" | "title" | "body";
+export type SignalSource = "label" | "assess" | "solve" | "title" | "body";
 /**
  * Priority order for signal sources (higher = takes precedence)
  */
@@ -63,7 +63,7 @@ export interface MergedPhaseResult {
 /**
  * Merge phase signals with priority-based deduplication
  *
- * Priority order: Labels > Solve > Title > Body
+ * Priority order: Labels > Assess > Title > Body
  * When multiple signals suggest the same phase, the highest-priority
  * source wins. Signals can only ADD phases, never remove.
  *

package/dist/src/lib/phase-signal.js

@@ -3,7 +3,7 @@
  *
  * Provides types for tracking where phase recommendations come from
  * and logic for merging signals with priority:
- * Labels > Solve Comment > Title > Body
+ * Labels > Assess Comment > Title > Body
  *
  * @example
  * ```typescript
@@ -24,14 +24,16 @@
  */
 export const SIGNAL_PRIORITY = {
     label: 4, // Highest priority - explicit labels
-    solve: 3, // Solve command analysis
+    assess: 3, // Assess command analysis
+    /** @deprecated Use `assess` instead */
+    solve: 3, // Solve command analysis (backward compat)
     title: 2, // Title keyword detection
     body: 1, // Body pattern detection (lowest)
 };
 /**
  * Merge phase signals with priority-based deduplication
  *
- * Priority order: Labels > Solve > Title > Body
+ * Priority order: Labels > Assess > Title > Body
  * When multiple signals suggest the same phase, the highest-priority
  * source wins. Signals can only ADD phases, never remove.
  *

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

@@ -45,6 +45,17 @@ export interface AgentSettings {
      */
     model: "haiku" | "sonnet" | "opus";
 }
+/**
+ * Aider-specific settings for the aider agent driver.
+ */
+export interface AiderSettings {
+    /** Model to use (e.g., "claude-3-sonnet", "gpt-4o") */
+    model?: string;
+    /** Edit format (e.g., "diff", "whole", "udiff") */
+    editFormat?: string;
+    /** Extra CLI arguments passed to aider */
+    extraArgs?: string[];
+}
 /**
  * Run command settings
  */
@@ -59,6 +70,8 @@ export interface RunSettings {
     timeout: number;
     /** Run issues sequentially by default */
     sequential: boolean;
+    /** Max concurrent issues in parallel mode (default: 3) */
+    concurrency: number;
     /** Enable quality loop by default */
     qualityLoop: boolean;
     /** Max iterations for quality loop */
@@ -95,6 +108,23 @@ export interface RunSettings {
      * Default: 5
      */
     staleBranchThreshold: number;
+    /**
+     * TTL in days for resolved issues on the dashboard.
+     * After this period, resolved issues are auto-pruned on next read.
+     * - Default: 7 (one week)
+     * - 0: Never auto-prune (manual cleanup only)
+     * - -1: Prune immediately (resolved issues never shown)
+     */
+    resolvedIssueTTL: number;
+    /**
+     * Agent driver for phase execution.
+     * Default: "claude-code". Set to "aider" to use Aider CLI.
+     */
+    agent?: string;
+    /**
+     * Aider-specific configuration. Only used when agent is "aider".
+     */
+    aider?: AiderSettings;
 }
 /**
  * Scope assessment threshold configuration
@@ -151,6 +181,17 @@ export interface ScopeAssessmentSettings {
         directorySpread: ScopeThreshold;
     };
 }
+/**
+ * QA skill settings
+ */
+export interface QASettings {
+    /**
+     * Diff size threshold (additions + deletions) for the small-diff fast path.
+     * Diffs below this threshold skip sub-agent spawning and use inline checks.
+     * Default: 100
+     */
+    smallDiffThreshold: number;
+}
 /**
  * Full settings schema
  */
@@ -163,6 +204,8 @@ export interface SequantSettings {
     agents: AgentSettings;
     /** Scope assessment settings */
     scopeAssessment: ScopeAssessmentSettings;
+    /** QA skill settings */
+    qa: QASettings;
 }
 /**
  * Default rotation settings
@@ -186,10 +229,19 @@ export declare const DEFAULT_TRIVIAL_THRESHOLDS: TrivialThresholds;
  * src/lib/scope/types.ts to ensure consistency.
  */
 export declare const DEFAULT_SCOPE_ASSESSMENT_SETTINGS: ScopeAssessmentSettings;
+/**
+ * Default QA settings
+ */
+export declare const DEFAULT_QA_SETTINGS: QASettings;
 /**
  * Default settings
  */
 export declare const DEFAULT_SETTINGS: SequantSettings;
+/**
+ * Validate aider-specific settings.
+ * Throws on invalid types to catch config errors at load time.
+ */
+export declare function validateAiderSettings(aider: unknown): AiderSettings | undefined;
 /**
  * Get the current project settings
  *

package/dist/src/lib/settings.js

@@ -68,6 +68,12 @@ export const DEFAULT_SCOPE_ASSESSMENT_SETTINGS = {
         directorySpread: { yellow: 3, red: 5 },
     },
 };
+/**
+ * Default QA settings
+ */
+export const DEFAULT_QA_SETTINGS = {
+    smallDiffThreshold: 100,
+};
 /**
  * Default settings
  */
@@ -79,6 +85,7 @@ export const DEFAULT_SETTINGS = {
         autoDetectPhases: true,
         timeout: 1800,
         sequential: false,
+        concurrency: 3,
         qualityLoop: false,
         maxIterations: 3,
         smartTests: true,
@@ -86,10 +93,37 @@ export const DEFAULT_SETTINGS = {
         mcp: true, // Enable MCP servers by default in headless mode
         retry: true, // Enable automatic retry with MCP fallback by default
         staleBranchThreshold: 5, // Block QA/test if feature is >5 commits behind main
+        resolvedIssueTTL: 7, // Auto-prune resolved issues after 7 days
     },
     agents: DEFAULT_AGENT_SETTINGS,
     scopeAssessment: DEFAULT_SCOPE_ASSESSMENT_SETTINGS,
+    qa: DEFAULT_QA_SETTINGS,
 };
+/**
+ * Validate aider-specific settings.
+ * Throws on invalid types to catch config errors at load time.
+ */
+export function validateAiderSettings(aider) {
+    if (aider == null)
+        return undefined;
+    if (typeof aider !== "object" || Array.isArray(aider)) {
+        throw new Error("settings.run.aider must be an object");
+    }
+    const obj = aider;
+    if (obj.model !== undefined && typeof obj.model !== "string") {
+        throw new Error("settings.run.aider.model must be a string");
+    }
+    if (obj.editFormat !== undefined && typeof obj.editFormat !== "string") {
+        throw new Error("settings.run.aider.editFormat must be a string");
+    }
+    if (obj.extraArgs !== undefined) {
+        if (!Array.isArray(obj.extraArgs) ||
+            !obj.extraArgs.every((a) => typeof a === "string")) {
+            throw new Error("settings.run.aider.extraArgs must be an array of strings");
+        }
+    }
+    return obj;
+}
 /**
  * Get the current project settings
  *
@@ -102,12 +136,15 @@ export async function getSettings() {
     try {
         const content = await readFile(SETTINGS_PATH);
         const parsed = JSON.parse(content);
+        // Validate aider settings if present
+        const aiderSettings = validateAiderSettings(parsed.run?.aider);
         // Merge with defaults to ensure all fields exist
         return {
             version: parsed.version ?? DEFAULT_SETTINGS.version,
             run: {
                 ...DEFAULT_SETTINGS.run,
                 ...parsed.run,
+                ...(aiderSettings !== undefined ? { aider: aiderSettings } : {}),
             },
             agents: {
                 ...DEFAULT_AGENT_SETTINGS,
@@ -125,6 +162,10 @@ export async function getSettings() {
                     ...parsed.scopeAssessment?.thresholds,
                 },
             },
+            qa: {
+                ...DEFAULT_QA_SETTINGS,
+                ...parsed.qa,
+            },
         };
     }
     catch {

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

@@ -46,7 +46,8 @@ export interface ShutdownManagerOptions {
 export declare class ShutdownManager {
     private cleanupTasks;
     private _isShuttingDown;
-    private abortController;
+    /** Active abort controllers — supports concurrent phase execution (#404) */
+    private abortControllers;
     private forceExitTimeout;
     private output;
     private errorOutput;
@@ -63,14 +64,24 @@ export declare class ShutdownManager {
      */
     get shuttingDown(): boolean;
     /**
-     * Set the abort controller for the current phase
+     * Register an abort controller for a running phase.
      *
-     * When shutdown is triggered, this controller will be aborted
-     * to cancel any in-flight operations.
+     * When shutdown is triggered, ALL registered controllers are aborted,
+     * supporting concurrent phase execution.
+     */
+    addAbortController(controller: AbortController): void;
+    /**
+     * Unregister a specific abort controller after a phase completes.
+     *
+     * Only removes the given controller — others remain active.
+     */
+    removeAbortController(controller: AbortController): void;
+    /**
+     * @deprecated Use addAbortController/removeAbortController for concurrent safety.
      */
     setAbortController(controller: AbortController): void;
     /**
-     * Clear the abort controller (e.g., after phase completes)
+     * @deprecated Use removeAbortController(controller) instead.
      */
     clearAbortController(): void;
     /**

package/dist/src/lib/shutdown.js

@@ -34,7 +34,8 @@ import chalk from "chalk";
 export class ShutdownManager {
     cleanupTasks = [];
     _isShuttingDown = false;
-    abortController = null;
+    /** Active abort controllers — supports concurrent phase execution (#404) */
+    abortControllers = new Set();
     forceExitTimeout;
     output;
     errorOutput;
@@ -67,19 +68,34 @@ export class ShutdownManager {
         return this._isShuttingDown;
     }
     /**
-     * Set the abort controller for the current phase
+     * Register an abort controller for a running phase.
      *
-     * When shutdown is triggered, this controller will be aborted
-     * to cancel any in-flight operations.
+     * When shutdown is triggered, ALL registered controllers are aborted,
+     * supporting concurrent phase execution.
+     */
+    addAbortController(controller) {
+        this.abortControllers.add(controller);
+    }
+    /**
+     * Unregister a specific abort controller after a phase completes.
+     *
+     * Only removes the given controller — others remain active.
+     */
+    removeAbortController(controller) {
+        this.abortControllers.delete(controller);
+    }
+    /**
+     * @deprecated Use addAbortController/removeAbortController for concurrent safety.
      */
     setAbortController(controller) {
-        this.abortController = controller;
+        this.abortControllers.clear();
+        this.abortControllers.add(controller);
     }
     /**
-     * Clear the abort controller (e.g., after phase completes)
+     * @deprecated Use removeAbortController(controller) instead.
      */
     clearAbortController() {
-        this.abortController = null;
+        this.abortControllers.clear();
     }
     /**
      * Register a cleanup task
@@ -123,10 +139,14 @@ export class ShutdownManager {
         }
         this._isShuttingDown = true;
         this.output(chalk.yellow(`\n⚠️  Received ${signal}, shutting down gracefully...`));
-        // Abort in-flight phase immediately
-        if (this.abortController) {
-            this.abortController.abort();
-            this.output(chalk.green("✓ Aborted active phase"));
+        // Abort all in-flight phases immediately
+        if (this.abortControllers.size > 0) {
+            const count = this.abortControllers.size;
+            for (const controller of this.abortControllers) {
+                controller.abort();
+            }
+            this.abortControllers.clear();
+            this.output(chalk.green(`✓ Aborted ${count} active phase${count > 1 ? "s" : ""}`));
         }
         // Set up force exit timeout
         const forceExitTimer = setTimeout(() => {
@@ -160,7 +180,7 @@ export class ShutdownManager {
         process.removeListener("SIGINT", this.sigintHandler);
         process.removeListener("SIGTERM", this.sigtermHandler);
         this.cleanupTasks = [];
-        this.abortController = null;
+        this.abortControllers.clear();
     }
 }
 /**