sequant 2.1.2 → 2.3.0

package/dist/src/commands/run-display.js

@@ -0,0 +1,150 @@
+/**
+ * Display helpers for `sequant run` — pre-run config block + post-run summary.
+ *
+ * Kept separate from run.ts so the adapter stays thin (see AC-2 of #503).
+ *
+ * As of #618, the post-run summary delegates to the unified RunRenderer when
+ * one is provided. The renderless path (used by --experimental-tui and tests)
+ * falls back to `renderRunSummary` so output stays consistent across modes.
+ */
+import chalk from "chalk";
+import { ui, colors } from "../lib/cli-ui.js";
+import { renderRunSummary } from "../lib/cli-ui/run-renderer.js";
+import { analyzeRun, formatReflection } from "../lib/workflow/run-reflect.js";
+/**
+ * Print pre-run config block.
+ *
+ * Columnar alignment via 15-char label padding. Conditional rows only
+ * appear when non-default, matching the pre-#503 format.
+ */
+export function displayConfig(r) {
+    const pad = (label) => label.padEnd(15);
+    const row = (label, value) => console.log(chalk.gray(`  ${pad(label)}${value}`));
+    row("Stack", r.stack);
+    if (r.autoDetectPhases) {
+        row("Phases", "auto-detect from labels");
+    }
+    else {
+        row("Phases", r.config.phases.join(" → "));
+    }
+    row("Mode", r.config.sequential
+        ? "sequential (stop-on-failure)"
+        : `parallel (concurrency: ${r.config.concurrency})`);
+    if (r.config.qualityLoop) {
+        row("Quality loop", `enabled (max ${r.config.maxIterations} iterations)`);
+    }
+    if (r.mergedOptions.testgen)
+        row("Testgen", "enabled");
+    if (r.config.noSmartTests)
+        row("Smart tests", "disabled");
+    if (r.config.dryRun) {
+        console.log(chalk.yellow(`  !  DRY RUN - no actual execution`));
+    }
+    if (r.logEnabled)
+        row("Logging", "JSON");
+    if (r.stateEnabled)
+        row("State", "enabled");
+    if (r.mergedOptions.force) {
+        console.log(chalk.yellow(`  ${pad("Force")}enabled (bypass state guard)`));
+    }
+    if (r.issueNumbers.length > 0) {
+        row("Issues", r.issueNumbers.map((n) => `#${n}`).join(", "));
+    }
+    if (r.worktreeIsolationEnabled) {
+        console.log(chalk.gray(`  Worktree isolation: enabled`));
+    }
+    if (r.baseBranch) {
+        console.log(chalk.gray(`  Base branch: ${r.baseBranch}`));
+    }
+    if (r.mergedOptions.chain) {
+        console.log(chalk.gray(`  Chain mode: enabled (each issue branches from previous)`));
+    }
+    if (r.mergedOptions.qaGate) {
+        console.log(chalk.gray(`  QA gate: enabled (chain waits for QA pass)`));
+    }
+}
+/**
+ * Convert workflow `IssueResult` to renderer `IssueSummary`.
+ */
+function toIssueSummary(r) {
+    const failedPhase = r.phaseResults.find((p) => !p.success);
+    const summary = {
+        issueNumber: r.issueNumber,
+        success: r.success,
+        durationSeconds: r.durationSeconds,
+        phases: r.phaseResults.map((p) => ({ name: p.phase, success: p.success })),
+        loopTriggered: r.loopTriggered,
+        prNumber: r.prNumber,
+        prUrl: r.prUrl,
+    };
+    if (!r.success) {
+        summary.failureReason =
+            failedPhase?.error ??
+                r.abortReason ??
+                `${failedPhase?.phase ?? "phase"} failed`;
+        if (failedPhase?.verdict) {
+            summary.qaVerdict = String(failedPhase.verdict);
+        }
+        if (failedPhase?.summary?.gaps?.length !== undefined) {
+            summary.unmetCount = failedPhase.summary.gaps.length;
+        }
+    }
+    return summary;
+}
+/**
+ * Print post-run summary: per-issue grid, log path, reflection, tips.
+ *
+ * If a renderer is provided (default path), delegate to its `renderSummary`
+ * so the live zone is torn down cleanly first. Otherwise, fall back to the
+ * shared `renderRunSummary` helper (used by tests and TUI mode).
+ */
+export function displaySummary(result, renderer) {
+    const { results, logPath, config, mergedOptions } = result;
+    if (results.length === 0)
+        return;
+    const issueSummaries = results.map(toIssueSummary);
+    const totalSeconds = results.reduce((sum, r) => sum + (r.durationSeconds ?? 0), 0);
+    if (renderer) {
+        renderer.renderSummary({
+            issues: issueSummaries,
+            totalDurationSeconds: totalSeconds,
+            logPath,
+            dryRun: config.dryRun,
+        });
+    }
+    else {
+        renderRunSummary({
+            issues: issueSummaries,
+            totalDurationSeconds: totalSeconds,
+            logPath,
+            dryRun: config.dryRun,
+        });
+    }
+    if (mergedOptions.reflect && results.length > 0) {
+        const reflection = analyzeRun({
+            results,
+            issueInfoMap: result.issueInfoMap,
+            runLog: result.logWriter?.getRunLog() ?? null,
+            config: { phases: config.phases, qualityLoop: config.qualityLoop },
+        });
+        const reflectionOutput = formatReflection(reflection);
+        if (reflectionOutput) {
+            console.log(reflectionOutput);
+            console.log("");
+        }
+    }
+    const passed = results.filter((r) => r.success).length;
+    if (results.length > 1 && passed > 0 && !config.dryRun) {
+        console.log(colors.muted("  Tip: Verify batch integration before merging:"));
+        console.log(colors.muted("     sequant merge --check"));
+        console.log("");
+    }
+    if (config.dryRun) {
+        console.log(colors.warning("  ℹ️  This was a dry run. Use without --dry-run to execute."));
+        console.log("");
+    }
+    // Reference imported `ui` so existing tests that depend on side-effect-only
+    // imports still pass; explicit retention to keep ui in scope for future
+    // formatting reuse.
+    void ui;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Run progress wiring — keeps run.ts thin (#503 AC-2: <200 LOC).
+ *
+ * Builds the appropriate `onProgress` callback for the run mode:
+ *   - tui   : no callback (the ink dashboard owns its own state)
+ *   - quiet : LivenessHeartbeat-driven (TTY liveness + stall warning)
+ *   - default: RunRenderer-driven (live grid + events log, #618)
+ */
+import type { RunRenderer } from "../lib/cli-ui/run-renderer-types.js";
+import { LivenessHeartbeat } from "../lib/workflow/heartbeat.js";
+import type { ProgressCallback } from "../lib/workflow/types.js";
+export interface ProgressWiring {
+    renderer: RunRenderer | null;
+    heartbeat: LivenessHeartbeat | null;
+    onProgress: ProgressCallback | undefined;
+}
+/**
+ * Construct the renderer + heartbeat + onProgress callback for a run.
+ *
+ * `tuiEnabled` and `quiet` are mutually exclusive with the renderer path.
+ */
+export declare function buildProgressWiring(args: {
+    tuiEnabled: boolean;
+    quiet: boolean;
+    issueNumbers: number[];
+    phaseTimeoutSeconds: number;
+    /** AC-23: when auto-detect mode is on, the renderer shows `Phase: detecting…`
+     *  while spec runs (before the resolved plan is known). */
+    autoDetectPhases?: boolean;
+    /** #624 Item 3 / D2: total allowed quality-loop iterations (from settings). */
+    maxLoopIterations?: number;
+}): ProgressWiring;

package/dist/src/commands/run-progress.js

@@ -0,0 +1,76 @@
+/**
+ * Run progress wiring — keeps run.ts thin (#503 AC-2: <200 LOC).
+ *
+ * Builds the appropriate `onProgress` callback for the run mode:
+ *   - tui   : no callback (the ink dashboard owns its own state)
+ *   - quiet : LivenessHeartbeat-driven (TTY liveness + stall warning)
+ *   - default: RunRenderer-driven (live grid + events log, #618)
+ */
+import { createRunRenderer } from "../lib/cli-ui/run-renderer.js";
+import { LivenessHeartbeat } from "../lib/workflow/heartbeat.js";
+/**
+ * Construct the renderer + heartbeat + onProgress callback for a run.
+ *
+ * `tuiEnabled` and `quiet` are mutually exclusive with the renderer path.
+ */
+export function buildProgressWiring(args) {
+    const { tuiEnabled, quiet, issueNumbers, phaseTimeoutSeconds, autoDetectPhases, maxLoopIterations, } = args;
+    const heartbeat = quiet && !tuiEnabled
+        ? new LivenessHeartbeat({ phaseTimeoutSeconds })
+        : null;
+    // RunRenderer (#618) — single owner of stdout, replaces legacy
+    // PhaseSpinner (#244) + parallel-mode `▸/✔` lines (#458).
+    // AC-26: derive a stall threshold from the configured phase timeout. Half
+    // the timeout is a conservative "expected duration" proxy — phases that
+    // routinely take longer would have failed timeout already.
+    // #624 Item 1: pass terminal rows so the live zone can cap its height.
+    // #624 Item 3 / D2: thread the configured maxLoopIterations through so
+    // all three retry-suffix sites display the correct denominator.
+    const renderer = !tuiEnabled && !quiet
+        ? createRunRenderer({
+            stallThresholdMs: phaseTimeoutSeconds > 0
+                ? (phaseTimeoutSeconds * 1000) / 2
+                : undefined,
+            rows: process.stdout.rows,
+            maxLoopIterations,
+        })
+        : null;
+    if (renderer) {
+        for (const issueNumber of issueNumbers) {
+            renderer.registerIssue({ issueNumber, autoDetect: autoDetectPhases });
+        }
+    }
+    let onProgress;
+    if (renderer) {
+        onProgress = (issue, phase, event, extra) => {
+            // #543: activity events only feed the TUI's nowLine — skip the line renderer.
+            if (event === "activity")
+                return;
+            // #624 Item 3: pass the outer-loop iteration through so the renderer can
+            // render `(attempt N/M)` / `loop N/M`.
+            renderer.onEvent({
+                issue,
+                phase,
+                event,
+                durationSeconds: extra?.durationSeconds,
+                error: extra?.error,
+                iteration: extra?.iteration,
+            });
+        };
+    }
+    else if (heartbeat) {
+        onProgress = (issue, phase, event) => {
+            if (event === "activity")
+                return;
+            if (event === "start")
+                heartbeat.start({
+                    issueNumber: issue,
+                    phase,
+                    startedAt: Date.now(),
+                });
+            else
+                heartbeat.stop({ issueNumber: issue, phase });
+        };
+    }
+    return { renderer, heartbeat, onProgress };
+}

package/dist/src/commands/run.js

@@ -1,14 +1,13 @@
 /** sequant run — Thin CLI adapter that delegates to RunOrchestrator. */
 import chalk from "chalk";
 import { getManifest } from "../lib/manifest.js";
-import { formatElapsedTime } from "../lib/phase-spinner.js";
 import { getSettings } from "../lib/settings.js";
 import { checkVersionCached, getVersionWarning } from "../lib/version-check.js";
-import { ui, colors } from "../lib/cli-ui.js";
-import { formatDuration } from "../lib/workflow/phase-executor.js";
+import { ui } from "../lib/cli-ui.js";
 import { parseBatches } from "../lib/workflow/batch-executor.js";
 import { RunOrchestrator } from "../lib/workflow/run-orchestrator.js";
-import { analyzeRun, formatReflection } from "../lib/workflow/run-reflect.js";
+import { displayConfig, displaySummary } from "./run-display.js";
+import { buildProgressWiring } from "./run-progress.js";
 // Re-export public API for backwards compatibility
 export * from "./run-compat.js";
 /** Parse CLI args → validate → delegate to RunOrchestrator.run() → display summary. */
@@ -32,6 +31,15 @@ export async function runCommand(issues, options) {
         return;
     }
     const settings = await getSettings();
+    // #605: --stacked implies --chain; reject explicit --no-chain combo before
+    // we evaluate any --chain-dependent constraint below.
+    if (options.stacked && options.chain === false) {
+        console.log(chalk.red("❌ --stacked cannot be combined with --no-chain"));
+        return;
+    }
+    if (options.stacked) {
+        options.chain = true;
+    }
     // Validate constraints
     if (options.chain && options.batch?.length) {
         console.log(chalk.red("❌ --chain cannot be used with --batch"));
@@ -51,83 +59,85 @@ export async function runCommand(issues, options) {
         batches = parseBatches(options.batch);
         console.log(chalk.gray(`  Batch mode: ${batches.map((b) => `[${b.join(", ")}]`).join(" → ")}`));
     }
-    console.log(chalk.gray(`  ${"Stack".padEnd(15)}${manifest.stack}`));
-    const onProgress = !options.quiet
-        ? (issue, phase, event, extra) => {
-            if (event === "start")
-                console.log(`  ${colors.running("▸")} #${issue}  ${phase}`);
-            else if (event === "complete") {
-                const dur = extra?.durationSeconds != null
-                    ? `  ${formatElapsedTime(extra.durationSeconds)}`
-                    : "";
-                console.log(`  ${colors.success("✔")} #${issue}  ${phase}${dur}`);
-            }
-            else
-                console.log(`  ${colors.error("✖")} #${issue}  ${phase}`);
-        }
-        : undefined;
-    const result = await RunOrchestrator.run({
+    const init = {
         options,
         settings,
         manifest: {
             stack: manifest.stack,
             packageManager: manifest.packageManager ?? "npm",
         },
-        onProgress,
-    }, issues, batches);
-    displaySummary(result);
-    if (result.exitCode !== 0)
-        process.exit(result.exitCode);
-}
-function displaySummary(result) {
-    const { results, logPath, config, mergedOptions } = result;
-    if (results.length === 0)
-        return;
-    const passed = results.filter((r) => r.success).length;
-    const failed = results.filter((r) => !r.success).length;
-    console.log("\n" + ui.divider());
-    console.log(colors.info("  Summary"));
-    console.log(ui.divider());
-    console.log(`\n  ${colors.success(`${passed} passed`)} ${colors.muted("·")} ${colors.error(`${failed} failed`)}`);
-    for (const r of results) {
-        const status = r.success
-            ? ui.statusIcon("success")
-            : ui.statusIcon("error");
-        const duration = r.durationSeconds
-            ? colors.muted(` (${formatDuration(r.durationSeconds)})`)
-            : "";
-        const phases = r.phaseResults
-            .map((p) => (p.success ? colors.success(p.phase) : colors.error(p.phase)))
-            .join(" → ");
-        const loopInfo = r.loopTriggered ? colors.warning(" [loop]") : "";
-        const prInfo = r.prUrl ? colors.muted(` → PR #${r.prNumber}`) : "";
-        console.log(`  ${status} #${r.issueNumber}: ${phases}${loopInfo}${prInfo}${duration}`);
-    }
-    console.log("");
-    if (logPath) {
-        console.log(colors.muted(`  Log: ${logPath}`));
-        console.log("");
-    }
-    if (mergedOptions.reflect && results.length > 0) {
-        const reflection = analyzeRun({
-            results,
-            issueInfoMap: result.issueInfoMap,
-            runLog: result.logWriter?.getRunLog() ?? null,
-            config: { phases: config.phases, qualityLoop: config.qualityLoop },
-        });
-        const reflectionOutput = formatReflection(reflection);
-        if (reflectionOutput) {
-            console.log(reflectionOutput);
-            console.log("");
+    };
+    const resolved = RunOrchestrator.resolveConfig(init, issues, batches);
+    displayConfig(resolved);
+    const tuiEnabled = Boolean(options.experimentalTui) && Boolean(process.stdout.isTTY);
+    // RunRenderer (#618) + LivenessHeartbeat (#574) wiring lives in
+    // run-progress.ts to keep this adapter under the 200-LOC cap (#503 AC-2).
+    const { renderer, heartbeat, onProgress } = buildProgressWiring({
+        tuiEnabled,
+        quiet: Boolean(options.quiet),
+        issueNumbers: resolved.issueNumbers,
+        phaseTimeoutSeconds: settings.run.timeout,
+        autoDetectPhases: resolved.autoDetectPhases,
+        // #624 Item 3 / D2: route the resolved maxIterations into the renderer so
+        // `(attempt N/M)` and `loop N/M` reflect actual configured limits.
+        maxLoopIterations: resolved.config.maxIterations,
+    });
+    if (tuiEnabled) {
+        const { renderTui } = await import("../ui/tui/index.js");
+        let tuiHandle = null;
+        // Unmount the TUI before ShutdownManager writes its shutdown banner so
+        // the two don't race on stdout / leave the terminal in alt-screen buffer.
+        // `process.once` fires listeners in registration order, so this runs
+        // before ShutdownManager's SIGINT handler registered inside run().
+        const sigintHandler = () => {
+            tuiHandle?.unmount();
+        };
+        process.once("SIGINT", sigintHandler);
+        try {
+            const result = await RunOrchestrator.run({
+                ...init,
+                onProgress,
+                onOrchestratorReady: (orch) => {
+                    tuiHandle = renderTui(orch);
+                },
+            }, issues, batches);
+            if (tuiHandle) {
+                await tuiHandle.done;
+            }
+            displaySummary(result);
+            if (result.exitCode !== 0)
+                process.exit(result.exitCode);
+            return;
+        }
+        finally {
+            process.off("SIGINT", sigintHandler);
         }
     }
-    if (results.length > 1 && passed > 0 && !config.dryRun) {
-        console.log(colors.muted("  Tip: Verify batch integration before merging:"));
-        console.log(colors.muted("     sequant merge --check"));
-        console.log("");
+    // SIGINT handler: clear the live zone before ShutdownManager writes its
+    // cleanup banner so the two don't collide. See AC-29.
+    const sigintHandler = () => {
+        renderer?.dispose();
+    };
+    if (renderer)
+        process.once("SIGINT", sigintHandler);
+    try {
+        const result = await RunOrchestrator.run({ ...init, onProgress }, issues, batches);
+        // Record PR info in renderer state before summary so done rows show PR #s.
+        if (renderer) {
+            for (const r of result.results) {
+                if (r.prNumber && r.prUrl) {
+                    renderer.setPullRequest(r.issueNumber, r.prNumber, r.prUrl);
+                }
+            }
+        }
+        displaySummary(result, renderer);
+        renderer?.dispose();
+        if (result.exitCode !== 0)
+            process.exit(result.exitCode);
     }
-    if (config.dryRun) {
-        console.log(colors.warning("  ℹ️  This was a dry run. Use without --dry-run to execute."));
-        console.log("");
+    finally {
+        heartbeat?.dispose();
+        if (renderer)
+            process.off("SIGINT", sigintHandler);
     }
 }

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

@@ -9,6 +9,8 @@ interface StatsOptions {
     csv?: boolean;
     json?: boolean;
     detailed?: boolean;
+    label?: string;
+    since?: string;
 }
 /**
  * Main stats command

package/dist/src/commands/stats.js

@@ -55,6 +55,37 @@ function parseLogFile(filePath) {
         return null;
     }
 }
+/**
+ * Filter runs by label and/or since date.
+ *
+ * Applied after parseLogFile, before calculateStats / calculateDetailedAnalytics.
+ * Metrics file is bypassed when either filter is set — its schema carries only
+ * issue numbers (not labels), so per-label filtering is impossible there.
+ *
+ * Inclusion rules (AND when both filters set):
+ *   --label <name> — keep a run iff some issue in log.issues carries the label
+ *                    (mirrors the per-issue label scan in calculateDetailedAnalytics)
+ *   --since YYYY-MM-DD — keep a run iff log.startTime >= <since>T00:00:00Z
+ *
+ * Caller is responsible for validating `since` format up-front (see statsCommand).
+ */
+function filterLogs(logs, filters) {
+    const { label, since } = filters;
+    const sinceMs = since !== undefined ? Date.parse(`${since}T00:00:00Z`) : undefined;
+    return logs.filter((log) => {
+        if (label !== undefined) {
+            const hasLabel = log.issues.some((issue) => issue.labels.includes(label));
+            if (!hasLabel)
+                return false;
+        }
+        if (sinceMs !== undefined) {
+            const startMs = Date.parse(log.startTime);
+            if (Number.isNaN(startMs) || startMs < sinceMs)
+                return false;
+        }
+        return true;
+    });
+}
 /**
  * Calculate aggregate statistics from logs
  */
@@ -566,12 +597,51 @@ function displayDetailedAnalytics(detailed) {
         }
     }
 }
+/**
+ * Emit the "no matching runs" empty branch in the active output format.
+ * Reuses the shape of the existing empty-data branches (AC-4).
+ */
+function emitNoMatchingRuns(options) {
+    if (options.json) {
+        console.log(JSON.stringify({ error: "No matching runs", runs: [] }));
+        return;
+    }
+    if (options.csv) {
+        console.log("runId,startTime,duration,issues,passed,failed,phases");
+        return;
+    }
+    console.log(ui.headerBox("SEQUANT ANALYTICS"));
+    console.log(colors.muted("\n  Local data only - no telemetry\n"));
+    console.log(colors.warning("  No matching runs."));
+    console.log("");
+}
 /**
  * Main stats command
  */
 export async function statsCommand(options) {
-    // Try to load local metrics first
-    const metrics = loadMetrics();
+    // Validate --since up-front so an invalid date errors before any output.
+    // Two-stage check: a strict YYYY-MM-DD regex (rejects 2026/01/01, 2026-1-1,
+    // Jan 1 2026 — all of which Date.parse would otherwise accept with engine-
+    // dependent UTC interpretation), then Date.parse for semantic validity
+    // (rejects 2026-13-45 etc.).
+    if (options.since !== undefined) {
+        const SINCE_RE = /^\d{4}-\d{2}-\d{2}$/;
+        const sinceMs = SINCE_RE.test(options.since)
+            ? Date.parse(`${options.since}T00:00:00Z`)
+            : NaN;
+        if (Number.isNaN(sinceMs)) {
+            console.error(colors.error(`Invalid --since date: ${options.since}. Expected YYYY-MM-DD.`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // --label / --since force log-mode: the metrics file has no per-issue labels
+    // (metrics-schema.ts MetricRun.issues is number[]), so filtering is impossible
+    // against metrics. Bypass the metrics-first path entirely when filters are set.
+    const useFilters = options.label !== undefined || options.since !== undefined;
+    const filters = { label: options.label, since: options.since };
+    // Try to load local metrics first (skipped when filters force log-mode)
+    const metrics = useFilters ? null : loadMetrics();
     // If JSON output requested
     if (options.json) {
         if (metrics && metrics.runs.length > 0) {
@@ -611,16 +681,21 @@ export async function statsCommand(options) {
             console.log(JSON.stringify({ error: "No data found", runs: [] }));
             return;
         }
-        const logs = logFiles
+        const allLogs = logFiles
             .map((filename) => {
             const filePath = path.join(logDir, filename);
             return parseLogFile(filePath);
         })
             .filter((log) => log !== null);
-        if (logs.length === 0) {
+        if (allLogs.length === 0) {
             console.log(JSON.stringify({ error: "No valid logs found", runs: [] }));
             return;
         }
+        const logs = useFilters ? filterLogs(allLogs, filters) : allLogs;
+        if (useFilters && logs.length === 0) {
+            emitNoMatchingRuns(options);
+            return;
+        }
         const stats = calculateStats(logs);
         const output = {
             source: "logs",
@@ -646,12 +721,17 @@ export async function statsCommand(options) {
             console.log("runId,startTime,duration,issues,passed,failed,phases");
             return;
         }
-        const logs = logFiles
+        const allLogs = logFiles
             .map((filename) => {
             const filePath = path.join(logDir, filename);
             return parseLogFile(filePath);
         })
             .filter((log) => log !== null);
+        const logs = useFilters ? filterLogs(allLogs, filters) : allLogs;
+        if (useFilters && logs.length === 0) {
+            emitNoMatchingRuns(options);
+            return;
+        }
         console.log(generateCsv(logs));
         return;
     }
@@ -672,16 +752,21 @@ export async function statsCommand(options) {
             console.log("");
             return;
         }
-        const logs = logFiles
+        const allLogs = logFiles
             .map((filename) => {
             const filePath = path.join(logDir, filename);
             return parseLogFile(filePath);
         })
             .filter((log) => log !== null);
-        if (logs.length === 0) {
+        if (allLogs.length === 0) {
             console.log(colors.warning("\n  No valid log files found.\n"));
             return;
         }
+        const logs = useFilters ? filterLogs(allLogs, filters) : allLogs;
+        if (useFilters && logs.length === 0) {
+            emitNoMatchingRuns(options);
+            return;
+        }
         const stats = calculateStats(logs);
         displayStats(stats, logDir);
     }
@@ -689,12 +774,13 @@ export async function statsCommand(options) {
     if (options.detailed) {
         const logDir = resolveLogPath(options.path);
         const logFiles = listLogFiles(logDir);
-        const logs = logFiles
+        const allLogs = logFiles
             .map((filename) => {
             const filePath = path.join(logDir, filename);
             return parseLogFile(filePath);
         })
             .filter((log) => log !== null);
+        const logs = useFilters ? filterLogs(allLogs, filters) : allLogs;
         if (logs.length > 0) {
             const detailed = calculateDetailedAnalytics(logs);
             displayDetailedAnalytics(detailed);