sequant 2.2.0 → 2.3.0

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,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,75 @@ 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 } = 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;
             }
-            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 }, 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,16 @@
+/**
+ * `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;
+}
+export declare function watchCommand(argsAndOptions: {
+    args: string[];
+    options: WatchCommandOptions;
+}): Promise<void>;

package/dist/src/commands/watch.js

@@ -0,0 +1,147 @@
+/**
+ * `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).
+ */
+import { existsSync, statSync, createReadStream, watch } from "fs";
+import chalk from "chalk";
+import { outboxPathFor } from "../lib/relay/paths.js";
+import { StateManager } from "../lib/workflow/state-manager.js";
+import { RelayResponseSchema } from "../lib/relay/types.js";
+function formatTimestamp(iso) {
+    try {
+        const date = new Date(iso);
+        const hh = String(date.getHours()).padStart(2, "0");
+        const mm = String(date.getMinutes()).padStart(2, "0");
+        const ss = String(date.getSeconds()).padStart(2, "0");
+        return `${hh}:${mm}:${ss}`;
+    }
+    catch {
+        return iso;
+    }
+}
+function formatLine(reply, json) {
+    if (json)
+        return JSON.stringify(reply);
+    return chalk.gray(`[${formatTimestamp(reply.timestamp)}] `) + reply.message;
+}
+function readNewLines(path, state) {
+    return new Promise((resolve, reject) => {
+        if (!existsSync(path)) {
+            resolve([]);
+            return;
+        }
+        const stat = statSync(path);
+        if (stat.size <= state.offset) {
+            // File was truncated/rotated — reset offset.
+            if (stat.size < state.offset)
+                state.offset = 0;
+            resolve([]);
+            return;
+        }
+        const stream = createReadStream(path, {
+            start: state.offset,
+            end: stat.size - 1,
+            encoding: "utf-8",
+        });
+        let buf = state.partial;
+        stream.on("data", (chunk) => {
+            buf += chunk;
+        });
+        stream.on("error", (err) => reject(err));
+        stream.on("end", () => {
+            state.offset = stat.size;
+            const lines = buf.split("\n");
+            state.partial = lines.pop() ?? "";
+            const replies = [];
+            for (const line of lines) {
+                if (line.trim() === "")
+                    continue;
+                try {
+                    const parsed = RelayResponseSchema.safeParse(JSON.parse(line));
+                    if (parsed.success)
+                        replies.push(parsed.data);
+                }
+                catch {
+                    /* skip malformed */
+                }
+            }
+            resolve(replies);
+        });
+    });
+}
+export async function watchCommand(argsAndOptions) {
+    const { args, options } = argsAndOptions;
+    const issueArg = args[0];
+    if (!issueArg) {
+        throw new Error("Usage: sequant watch <issue>");
+    }
+    const issueNumber = Number.parseInt(issueArg, 10);
+    if (!Number.isInteger(issueNumber) || issueNumber <= 0) {
+        throw new Error(`Invalid issue number: '${issueArg}'`);
+    }
+    const stateManager = new StateManager();
+    const issueState = await stateManager.getIssueState(issueNumber);
+    const outboxPath = outboxPathFor(issueNumber, {
+        worktreePath: issueState?.worktree,
+    });
+    const pollIntervalMs = options.pollIntervalMs ?? 200;
+    const tail = { offset: 0, partial: "" };
+    // Seed tail offset at current EOF so we only show NEW replies.
+    if (existsSync(outboxPath)) {
+        tail.offset = statSync(outboxPath).size;
+    }
+    if (!options.json) {
+        console.log(chalk.gray(`Watching #${issueNumber} outbox — Ctrl+C to stop`));
+    }
+    let stopped = false;
+    const stop = () => {
+        stopped = true;
+    };
+    options.signal?.addEventListener("abort", stop);
+    process.on("SIGINT", () => {
+        stop();
+        if (!options.json)
+            console.log(chalk.gray("\nStopped watching."));
+        process.exit(0);
+    });
+    let useWatcher = false;
+    let watcher = null;
+    try {
+        if (existsSync(outboxPath)) {
+            watcher = watch(outboxPath, { persistent: true }, () => {
+                // fs.watch fires on any modification; we still poll readNewLines.
+            });
+            useWatcher = true;
+        }
+    }
+    catch {
+        useWatcher = false;
+    }
+    const emit = (replies) => {
+        for (const r of replies) {
+            console.log(formatLine(r, options.json === true));
+        }
+    };
+    // Polling loop — also used as a heartbeat when fs.watch is active so we
+    // don't miss events on filesystems where watch is unreliable.
+    while (!stopped) {
+        try {
+            const replies = await readNewLines(outboxPath, tail);
+            emit(replies);
+        }
+        catch {
+            /* transient — try again next tick */
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    if (watcher) {
+        try {
+            watcher.close();
+        }
+        catch {
+            /* swallow */
+        }
+    }
+    void useWatcher; // currently unused beyond best-effort init
+}

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

@@ -19,7 +19,7 @@ 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";
+export type ACLintIssueType = "vague" | "unmeasurable" | "incomplete" | "open_ended" | "title-body-tension";
 /**
  * A lint issue found in an acceptance criterion
  */