sequant 1.12.0 → 1.13.1

package/dist/src/commands/run.js

@@ -20,6 +20,8 @@ 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";
+import { PhaseSpinner } from "../lib/phase-spinner.js";
 /**
  * Slugify a title for branch naming
  */
@@ -30,6 +32,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
  */
@@ -553,7 +582,7 @@ const ISOLATED_PHASES = ["exec", "test", "qa"];
 /**
  * Execute a single phase for an issue using Claude Agent SDK
  */
-async function executePhase(issueNumber, phase, config, sessionId, worktreePath, shutdownManager) {
+async function executePhase(issueNumber, phase, config, sessionId, worktreePath, shutdownManager, spinner) {
     const startTime = Date.now();
     if (config.dryRun) {
         // Dry run - just simulate
@@ -658,7 +687,10 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath,
                     capturedOutput += textContent;
                     // Show streaming output in verbose mode
                     if (config.verbose) {
+                        // Pause spinner during verbose streaming to avoid terminal corruption
+                        spinner?.pause();
                         process.stdout.write(chalk.gray(textContent));
+                        spinner?.resume();
                     }
                 }
             }
@@ -676,6 +708,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 +985,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 +1398,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
@@ -1457,7 +1520,14 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
         else {
             // Run spec first to get recommended workflow
             console.log(chalk.gray(`    Running spec to determine workflow...`));
-            console.log(chalk.gray(`    ⏳ spec...`));
+            // Create spinner for spec phase (1 of estimated 3: spec, exec, qa)
+            const specSpinner = new PhaseSpinner({
+                phase: "spec",
+                phaseIndex: 1,
+                totalPhases: 3, // Estimate; will be refined after spec
+                shutdownManager,
+            });
+            specSpinner.start();
             // Track spec phase start in state
             if (stateManager) {
                 try {
@@ -1470,7 +1540,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
             const specStartTime = new Date();
             // Note: spec runs in main repo (not worktree) for planning
             const specResult = await executePhase(issueNumber, "spec", config, sessionId, worktreePath, // Will be ignored for spec (non-isolated phase)
-            shutdownManager);
+            shutdownManager, specSpinner);
             const specEndTime = new Date();
             if (specResult.sessionId) {
                 sessionId = specResult.sessionId;
@@ -1508,7 +1578,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
                 }
             }
             if (!specResult.success) {
-                console.log(chalk.red(`    ✗ spec: ${specResult.error}`));
+                specSpinner.fail(specResult.error);
                 const durationSeconds = (Date.now() - startTime) / 1000;
                 return {
                     issueNumber,
@@ -1518,10 +1588,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
                     loopTriggered: false,
                 };
             }
-            const duration = specResult.durationSeconds
-                ? ` (${formatDuration(specResult.durationSeconds)})`
-                : "";
-            console.log(chalk.green(`    ✓ spec${duration}`));
+            specSpinner.succeed();
             // Parse recommended workflow from spec output
             const parsedWorkflow = specResult.output
                 ? parseRecommendedWorkflow(specResult.output)
@@ -1575,8 +1642,22 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
             loopTriggered = true;
         }
         let phasesFailed = false;
-        for (const phase of phases) {
-            console.log(chalk.gray(`    ⏳ ${phase}...`));
+        // Calculate total phases for progress indicator
+        // If spec already ran in auto-detect mode, it's counted separately
+        const totalPhases = specAlreadyRan ? phases.length + 1 : phases.length;
+        const phaseIndexOffset = specAlreadyRan ? 1 : 0;
+        for (let phaseIdx = 0; phaseIdx < phases.length; phaseIdx++) {
+            const phase = phases[phaseIdx];
+            const phaseNumber = phaseIdx + 1 + phaseIndexOffset;
+            // Create spinner for this phase
+            const phaseSpinner = new PhaseSpinner({
+                phase,
+                phaseIndex: phaseNumber,
+                totalPhases,
+                shutdownManager,
+                iteration: useQualityLoop ? iteration : undefined,
+            });
+            phaseSpinner.start();
             // Track phase start in state
             if (stateManager) {
                 try {
@@ -1587,7 +1668,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
                 }
             }
             const phaseStartTime = new Date();
-            const result = await executePhase(issueNumber, phase, config, sessionId, worktreePath, shutdownManager);
+            const result = await executePhase(issueNumber, phase, config, sessionId, worktreePath, shutdownManager, phaseSpinner);
             const phaseEndTime = new Date();
             // Capture session ID for subsequent phases
             if (result.sessionId) {
@@ -1609,7 +1690,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
@@ -1627,29 +1712,34 @@ async function runIssueWithLogging(issueNumber, config, logWriter, stateManager,
                 }
             }
             if (result.success) {
-                const duration = result.durationSeconds
-                    ? ` (${formatDuration(result.durationSeconds)})`
-                    : "";
-                console.log(chalk.green(`    ✓ ${phase}${duration}`));
+                phaseSpinner.succeed();
             }
             else {
-                console.log(chalk.red(`    ✗ ${phase}: ${result.error}`));
+                phaseSpinner.fail(result.error);
                 phasesFailed = true;
                 // If quality loop enabled, run loop phase to fix issues
                 if (useQualityLoop && iteration < maxIterations) {
-                    console.log(chalk.yellow(`    Running /loop to fix issues...`));
-                    const loopResult = await executePhase(issueNumber, "loop", config, sessionId, worktreePath, shutdownManager);
+                    // Create spinner for loop phase
+                    const loopSpinner = new PhaseSpinner({
+                        phase: "loop",
+                        phaseIndex: phaseNumber,
+                        totalPhases,
+                        shutdownManager,
+                        iteration,
+                    });
+                    loopSpinner.start();
+                    const loopResult = await executePhase(issueNumber, "loop", config, sessionId, worktreePath, shutdownManager, loopSpinner);
                     phaseResults.push(loopResult);
                     if (loopResult.sessionId) {
                         sessionId = loopResult.sessionId;
                     }
                     if (loopResult.success) {
-                        console.log(chalk.green(`    ✓ loop - retrying phases`));
+                        loopSpinner.succeed();
                         // Continue to next iteration
                         break;
                     }
                     else {
-                        console.log(chalk.red(`    ✗ loop: ${loopResult.error}`));
+                        loopSpinner.fail(loopResult.error);
                     }
                 }
                 // Stop on first failure (if not in quality loop or loop failed)

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/commands/sync.d.ts

@@ -0,0 +1,28 @@
+/**
+ * sequant sync - Fast, non-interactive template sync
+ *
+ * Syncs skills and other templates from the package to the local project.
+ * Designed for plugin users who need to update after upgrading sequant.
+ */
+interface SyncOptions {
+    force?: boolean;
+    quiet?: boolean;
+}
+/**
+ * Get the version of skills currently installed
+ */
+export declare function getSkillsVersion(): Promise<string | null>;
+/**
+ * Check if skills are outdated compared to package version
+ */
+export declare function areSkillsOutdated(): Promise<{
+    outdated: boolean;
+    currentVersion: string | null;
+    packageVersion: string;
+}>;
+export declare function syncCommand(options?: SyncOptions): Promise<void>;
+/**
+ * Check and warn if skills are outdated (for use by other commands)
+ */
+export declare function checkAndWarnSkillsOutdated(): Promise<boolean>;
+export {};