sequant 2.2.0 → 2.4.0

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

@@ -2,7 +2,12 @@
  * 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 type { RunRenderer } from "../lib/cli-ui/run-renderer-types.js";
 import type { ResolvedRun, RunResult } from "../lib/workflow/run-orchestrator.js";
 /**
  * Print pre-run config block.
@@ -12,6 +17,10 @@ import type { ResolvedRun, RunResult } from "../lib/workflow/run-orchestrator.js
  */
 export declare function displayConfig(r: ResolvedRun): void;
 /**
- * Print post-run summary: per-issue status, log path, reflection, tips.
+ * 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 declare function displaySummary(result: RunResult): void;
+export declare function displaySummary(result: RunResult, renderer?: RunRenderer | null): void;

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

@@ -2,10 +2,14 @@
  * 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 { formatDuration } from "../lib/workflow/phase-executor.js";
+import { renderRunSummary } from "../lib/cli-ui/run-renderer.js";
 import { analyzeRun, formatReflection } from "../lib/workflow/run-reflect.js";
 /**
  * Print pre-run config block.
@@ -21,7 +25,7 @@ export function displayConfig(r) {
         row("Phases", "auto-detect from labels");
     }
     else {
-        row("Phases", r.config.phases.join(" \u2192 "));
+        row("Phases", r.config.phases.join(" → "));
     }
     row("Mode", r.config.sequential
         ? "sequential (stop-on-failure)"
@@ -60,36 +64,61 @@ export function displayConfig(r) {
     }
 }
 /**
- * Print post-run summary: per-issue status, log path, reflection, tips.
+ * 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) {
+export function displaySummary(result, renderer) {
     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("");
+    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({
@@ -104,6 +133,7 @@ export function displaySummary(result) {
             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"));
@@ -113,4 +143,8 @@ export function displaySummary(result) {
         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,42 @@
+/**
+ * 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, PhasePlanCallback } from "../lib/workflow/types.js";
+export interface ProgressWiring {
+    renderer: RunRenderer | null;
+    heartbeat: LivenessHeartbeat | null;
+    onProgress: ProgressCallback | undefined;
+    /** #672 AC-2: forwarded to the orchestrator so batch-executor can hand the
+     *  resolved phase pipeline back to the renderer once it's known. */
+    onPhasePlan: PhasePlanCallback | 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;
+    /** #672 AC-2: the base configured phase pipeline. In explicit-phase mode
+     *  (not auto-detect) this is known upfront, so every issue — including those
+     *  still queued behind the active one — can show its roadmap immediately
+     *  rather than only once it starts running. `setPhasePlan` later refines it
+     *  per issue (e.g. testgen/security-review insertion). Ignored in
+     *  auto-detect mode, where the plan isn't known until spec resolves it. */
+    basePhases?: string[];
+    /** #624 Item 3 / D2: total allowed quality-loop iterations (from settings). */
+    maxLoopIterations?: number;
+}): ProgressWiring;

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

@@ -0,0 +1,93 @@
+/**
+ * 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, basePhases, 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) {
+        // #672 AC-2: seed the planned pipeline at registration when it's known
+        // upfront (explicit-phase mode). This makes queued issues render their
+        // roadmap before they start, matching the issue's multi-row matrix
+        // mock-up. In auto-detect mode the plan isn't known yet, so we leave
+        // `plannedPhases` undefined and rely on `setPhasePlan` once spec resolves.
+        const seedPlan = !autoDetectPhases && basePhases && basePhases.length > 0
+            ? basePhases
+            : undefined;
+        for (const issueNumber of issueNumbers) {
+            renderer.registerIssue({
+                issueNumber,
+                autoDetect: autoDetectPhases,
+                plannedPhases: seedPlan,
+            });
+        }
+    }
+    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 });
+        };
+    }
+    // #672 AC-2: only the renderer path consumes a phase plan; quiet / TUI
+    // modes leave this undefined and the orchestrator no-ops the callback.
+    const onPhasePlan = renderer
+        ? (issue, phases) => renderer.setPhasePlan(issue, phases)
+        : undefined;
+    return { renderer, heartbeat, onProgress, onPhasePlan };
+}

package/dist/src/commands/run.js

@@ -1,13 +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 { ui } from "../lib/cli-ui.js";
 import { parseBatches } from "../lib/workflow/batch-executor.js";
 import { RunOrchestrator } from "../lib/workflow/run-orchestrator.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. */
@@ -31,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"));
@@ -60,22 +69,85 @@ export async function runCommand(issues, options) {
     };
     const resolved = RunOrchestrator.resolveConfig(init, issues, batches);
     displayConfig(resolved);
