sequant 1.11.0 → 1.13.0

package/dist/src/commands/run.d.ts

@@ -4,7 +4,19 @@
  * Runs the Sequant workflow (/spec → /exec → /qa) for one or more issues
  * using the Claude Agent SDK for proper skill invocation.
  */
-import { Phase } from "../lib/workflow/types.js";
+import { Phase, QaVerdict } from "../lib/workflow/types.js";
+/**
+ * Parse QA verdict from phase output
+ *
+ * Looks for verdict patterns in the QA output:
+ * - "### Verdict: READY_FOR_MERGE"
+ * - "**Verdict:** AC_NOT_MET"
+ * - "Verdict: AC_MET_BUT_NOT_A_PLUS"
+ *
+ * @param output - The captured output from QA phase
+ * @returns The parsed verdict or null if not found
+ */
+export declare function parseQaVerdict(output: string): QaVerdict | null;
 /**
  * List all active worktrees with their branches
  */

package/dist/src/commands/run.js

@@ -20,6 +20,7 @@ import { getMcpServersConfig } from "../lib/system.js";
 import { checkVersionCached, getVersionWarning } from "../lib/version-check.js";
 import { MetricsWriter } from "../lib/workflow/metrics-writer.js";
 import { determineOutcome, } from "../lib/workflow/metrics-schema.js";
+import { ui, colors } from "../lib/cli-ui.js";
 /**
  * Slugify a title for branch naming
  */
@@ -30,6 +31,33 @@ function slugify(title) {
         .replace(/^-+|-+$/g, "")
         .substring(0, 50);
 }
+/**
+ * Parse QA verdict from phase output
+ *
+ * Looks for verdict patterns in the QA output:
+ * - "### Verdict: READY_FOR_MERGE"
+ * - "**Verdict:** AC_NOT_MET"
+ * - "Verdict: AC_MET_BUT_NOT_A_PLUS"
+ *
+ * @param output - The captured output from QA phase
+ * @returns The parsed verdict or null if not found
+ */
+export function parseQaVerdict(output) {
+    if (!output)
+        return null;
+    // Match various verdict formats:
+    // - "### Verdict: X" (markdown header)
+    // - "**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);
+    if (!verdictMatch)
+        return null;
+    // Normalize to uppercase with underscores
+    const verdict = verdictMatch[1].toUpperCase().replace(/-/g, "_");
+    return verdict;
+}
 /**
  * Get the git repository root directory
  */
@@ -676,6 +704,35 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath,
         // Check result status
         if (resultMessage) {
             if (resultMessage.subtype === "success") {
+                // For QA phase, check the verdict to determine actual success
+                // SDK "success" just means the query completed - we need to parse the verdict
+                if (phase === "qa" && capturedOutput) {
+                    const verdict = parseQaVerdict(capturedOutput);
+                    // Only READY_FOR_MERGE and NEEDS_VERIFICATION are considered passing
+                    // NEEDS_VERIFICATION is external verification, not a code quality issue
+                    if (verdict &&
+                        verdict !== "READY_FOR_MERGE" &&
+                        verdict !== "NEEDS_VERIFICATION") {
+                        return {
+                            phase,
+                            success: false,
+                            durationSeconds,
+                            error: `QA verdict: ${verdict}`,
+                            sessionId: resultSessionId,
+                            output: capturedOutput,
+                            verdict, // Include parsed verdict
+                        };
+                    }
+                    // Pass case - include verdict for logging
+                    return {
+                        phase,
+                        success: true,
+                        durationSeconds,
+                        sessionId: resultSessionId,
+                        output: capturedOutput,
+                        verdict: verdict ?? undefined, // Include if found
+                    };
+                }
                 return {
                     phase,
                     success: true,
@@ -924,7 +981,7 @@ function parseBatches(batchArgs) {
  * Main run command
  */
 export async function runCommand(issues, options) {
-    console.log(chalk.blue("\n🌐 Sequant Workflow Execution\n"));
+    console.log(ui.headerBox("SEQUANT WORKFLOW"));
     // Version freshness check (cached, non-blocking, respects --quiet)
     if (!options.quiet) {
         try {
@@ -1337,28 +1394,30 @@ export async function runCommand(issues, options) {
             }
         }
         // Summary
-        console.log(chalk.blue("\n" + "━".repeat(50)));
-        console.log(chalk.blue("  Summary"));
-        console.log(chalk.blue("━".repeat(50)));
-        console.log(chalk.gray(`\n  Results: ${chalk.green(`${passed} passed`)}, ${chalk.red(`${failed} failed`)}`));
+        console.log("\n" + ui.divider());
+        console.log(colors.info("  Summary"));
+        console.log(ui.divider());
+        console.log(colors.muted(`\n  Results: ${colors.success(`${passed} passed`)}, ${colors.error(`${failed} failed`)}`));
         for (const result of results) {
-            const status = result.success ? chalk.green("✓") : chalk.red("✗");
+            const status = result.success
+                ? ui.statusIcon("success")
+                : ui.statusIcon("error");
             const duration = result.durationSeconds
-                ? chalk.gray(` (${formatDuration(result.durationSeconds)})`)
+                ? colors.muted(` (${formatDuration(result.durationSeconds)})`)
                 : "";
             const phases = result.phaseResults
-                .map((p) => (p.success ? chalk.green(p.phase) : chalk.red(p.phase)))
+                .map((p) => p.success ? colors.success(p.phase) : colors.error(p.phase))
                 .join(" → ");
-            const loopInfo = result.loopTriggered ? chalk.yellow(" [loop]") : "";
+            const loopInfo = result.loopTriggered ? colors.warning(" [loop]") : "";
             console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${duration}`);
         }
         console.log("");
         if (logPath) {
-            console.log(chalk.gray(`  📝 Log: ${logPath}`));
+            console.log(colors.muted(`  📝 Log: ${logPath}`));
             console.log("");
         }
         if (config.dryRun) {
-            console.log(chalk.yellow("  ℹ️  This was a dry run. Use without --dry-run to execute."));
+            console.log(colors.warning("  ℹ️  This was a dry run. Use without --dry-run to execute."));
             console.log("");
         }
         // Set exit code if any failed
@@ -1609,7 +1668,11 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
                     ? "success"
                     : result.error?.includes("Timeout")
                         ? "timeout"
-                        : "failure", { error: result.error });
+                        : "failure", {
+                    error: result.error,
+                    // Include verdict for QA phase (AC-6)
+                    verdict: result.verdict,
+                });
                 logWriter.logPhase(phaseLog);
             }
             // Track phase completion in state

package/dist/src/commands/stats.js

@@ -4,10 +4,10 @@
  * Provides success/failure rates, workflow insights, and aggregate statistics.
  * All data is local - no telemetry is ever sent remotely.
  */
-import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { ui, colors } from "../lib/cli-ui.js";
 import { RunLogSchema, LOG_PATHS, } from "../lib/workflow/run-log-schema.js";
 import { MetricsSchema, METRICS_FILE_PATH, } from "../lib/workflow/metrics-schema.js";
 /**
@@ -158,46 +158,57 @@ function generateCsv(logs) {
     return [header, ...csvRows].join("\n");
 }
 /**
- * Display human-readable statistics
+ * Display human-readable statistics with dashboard-style boxes
  */
 function displayStats(stats, logDir) {
-    console.log(chalk.blue("\n📊 Sequant Run Statistics\n"));
-    console.log(chalk.gray(`  Log directory: ${logDir}`));
-    // Overall summary
-    console.log(chalk.blue("\n  Overview"));
-    console.log(chalk.gray(`  ─────────────────────────────────`));
-    console.log(chalk.gray(`  Total runs analyzed: ${stats.totalRuns}`));
-    console.log(chalk.gray(`  Total issues processed: ${stats.totalIssues}`));
-    console.log(chalk.gray(`  Average run duration: ${formatDuration(stats.avgDurationSeconds)}`));
-    // Success/failure rates
-    console.log(chalk.blue("\n  Success/Failure Rates"));
-    console.log(chalk.gray(`  ─────────────────────────────────`));
-    console.log(chalk.green(`  Passed: ${stats.passed} (${stats.successRate.toFixed(1)}%)`));
-    console.log(chalk.red(`  Failed: ${stats.failed} (${stats.failureRate.toFixed(1)}%)`));
+    console.log(ui.headerBox("SEQUANT ANALYTICS"));
+    console.log(colors.muted(`\n  Log directory: ${logDir}`));
+    console.log(colors.muted("  Local data only - no telemetry\n"));
+    // Overview table
+    const overviewData = {
+        "Total Runs": stats.totalRuns,
+        "Issues Processed": stats.totalIssues,
+        "Avg Duration": formatDuration(stats.avgDurationSeconds),
+    };
+    console.log(ui.keyValueTable(overviewData));
+    // Success rates with progress bar
+    console.log(ui.sectionHeader("Success Rates"));
+    const passedBar = ui.progressBar(stats.passed, stats.totalIssues, 12);
+    const failedBar = ui.progressBar(stats.failed, stats.totalIssues, 12);
+    console.log(`  ${colors.success("\u2713 Passed")}     ${stats.passed} (${stats.successRate.toFixed(1)}%)     ${passedBar}`);
+    console.log(`  ${colors.error("\u2717 Failed")}     ${stats.failed} (${stats.failureRate.toFixed(1)}%)     ${failedBar}`);
     if (stats.partial > 0) {
-        console.log(chalk.yellow(`  Partial: ${stats.partial}`));
+        const partialRate = (stats.partial / stats.totalIssues) * 100;
+        const partialBar = ui.progressBar(stats.partial, stats.totalIssues, 12);
+        console.log(`  ${colors.warning("\u26A0 Partial")}    ${stats.partial} (${partialRate.toFixed(1)}%)     ${partialBar}`);
     }
-    // Phase durations
+    // Phase durations table
     if (stats.phaseDurations.size > 0) {
-        console.log(chalk.blue("\n  Average Phase Durations"));
-        console.log(chalk.gray(`  ─────────────────────────────────`));
+        console.log(ui.sectionHeader("Phase Durations"));
         // Sort phases by count (most common first)
         const sortedPhases = [...stats.phaseDurations.entries()].sort((a, b) => b[1].count - a[1].count);
-        for (const [phase, data] of sortedPhases) {
-            const avgFormatted = formatDuration(data.avg);
-            console.log(chalk.gray(`  ${phase.padEnd(10)} ${avgFormatted.padStart(8)} avg (${data.count} runs)`));
-        }
+        const phaseRows = sortedPhases.map(([phase, data]) => [
+            phase,
+            formatDuration(data.avg),
+            data.count,
+        ]);
+        console.log(ui.table(phaseRows, {
+            columns: [
+                { header: "Phase", width: 12 },
+                { header: "Avg Time", width: 12 },
+                { header: "Runs", width: 8 },
+            ],
+        }));
     }
     // Common failures
     if (stats.commonFailures.size > 0) {
-        console.log(chalk.blue("\n  Common Failure Points"));
-        console.log(chalk.gray(`  ─────────────────────────────────`));
+        console.log(ui.sectionHeader("Common Failures"));
         // Sort by frequency
         const sortedFailures = [...stats.commonFailures.entries()]
             .sort((a, b) => b[1] - a[1])
             .slice(0, 5); // Top 5
         for (const [error, count] of sortedFailures) {
-            console.log(chalk.red(`  ${count}x ${error}`));
+            console.log(`  ${colors.error(`${count}x`)} ${error}`);
         }
     }
     console.log("");
@@ -332,39 +343,46 @@ function generateInsights(runs, successRate, avgFilesChanged, avgLinesAdded, cha
     return insights;
 }
 /**
- * Display local metrics analytics
+ * Display local metrics analytics with dashboard-style boxes
  */
 function displayMetricsAnalytics(analytics) {
-    console.log(chalk.blue("\n📊 Sequant Analytics (local data only)\n"));
-    // Overall summary
-    console.log(chalk.gray(`  Runs: ${analytics.totalRuns} total`));
-    console.log(chalk.green(`    Success: ${analytics.successCount} (${analytics.successRate.toFixed(0)}%)`));
+    console.log(ui.headerBox("SEQUANT ANALYTICS"));
+    console.log(colors.muted("\n  Local data only - no telemetry\n"));
+    // Overview with progress bars
+    const total = analytics.successCount + analytics.partialCount + analytics.failedCount;
+    const successBar = ui.progressBar(analytics.successCount, total, 12);
+    const failedBar = ui.progressBar(analytics.failedCount, total, 12);
+    console.log(`  Runs: ${analytics.totalRuns} total\n`);
+    console.log(`  ${colors.success("\u2713 Success")}   ${analytics.successCount} (${analytics.successRate.toFixed(0)}%)    ${successBar}`);
     if (analytics.partialCount > 0) {
-        console.log(chalk.yellow(`    Partial: ${analytics.partialCount}`));
+        const partialRate = (analytics.partialCount / total) * 100;
+        const partialBar = ui.progressBar(analytics.partialCount, total, 12);
+        console.log(`  ${colors.warning("\u26A0 Partial")}   ${analytics.partialCount} (${partialRate.toFixed(0)}%)    ${partialBar}`);
     }
     if (analytics.failedCount > 0) {
-        console.log(chalk.red(`    Failed: ${analytics.failedCount}`));
+        const failedRate = (analytics.failedCount / total) * 100;
+        console.log(`  ${colors.error("\u2717 Failed")}    ${analytics.failedCount} (${failedRate.toFixed(0)}%)    ${failedBar}`);
     }
-    // Averages
-    console.log(chalk.blue("\n  Averages"));
-    console.log(chalk.gray(`  ─────────────────────────────────`));
+    // Averages table
+    console.log(ui.sectionHeader("Averages"));
+    const avgData = {};
     if (analytics.avgTokensPerRun > 0) {
-        console.log(chalk.gray(`  Tokens per run: ${analytics.avgTokensPerRun.toLocaleString()}`));
+        avgData["Tokens/run"] = analytics.avgTokensPerRun.toLocaleString();
     }
-    console.log(chalk.gray(`  Files changed: ${analytics.avgFilesChanged.toFixed(1)}`));
+    avgData["Files changed"] = analytics.avgFilesChanged.toFixed(1);
     if (analytics.avgLinesAdded > 0) {
-        console.log(chalk.gray(`  Lines added: ${analytics.avgLinesAdded.toFixed(0)}`));
+        avgData["Lines added"] = analytics.avgLinesAdded.toFixed(0);
     }
-    console.log(chalk.gray(`  Duration: ${formatDuration(analytics.avgDuration)}`));
+    avgData["Duration"] = formatDuration(analytics.avgDuration);
+    console.log(ui.keyValueTable(avgData));
     // Insights
     if (analytics.insights.length > 0) {
-        console.log(chalk.blue("\n  Insights"));
-        console.log(chalk.gray(`  ─────────────────────────────────`));
+        console.log(ui.sectionHeader("Insights"));
         for (const insight of analytics.insights) {
-            console.log(chalk.gray(`  • ${insight}`));
+            console.log(`  ${colors.accent("\u2022")} ${insight}`);
         }
     }
-    console.log(chalk.gray("\n  Data stored locally in .sequant/metrics.json"));
+    console.log(colors.muted("\n  Data stored locally in .sequant/metrics.json"));
     console.log("");
 }
 /**
@@ -457,9 +475,10 @@ export async function statsCommand(options) {
     const logDir = resolveLogPath(options.path);
     const logFiles = listLogFiles(logDir);
     if (logFiles.length === 0) {
-        console.log(chalk.blue("\n📊 Sequant Analytics (local data only)\n"));
-        console.log(chalk.yellow("  No data found."));
-        console.log(chalk.gray("  Run `npx sequant run <issues>` to collect metrics."));
+        console.log(ui.headerBox("SEQUANT ANALYTICS"));
+        console.log(colors.muted("\n  Local data only - no telemetry\n"));
+        console.log(colors.warning("  No data found."));
+        console.log(colors.muted("  Run `npx sequant run <issues>` to collect metrics."));
         console.log("");
         return;
     }
@@ -470,7 +489,7 @@ export async function statsCommand(options) {
     })
         .filter((log) => log !== null);
     if (logs.length === 0) {
-        console.log(chalk.yellow("\n  No valid log files found.\n"));
+        console.log(colors.warning("\n  No valid log files found.\n"));
         return;
     }
     const stats = calculateStats(logs);

package/dist/src/commands/status.js

@@ -2,6 +2,7 @@
  * sequant status - Show version, configuration, and workflow state
  */
 import chalk from "chalk";
+import { ui, colors } from "../lib/cli-ui.js";
 import { getManifest, getPackageVersion } from "../lib/manifest.js";
 import { fileExists } from "../lib/fs.js";
 import { readdir } from "fs/promises";
@@ -122,7 +123,6 @@ function displayIssueSummary(issues) {
         console.log(chalk.gray("  Run `sequant run <issue>` to start tracking."));
         return;
     }
-    console.log(chalk.bold("\n  Tracked Issues:\n"));
     // Group by status
     const byStatus = {
         in_progress: [],
@@ -136,7 +136,7 @@ function displayIssueSummary(issues) {
     for (const issue of issues) {
         byStatus[issue.status].push(issue);
     }
-    // Display in priority order
+    // Display in priority order using a table
     const statusOrder = [
         "in_progress",
         "waiting_for_qa_gate",
@@ -146,34 +146,51 @@ function displayIssueSummary(issues) {
         "merged",
         "abandoned",
     ];
+    // Build rows for the table
+    const rows = [];
     for (const status of statusOrder) {
         const statusIssues = byStatus[status];
-        if (statusIssues.length === 0)
-            continue;
         for (const issue of statusIssues) {
-            console.log(formatIssueState(issue));
-            console.log("");
+            const title = issue.title.length > 30
+                ? issue.title.substring(0, 27) + "..."
+                : issue.title;
+            rows.push([
+                `#${issue.number}`,
+                title,
+                colorStatus(issue.status),
+                issue.currentPhase || "-",
+            ]);
         }
     }
+    // Display table
+    console.log("\n" +
+        ui.table(rows, {
+            columns: [
+                { header: "Issue", width: 8 },
+                { header: "Title", width: 32 },
+                { header: "Status", width: 20 },
+                { header: "Phase", width: 10 },
+            ],
+        }));
     // Summary counts
     const summary = [
         `Total: ${issues.length}`,
         byStatus.in_progress.length > 0
-            ? chalk.blue(`In Progress: ${byStatus.in_progress.length}`)
+            ? colors.info(`In Progress: ${byStatus.in_progress.length}`)
             : null,
         byStatus.waiting_for_qa_gate.length > 0
-            ? chalk.yellow(`QA Gate: ${byStatus.waiting_for_qa_gate.length}`)
+            ? colors.warning(`QA Gate: ${byStatus.waiting_for_qa_gate.length}`)
             : null,
         byStatus.ready_for_merge.length > 0
-            ? chalk.green(`Ready: ${byStatus.ready_for_merge.length}`)
+            ? colors.success(`Ready: ${byStatus.ready_for_merge.length}`)
             : null,
         byStatus.blocked.length > 0
-            ? chalk.yellow(`Blocked: ${byStatus.blocked.length}`)
+            ? colors.warning(`Blocked: ${byStatus.blocked.length}`)
             : null,
     ]
         .filter(Boolean)
         .join("  ");
-    console.log(chalk.gray(`  ${summary}`));
+    console.log(`\n  ${summary}`);
 }
 export async function statusCommand(options = {}) {
     // Handle --rebuild flag
@@ -191,7 +208,8 @@ export async function statusCommand(options = {}) {
         await displayIssueState(options);
         return;
     }
-    console.log(chalk.bold("\n📊 Sequant Status\n"));
+    console.log(ui.headerBox("SEQUANT STATUS"));
+    console.log();
     // Package version
     console.log(chalk.gray(`Package version: ${getPackageVersion()}`));
     // Check initialization

package/dist/src/index.d.ts

@@ -23,3 +23,9 @@ export { createStateHook, isOrchestrated, getOrchestrationContext, } from "./lib
 export type { StateHook, StateHookOptions } from "./lib/workflow/state-hook.js";
 export { rebuildStateFromLogs, cleanupStaleEntries, } from "./lib/workflow/state-utils.js";
 export type { RebuildOptions, RebuildResult, CleanupOptions, CleanupResult, } from "./lib/workflow/state-utils.js";
+export { analyzeTitleForPhases, analyzeBodyForPhases, analyzeContentForPhases, isTrivialWork, formatContentAnalysis, } from "./lib/content-analyzer.js";
+export type { ContentSignal, ContentAnalysisResult, } from "./lib/content-analyzer.js";
+export { mergePhaseSignals, signalFromLabel, signalsFromLabels, formatMergedPhases, SIGNAL_PRIORITY, } from "./lib/phase-signal.js";
+export type { SignalSource, SignalConfidence, PhaseSignal, MergedPhaseResult, } from "./lib/phase-signal.js";
+export { isSolveComment, findSolveComment, parseSolveWorkflow, solveWorkflowToSignals, solveCoversIssue, } from "./lib/solve-comment-parser.js";
+export type { SolveWorkflowResult, IssueComment, } from "./lib/solve-comment-parser.js";

package/dist/src/index.js

@@ -16,3 +16,7 @@ export { StateManager, getStateManager } from "./lib/workflow/state-manager.js";
 export { createEmptyState, createIssueState, createPhaseState, STATE_FILE_PATH, WORKFLOW_PHASES, } from "./lib/workflow/state-schema.js";
 export { createStateHook, isOrchestrated, getOrchestrationContext, } from "./lib/workflow/state-hook.js";
 export { rebuildStateFromLogs, cleanupStaleEntries, } from "./lib/workflow/state-utils.js";
+// Content analysis exports
+export { analyzeTitleForPhases, analyzeBodyForPhases, analyzeContentForPhases, isTrivialWork, formatContentAnalysis, } from "./lib/content-analyzer.js";
+export { mergePhaseSignals, signalFromLabel, signalsFromLabels, formatMergedPhases, SIGNAL_PRIORITY, } from "./lib/phase-signal.js";
+export { isSolveComment, findSolveComment, parseSolveWorkflow, solveWorkflowToSignals, solveCoversIssue, } from "./lib/solve-comment-parser.js";

package/dist/src/lib/ac-linter.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Acceptance Criteria Linter
+ *
+ * Static analysis of acceptance criteria to flag vague, untestable,
+ * or incomplete requirements before implementation begins.
+ *
+ * @example
+ * ```typescript
+ * import { lintAcceptanceCriteria } from './ac-linter';
+ * import { parseAcceptanceCriteria } from './ac-parser';
+ *
+ * const criteria = parseAcceptanceCriteria(issueBody);
+ * const lintResults = lintAcceptanceCriteria(criteria);
+ *
+ * console.log(formatACLintResults(lintResults));
+ * ```
+ */
+import type { AcceptanceCriterion } from "./workflow/state-schema.js";
+/**
+ * Types of issues that can be flagged in AC
+ */
+export type ACLintIssueType = "vague" | "unmeasurable" | "incomplete" | "open_ended";
+/**
+ * A lint issue found in an acceptance criterion
+ */
+export interface ACLintIssue {
+    /** Type of issue detected */
+    type: ACLintIssueType;
+    /** The matched pattern that triggered this issue */
+    matchedPattern: string;
+    /** Human-readable description of the problem */
+    problem: string;
+    /** Suggested improvement */
+    suggestion: string;
+}
+/**
+ * Lint result for a single acceptance criterion
+ */
+export interface ACLintResult {
+    /** The AC being linted */
+    ac: AcceptanceCriterion;
+    /** Issues found (empty if AC is clear) */
+    issues: ACLintIssue[];
+    /** Whether this AC passed linting (no issues) */
+    passed: boolean;
+}
+/**
+ * Overall lint results for all acceptance criteria
+ */
+export interface ACLintResults {
+    /** Results for each AC */
+    results: ACLintResult[];
+    /** Summary counts */
+    summary: {
+        total: number;
+        passed: number;
+        flagged: number;
+    };
+    /** Whether any issues were found */
+    hasIssues: boolean;
+}
+/**
+ * Pattern definition for detecting issues
+ */
+interface LintPattern {
+    /** Regular expression to match (case-insensitive) */
+    regex: RegExp;
+    /** Type of issue this pattern indicates */
+    type: ACLintIssueType;
+    /** Problem description */
+    problem: string;
+    /** Suggested fix */
+    suggestion: string;
+}
+/**
+ * Lint a single acceptance criterion against all patterns
+ *
+ * @param ac - The acceptance criterion to lint
+ * @param patterns - Optional custom patterns (defaults to DEFAULT_LINT_PATTERNS)
+ * @returns Lint result with any issues found
+ */
+export declare function lintAcceptanceCriterion(ac: AcceptanceCriterion, patterns?: LintPattern[]): ACLintResult;
+/**
+ * Lint all acceptance criteria
+ *
+ * @param criteria - Array of acceptance criteria to lint
+ * @param patterns - Optional custom patterns
+ * @returns Complete lint results with summary
+ */
+export declare function lintAcceptanceCriteria(criteria: AcceptanceCriterion[], patterns?: LintPattern[]): ACLintResults;
+/**
+ * Format lint results as markdown for the spec output
+ *
+ * @param results - Lint results to format
+ * @returns Markdown-formatted output string
+ */
+export declare function formatACLintResults(results: ACLintResults): string;
+/**
+ * Get the default lint patterns
+ *
+ * @returns Copy of the default lint patterns
+ */
+export declare function getDefaultLintPatterns(): LintPattern[];
+/**
+ * Create custom lint patterns from a simplified configuration
+ *
+ * @param config - Array of pattern configurations
+ * @returns Array of LintPattern objects
+ */
+export declare function createLintPatterns(config: Array<{
+    pattern: string;
+    type: ACLintIssueType;
+    problem: string;
+    suggestion: string;
+}>): LintPattern[];
+export {};