-    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}`);
+    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, onPhasePlan } = buildProgressWiring({
+        tuiEnabled,
+        quiet: Boolean(options.quiet),
+        issueNumbers: resolved.issueNumbers,
+        phaseTimeoutSeconds: settings.run.timeout,
+        autoDetectPhases: resolved.autoDetectPhases,
+        // #672 AC-2: base pipeline so queued issues show their roadmap upfront in
+        // explicit-phase mode (ignored when auto-detect resolves the plan later).
+        basePhases: resolved.config.phases,
+        // #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,
+                onPhasePlan,
+                phasePauseHandle: renderer ?? undefined,
+                onOrchestratorReady: (orch) => {
+                    tuiHandle = renderTui(orch);
+                },
+            }, issues, batches);
+            if (tuiHandle) {
+                await tuiHandle.done;
             }
-            else
-                console.log(`  ${colors.error("✖")} #${issue}  ${phase}`);
+            displaySummary(result);
+            if (result.exitCode !== 0)
+                process.exit(result.exitCode);
+            return;
+        }
+        finally {
+            process.off("SIGINT", sigintHandler);
         }
-        : undefined;
-    const result = await RunOrchestrator.run({ ...init, onProgress }, issues, batches);
-    displaySummary(result);
-    if (result.exitCode !== 0)
-        process.exit(result.exitCode);
+    }
+    // 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,
+            onPhasePlan,
+            phasePauseHandle: renderer ?? undefined,
+        }, 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);
+    }
+    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);

package/dist/src/commands/status.js

@@ -11,6 +11,7 @@ import { rebuildStateFromLogs, cleanupStaleEntries, } from "../lib/workflow/stat
 import { reconcileState, getNextActionHint, formatRelativeTime, } from "../lib/workflow/reconcile.js";
 import { getSettingsWithWarnings } from "../lib/settings.js";
 import { getSkillVersions } from "../lib/skill-version.js";
+import { LockManager, formatLockedMessage } from "../lib/locks/index.js";
 /**
  * Run reconciliation and display warnings.
  * Returns the reconcile result for use in display.
@@ -182,11 +183,16 @@ function displayIssueSummary(issues) {
             const hintDisplay = hint
                 ? chalk.gray(`→ ${hint.length > 30 ? hint.substring(0, 27) + "..." : hint}`)
                 : "";
+            // Relay column (#383). Shows ✓ when active, "-" otherwise.
+            const relayDisplay = issue.relay?.enabled
+                ? chalk.green("on")
+                : chalk.gray("-");
             rows.push([
                 `#${issue.number}`,
                 title,
                 colorStatus(issue.status, issue.resolvedAt),
                 issue.currentPhase || "-",
+                relayDisplay,
                 hintDisplay,
             ]);
         }
@@ -199,6 +205,7 @@ function displayIssueSummary(issues) {
                 { header: "Title", width: 32 },
                 { header: "Status", width: 20 },
                 { header: "Phase", width: 10 },
+                { header: "Relay", width: 5 },
                 { header: "Next", width: 34 },
             ],
         }));
@@ -356,6 +363,11 @@ async function displayIssueState(options) {
             else if (issueState) {
                 console.log(chalk.bold(`\nIssue #${options.issue} State\n`));
                 console.log(formatIssueState(issueState));
+                const lockManager = new LockManager();
+                const holder = lockManager.check(options.issue);
+                if (holder) {
+                    console.log(chalk.yellow(`    !  ${formatLockedMessage(options.issue, holder)}`));
+                }
                 const hint = getNextActionHint(issueState);
                 if (hint) {
                     console.log(chalk.cyan(`\n    Next: ${hint}`));

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

@@ -0,0 +1,18 @@
+/**
+ * `sequant watch <issue>` — tail the relay outbox for replies from a running
+ * headless session (#383). Uses `fs.watch()` when available, falls back to
+ * polling on platforms where `fs.watch` is unreliable (NFS, some WSL setups).
+ */
+export interface WatchCommandOptions {
+    json?: boolean;
+    /** Poll interval (ms); used when fs.watch is unavailable. Default: 200. */
+    pollIntervalMs?: number;
+    /** Abort signal for clean shutdown (tests). */
+    signal?: AbortSignal;
+    /** Override cwd for resolving the pid file + archive root (test seam). */
+    cwd?: string;
+}
+export declare function watchCommand(argsAndOptions: {
+    args: string[];
+    options: WatchCommandOptions;
+}): Promise<void>;