sequant 2.1.2 → 2.3.0

package/dist/src/mcp/tools/run.js

@@ -71,6 +71,30 @@ function resolveLogDir() {
     }
     return projectPath;
 }
+/**
+ * Find and parse a run log file by its exact runId suffix (#631).
+ *
+ * Avoids the recency-window heuristic in `readLatestRunLog`, which can
+ * return another concurrent run's log or a stale same-issue log when
+ * filesystem ordering doesn't favor the current run.
+ *
+ * Returns null on miss, parse failure, or I/O error (no new failure mode).
+ */
+export async function readRunLogById(runId) {
+    try {
+        const logDir = resolveLogDir();
+        const entries = await readdir(logDir);
+        // Filename format: run-<timestamp>-<runId>.json — match by exact suffix.
+        const match = entries.find((f) => f.endsWith(`-${runId}.json`));
+        if (!match)
+            return null;
+        const content = await readFile(join(logDir, match), "utf-8");
+        return RunLogSchema.parse(JSON.parse(content));
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Find and parse the most recent run log file.
  *
@@ -109,6 +133,24 @@ export async function readLatestRunLog(runStartTime) {
         return null;
     }
 }
+/**
+ * Resolve the run log for an MCP `sequant_run` invocation (#631).
+ *
+ * Prefers exact-filename lookup by captured runId; falls back to the
+ * time-window heuristic when no runId was captured (older CLI, startup
+ * race) or when the runId lookup returned null (corrupted file, slow
+ * fsync). On lookup-miss with a captured runId, emit a debug line on
+ * the MCP server's own stderr so the silent fallback is observable.
+ */
+export async function resolveRunLog(capturedRunId, runStartTime) {
+    if (capturedRunId !== null) {
+        const byId = await readRunLogById(capturedRunId);
+        if (byId)
+            return byId;
+        console.error(`[mcp:run] runId ${capturedRunId} lookup miss — falling back to readLatestRunLog`);
+    }
+    return readLatestRunLog(runStartTime);
+}
 /**
  * Build a structured response from a parsed RunLog
  */
@@ -199,6 +241,21 @@ function buildFallbackResponse(stdout, issueNumbers, overallStatus, phases, exit
 }
 /** Prefix used by the batch executor to emit structured progress lines. */
 const PROGRESS_LINE_PREFIX = "SEQUANT_PROGRESS:";
+/** Prefix used by the batch executor to emit the current run's UUID (#631). */
+const RUN_ID_LINE_PREFIX = "SEQUANT_RUN_ID:";
+/** UUID v4 pattern produced by `crypto.randomUUID()`. */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Parse a SEQUANT_RUN_ID line emitted by the batch executor (#631).
+ * Returns the runId UUID or null if the line isn't a runId line or the
+ * payload isn't a well-formed UUID.
+ */
+export function parseRunIdLine(line) {
+    if (!line.startsWith(RUN_ID_LINE_PREFIX))
+        return null;
+    const id = line.slice(RUN_ID_LINE_PREFIX.length).trim();
+    return UUID_RE.test(id) ? id : null;
+}
 /**
  * Parse a SEQUANT_PROGRESS line emitted by the batch executor.
  * Returns the parsed event or null if the line isn't a progress line.
@@ -233,6 +290,38 @@ export function parseProgressLine(line) {
         return null;
     }
 }
+/**
+ * Stateful capture of the per-run UUID emitted on stderr by the spawned
+ * CLI (#631). Each MCP request creates its own capture instance.
+ *
+ * `routeLine` consumes a complete stderr line:
+ * - Until a `SEQUANT_RUN_ID:` line is seen, attempts to capture it.
+ * - After capture (or for non-runId lines), delegates to `parseProgressLine`
+ *   and returns the parsed `ProgressEvent`, if any.
+ *
+ * Returning `ProgressEvent | null` (instead of side-effecting) keeps the
+ * factory pure and lets callers wire emission (`emitProgress`) at the
+ * outer layer. This separation also makes the capture logic directly
+ * testable without driving the full MCP request handler.
+ */
+export function createRunIdCapture() {
+    let capturedRunId = null;
+    return {
+        routeLine(line) {
+            if (capturedRunId === null) {
+                const id = parseRunIdLine(line);
+                if (id) {
+                    capturedRunId = id;
+                    return null;
+                }
+            }
+            return parseProgressLine(line);
+        },
+        getCapturedRunId() {
+            return capturedRunId;
+        },
+    };
+}
 /**
  * Build a human-readable message for a progress notification (AC-3).
  * @internal Exported for testing only.
@@ -368,22 +457,21 @@ export function registerRunTool(server) {
                 // Swallow synchronous errors (AC-6)
             }
         };
-        /**
-         * Handle a complete line of subprocess stderr, checking for progress events.
-         * The batch executor emits SEQUANT_PROGRESS:{json} lines at phase boundaries.
-         */
+        // Per-request capture of the runId line emitted by the spawned CLI
+        // (#631). `routeLine` also parses progress events; we wire emission
+        // at this layer so the capture factory stays pure / testable.
+        const { routeLine, getCapturedRunId } = createRunIdCapture();
         const handleLine = (line) => {
-            const event = parseProgressLine(line);
+            const event = routeLine(line);
             if (event)
                 emitProgress(event);
         };
-        // Line-buffer stderr to handle chunk boundaries correctly.
-        // When a progressToken is present, we also enable spawnAsync's
-        // internal progress detection for timeout reset (AC-4).
+        // `hasProgressToken` no longer gates the line buffer (always-on so
+        // runId capture works without a subscriber); it still gates the
+        // `onProgress` callback below, which controls spawnAsync's
+        // timeout-reset behavior on progress events.
         const hasProgressToken = progressToken !== undefined;
-        const stderrLineBuffer = hasProgressToken
-            ? createLineBuffer(handleLine)
-            : undefined;
+        const stderrLineBuffer = createLineBuffer(handleLine);
         // Register all issues as active runs for real-time status polling
         for (const issue of issues) {
             registerRun(issue);
@@ -405,8 +493,11 @@ export function registerRunTool(server) {
             const stdout = result.stdout || "";
             const stderr = result.stderr || "";
             const overallStatus = result.exitCode === 0 ? "success" : "failure";
-            // Try to read structured log file for rich per-issue data
-            const runLog = await readLatestRunLog(runStartTime);
+            // Try to read structured log file for rich per-issue data.
+            // Prefer exact-filename lookup by captured runId (#631); fall back to
+            // the time-window heuristic when the CLI didn't emit a runId (older
+            // CLI, startup race) or the file is not yet visible on disk.
+            const runLog = await resolveRunLog(getCapturedRunId(), runStartTime);
             let response;
             if (runLog) {
                 response = buildStructuredResponse(runLog, stdout, overallStatus, result.exitCode, stderr || undefined);

package/dist/src/ui/tui/App.d.ts

@@ -0,0 +1,14 @@
+import { type JSX } from "react";
+import type { RunSnapshot } from "../../lib/workflow/run-state.js";
+/**
+ * Root TUI component.
+ *
+ * Polls `getSnapshot` at 10 Hz. A 1 Hz "now" tick keeps the
+ * last-activity stamp moving even when the snapshot itself is unchanged.
+ * When the snapshot reports `done`, the component stops polling and
+ * invokes `onDone` so the caller can `unmount` the ink instance.
+ */
+export declare function App({ getSnapshot, onDone, }: {
+    getSnapshot: () => RunSnapshot;
+    onDone?: () => void;
+}): JSX.Element;

package/dist/src/ui/tui/App.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Box, useStdout } from "ink";
+import { Header } from "./Header.js";
+import { IssueBox } from "./IssueBox.js";
+const POLL_MS = 100; // 10 Hz
+/**
+ * Root TUI component.
+ *
+ * Polls `getSnapshot` at 10 Hz. A 1 Hz "now" tick keeps the
+ * last-activity stamp moving even when the snapshot itself is unchanged.
+ * When the snapshot reports `done`, the component stops polling and
+ * invokes `onDone` so the caller can `unmount` the ink instance.
+ */
+export function App({ getSnapshot, onDone, }) {
+    const [snapshot, setSnapshot] = useState(() => getSnapshot());
+    const [now, setNow] = useState(() => Date.now());
+    const doneFired = useRef(false);
+    const { stdout } = useStdout();
+    // Snapshot poller (drives all state transitions).
+    useEffect(() => {
+        const id = setInterval(() => {
+            const next = getSnapshot();
+            setSnapshot(next);
+            if (next.done && !doneFired.current) {
+                doneFired.current = true;
+                clearInterval(id);
+                onDone?.();
+            }
+        }, POLL_MS);
+        return () => clearInterval(id);
+    }, [getSnapshot, onDone]);
+    // Coarse 1 Hz tick for the last-activity stamp.
+    useEffect(() => {
+        const id = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(id);
+    }, []);
+    const columns = stdout?.columns ?? 80;
+    const boxWidth = Math.min(columns - 2, 100);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { snapshot: snapshot }), snapshot.issues.map((issue, i) => (_jsx(IssueBox, { state: issue, slot: i, width: boxWidth, now: now }, issue.number)))] }));
+}

package/dist/src/ui/tui/ElapsedTimer.d.ts

@@ -0,0 +1,10 @@
+import { type JSX } from "react";
+/**
+ * Per-issue elapsed timer. Owns its own interval so tick-driven re-renders
+ * are scoped to this leaf component and do not propagate to `IssueBox`.
+ */
+export declare function ElapsedTimer({ startedAt }: {
+    startedAt?: Date;
+}): JSX.Element;
+/** Format an absolute timestamp as the "last activity Xs ago" stamp. */
+export declare function formatSinceActivity(now: number, activityAt: Date): string;

package/dist/src/ui/tui/ElapsedTimer.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text } from "ink";
+/**
+ * Per-issue elapsed timer. Owns its own interval so tick-driven re-renders
+ * are scoped to this leaf component and do not propagate to `IssueBox`.
+ */
+export function ElapsedTimer({ startedAt }) {
+    const [now, setNow] = useState(() => Date.now());
+    useEffect(() => {
+        const id = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(id);
+    }, []);
+    if (!startedAt)
+        return _jsx(Text, { children: "--:--" });
+    const secs = Math.max(0, Math.floor((now - startedAt.getTime()) / 1000));
+    const mm = Math.floor(secs / 60)
+        .toString()
+        .padStart(2, "0");
+    const ss = (secs % 60).toString().padStart(2, "0");
+    return _jsx(Text, { children: `${mm}:${ss}` });
+}
+/** Format an absolute timestamp as the "last activity Xs ago" stamp. */
+export function formatSinceActivity(now, activityAt) {
+    const secs = Math.max(0, Math.floor((now - activityAt.getTime()) / 1000));
+    if (secs < 60)
+        return `${secs}s ago`;
+    const mm = Math.floor(secs / 60);
+    const ss = secs % 60;
+    return `${mm}m ${ss}s ago`;
+}

package/dist/src/ui/tui/Header.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from "react";
+import type { RunSnapshot } from "../../lib/workflow/run-state.js";
+/** Top-of-dashboard summary: count, concurrency, base, quality-loop. */
+export declare function Header({ snapshot }: {
+    snapshot: RunSnapshot;
+}): JSX.Element;

package/dist/src/ui/tui/Header.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { DIVIDER_COLOR } from "./theme.js";
+/** Top-of-dashboard summary: count, concurrency, base, quality-loop. */
+export function Header({ snapshot }) {
+    const { config, issues } = snapshot;
+    const concurrency = config.concurrency > 1
+        ? `parallel (${config.concurrency} concurrent)`
+        : "sequential";
+    const loop = config.qualityLoop ? "on" : "off";
+    const base = config.baseSha
+        ? `${config.baseBranch} @${config.baseSha.slice(0, 7)}`
+        : config.baseBranch;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "sequant run" }), _jsxs(Text, { color: DIVIDER_COLOR, children: ["  ─  ", issues.length, " issue", issues.length === 1 ? "" : "s", "  •  ", concurrency, "  •  ", "quality loop ", loop] })] }), _jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "base " }), _jsx(Text, { children: base })] })] }));
+}

package/dist/src/ui/tui/IssueBox.d.ts

@@ -0,0 +1,16 @@
+import type { JSX } from "react";
+import type { IssueRuntimeState } from "../../lib/workflow/run-state.js";
+/**
+ * Three-cell rendering of a single issue's runtime state.
+ *
+ * Cells:
+ *   1. header  — id, title, phase N/total, elapsed
+ *   2. context — branch, phase progression, log path
+ *   3. activity — current `now` line, last-activity stamp
+ */
+export declare function IssueBox({ state, slot, width, now, }: {
+    state: IssueRuntimeState;
+    slot: number;
+    width: number;
+    now: number;
+}): JSX.Element;

package/dist/src/ui/tui/IssueBox.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { DIVIDER_COLOR, PHASE_GLYPHS, borderColorForIssue, phaseStatusColor, } from "./theme.js";
+import { Spinner } from "./Spinner.js";
+import { ElapsedTimer, formatSinceActivity } from "./ElapsedTimer.js";
+import { truncateToWidth } from "./truncate.js";
+/**
+ * Three-cell rendering of a single issue's runtime state.
+ *
+ * Cells:
+ *   1. header  — id, title, phase N/total, elapsed
+ *   2. context — branch, phase progression, log path
+ *   3. activity — current `now` line, last-activity stamp
+ */
+export function IssueBox({ state, slot, width, now, }) {
+    const border = borderColorForIssue(state.status, slot);
+    const innerWidth = Math.max(10, width - 4);
+    const doneCount = state.phases.filter((p) => p.status === "done" || p.status === "failed").length;
+    const activePhaseIndex = state.phases.findIndex((p) => p.status === "running");
+    const displayPhaseN = activePhaseIndex >= 0 ? activePhaseIndex + 1 : doneCount;
+    const total = state.phases.length;
+    const headerTitle = truncateToWidth(`#${state.number}  ${state.title}`, Math.max(10, innerWidth - 20));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: border, paddingX: 1, marginBottom: 1, width: width, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: border, children: headerTitle }), _jsxs(Text, { color: DIVIDER_COLOR, children: ["phase ", displayPhaseN, "/", total, " \u2022", " ", _jsx(ElapsedTimer, { startedAt: state.startedAt })] })] }), _jsx(Divider, { width: innerWidth, borderColor: border }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "branch " }), _jsx(Text, { children: truncateToWidth(state.branch, innerWidth - 8) })] }), _jsx(PhaseProgression, { phases: state.phases, borderColor: border }), state.currentPhase?.logPath ? (_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "log " }), _jsx(Text, { children: truncateToWidth(state.currentPhase.logPath, innerWidth - 8) })] })) : null] }), _jsx(Divider, { width: innerWidth, borderColor: border }), _jsx(Box, { flexDirection: "column", children: state.currentPhase ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "now " }), _jsx(Spinner, { color: border }), _jsxs(Text, { children: ["  ", truncateToWidth(state.currentPhase.nowLine, innerWidth - 12)] })] }), _jsx(Box, { children: _jsxs(Text, { color: DIVIDER_COLOR, children: ["        └ last activity ", formatSinceActivity(now, state.currentPhase.lastActivityAt)] }) })] })) : (_jsx(Text, { color: DIVIDER_COLOR, children: statusLine(state) })) })] }));
+}
+function statusLine(state) {
+    switch (state.status) {
+        case "queued":
+            return "queued";
+        case "running":
+            return "working…";
+        case "passed":
+            return "completed";
+        case "failed":
+            return "failed";
+    }
+}
+function Divider({ width, borderColor, }) {
+    const mid = "─".repeat(Math.max(0, width - 2));
+    return (_jsxs(Text, { children: [_jsx(Text, { color: borderColor, children: "\u251C" }), _jsx(Text, { color: DIVIDER_COLOR, children: mid }), _jsx(Text, { color: borderColor, children: "\u2524" })] }));
+}
+function PhaseProgression({ phases, borderColor, }) {
+    return (_jsxs(Box, { flexWrap: "wrap", children: [_jsx(Text, { color: DIVIDER_COLOR, children: "phases " }), phases.map((p, i) => {
+                const isLast = i === phases.length - 1;
+                return (_jsxs(Box, { children: [_jsx(PhaseGlyph, { status: p.status, label: p.name, activeColor: borderColor, elapsedMs: p.elapsedMs }), !isLast ? (_jsxs(Text, { color: DIVIDER_COLOR, children: ["   ", PHASE_GLYPHS.separator, "   "] })) : null] }, `${p.name}-${i}`));
+            })] }));
+}
+function PhaseGlyph({ status, label, activeColor, elapsedMs, }) {
+    if (status === "running") {
+        return (_jsxs(Box, { children: [_jsx(Spinner, { color: activeColor }), _jsxs(Text, { children: [" ", label] })] }));
+    }
+    const glyph = status === "done"
+        ? PHASE_GLYPHS.done
+        : status === "failed"
+            ? PHASE_GLYPHS.failed
+            : PHASE_GLYPHS.pending;
+    const glyphColor = phaseStatusColor(status);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: glyphColor, children: glyph }), _jsxs(Text, { color: DIVIDER_COLOR, children: [" ", label, elapsedMs != null ? ` ${formatShortDuration(elapsedMs)}` : ""] })] }));
+}
+function formatShortDuration(ms) {
+    const secs = Math.max(0, Math.floor(ms / 1000));
+    if (secs < 60)
+        return `${secs.toString().padStart(2, "0")}s`;
+    const mm = Math.floor(secs / 60)
+        .toString()
+        .padStart(2, "0");
+    const ss = (secs % 60).toString().padStart(2, "0");
+    return `${mm}:${ss}`;
+}

package/dist/src/ui/tui/Spinner.d.ts

@@ -0,0 +1,9 @@
+import { type JSX } from "react";
+import { type BorderColor } from "./theme.js";
+/**
+ * Braille spinner. Ticks at 10 Hz in its own component so the parent
+ * issue box is not forced to re-render on each frame.
+ */
+export declare function Spinner({ color }: {
+    color?: BorderColor;
+}): JSX.Element;

package/dist/src/ui/tui/Spinner.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text } from "ink";
+import { SPINNER_FRAMES } from "./theme.js";
+/**
+ * Braille spinner. Ticks at 10 Hz in its own component so the parent
+ * issue box is not forced to re-render on each frame.
+ */
+export function Spinner({ color }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => {
+            setFrame((f) => (f + 1) % SPINNER_FRAMES.length);
+        }, 100);
+        return () => clearInterval(id);
+    }, []);
+    return _jsx(Text, { color: color, children: SPINNER_FRAMES[frame] });
+}

package/dist/src/ui/tui/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Experimental multi-issue TUI entry point.
+ *
+ * Mounts an `ink` app that polls `RunOrchestrator.getSnapshot()` at 10 Hz.
+ * Unmounts when the orchestrator reports `done` so the shell returns
+ * cleanly. Only safe to call when `process.stdout.isTTY` is true.
+ */
+import type { RunOrchestrator } from "../../lib/workflow/run-orchestrator.js";
+export interface TuiHandle {
+    /** Promise that resolves when the TUI unmounts. */
+    done: Promise<void>;
+    /** Force-unmount (e.g., on SIGINT fallback). */
+    unmount: () => void;
+}
+export declare function renderTui(orchestrator: RunOrchestrator): TuiHandle;

package/dist/src/ui/tui/index.js

@@ -0,0 +1,29 @@
+/**
+ * Experimental multi-issue TUI entry point.
+ *
+ * Mounts an `ink` app that polls `RunOrchestrator.getSnapshot()` at 10 Hz.
+ * Unmounts when the orchestrator reports `done` so the shell returns
+ * cleanly. Only safe to call when `process.stdout.isTTY` is true.
+ */
+import { createElement } from "react";
+import { render } from "ink";
+import { App } from "./App.js";
+export function renderTui(orchestrator) {
+    let resolveDone;
+    const done = new Promise((resolve) => {
+        resolveDone = resolve;
+    });
+    const instance = render(createElement(App, {
+        getSnapshot: () => orchestrator.getSnapshot(),
+        onDone: () => {
+            instance.unmount();
+        },
+    }), { exitOnCtrlC: false });
+    instance.waitUntilExit().then(() => resolveDone());
+    return {
+        done,
+        unmount: () => {
+            instance.unmount();
+        },
+    };
+}

package/dist/src/ui/tui/theme.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Theme tokens for the experimental multi-issue dashboard TUI.
+ *
+ * Palette rotates by start order (cyan → magenta → blue → yellow); issue
+ * status (failed / passed) overrides the rotation color where applicable.
+ * Respects `NO_COLOR` automatically via `ink`/`chalk`.
+ */
+import type { IssueStatus, PhaseStatus } from "../../lib/workflow/run-state.js";
+/** Border-color palette rotated by issue start order. */
+export declare const BORDER_ROTATION: readonly ["cyan", "magenta", "blue", "yellow"];
+export type BorderColor = (typeof BORDER_ROTATION)[number] | "green" | "red" | "gray";
+/** Gray used for horizontal dividers inside each box. */
+export declare const DIVIDER_COLOR: "gray";
+/**
+ * Pick the border color for an issue.
+ * Failed / passed states win over rotation; otherwise rotate by slot.
+ */
+export declare function borderColorForIssue(status: IssueStatus, slot: number): BorderColor;
+/** Glyphs for the phase progression row. */
+export declare const PHASE_GLYPHS: {
+    readonly pending: "○";
+    readonly done: "✓";
+    readonly failed: "✗";
+    readonly separator: "▸";
+};
+/** Braille spinner frames — 10 Hz rotation looks smooth at ~100ms tick. */
+export declare const SPINNER_FRAMES: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Color for a phase glyph based on its status. Active phase uses border color. */
+export declare function phaseStatusColor(status: PhaseStatus): BorderColor;

package/dist/src/ui/tui/theme.js

@@ -0,0 +1,52 @@
+/**
+ * Theme tokens for the experimental multi-issue dashboard TUI.
+ *
+ * Palette rotates by start order (cyan → magenta → blue → yellow); issue
+ * status (failed / passed) overrides the rotation color where applicable.
+ * Respects `NO_COLOR` automatically via `ink`/`chalk`.
+ */
+/** Border-color palette rotated by issue start order. */
+export const BORDER_ROTATION = ["cyan", "magenta", "blue", "yellow"];
+/** Gray used for horizontal dividers inside each box. */
+export const DIVIDER_COLOR = "gray";
+/**
+ * Pick the border color for an issue.
+ * Failed / passed states win over rotation; otherwise rotate by slot.
+ */
+export function borderColorForIssue(status, slot) {
+    if (status === "failed")
+        return "red";
+    if (status === "passed")
+        return "green";
+    const idx = ((slot % BORDER_ROTATION.length) + BORDER_ROTATION.length) %
+        BORDER_ROTATION.length;
+    return BORDER_ROTATION[idx];
+}
+/** Glyphs for the phase progression row. */
+export const PHASE_GLYPHS = {
+    pending: "○",
+    done: "✓",
+    failed: "✗",
+    separator: "▸",
+};
+/** Braille spinner frames — 10 Hz rotation looks smooth at ~100ms tick. */
+export const SPINNER_FRAMES = [
+    "⠋",
+    "⠙",
+    "⠹",
+    "⠸",
+    "⠼",
+    "⠴",
+    "⠦",
+    "⠧",
+    "⠇",
+    "⠏",
+];
+/** Color for a phase glyph based on its status. Active phase uses border color. */
+export function phaseStatusColor(status) {
+    if (status === "done")
+        return "green";
+    if (status === "failed")
+        return "red";
+    return "gray";
+}

package/dist/src/ui/tui/truncate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Display-width-aware truncation for terminal output.
+ *
+ * Uses `string-width` so wide glyphs (CJK, emoji) and ANSI escapes are
+ * counted correctly. Cheaper than ink's own truncation in hot paths.
+ */
+/**
+ * Truncate `text` so its visible width does not exceed `max` columns.
+ * If truncation happens, appends a single `…` (which itself counts as 1 col).
+ */
+export declare function truncateToWidth(text: string, max: number): string;

package/dist/src/ui/tui/truncate.js

@@ -0,0 +1,31 @@
+/**
+ * Display-width-aware truncation for terminal output.
+ *
+ * Uses `string-width` so wide glyphs (CJK, emoji) and ANSI escapes are
+ * counted correctly. Cheaper than ink's own truncation in hot paths.
+ */
+import stringWidth from "string-width";
+/**
+ * Truncate `text` so its visible width does not exceed `max` columns.
+ * If truncation happens, appends a single `…` (which itself counts as 1 col).
+ */
+export function truncateToWidth(text, max) {
+    if (max <= 0)
+        return "";
+    const width = stringWidth(text);
+    if (width <= max)
+        return text;
+    if (max === 1)
+        return "…";
+    let acc = "";
+    let accWidth = 0;
+    const budget = max - 1; // reserve one column for the ellipsis
+    for (const ch of text) {
+        const w = stringWidth(ch);
+        if (accWidth + w > budget)
+            break;
+        acc += ch;
+        accWidth += w;
+    }
+    return `${acc}…`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sequant",
-  "version": "2.1.2",
+  "version": "2.3.0",
   "description": "Quantize your development workflow - Sequential AI phases with quality gates",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
     "lint": "eslint src/ bin/ --max-warnings 0",
     "sync:skills": "cp -r templates/skills/* .claude/skills/",
     "validate:skills": "for skill in templates/skills/*/; do npx skills-ref validate \"$skill\"; done",
+    "lint:skill-calls": "npx tsx scripts/lint-skill-calls.ts",
     "prepare:marketplace": "npx tsx scripts/prepare-marketplace.ts",
     "validate:marketplace": "npx tsx scripts/prepare-marketplace.ts --validate-only",
     "prepublishOnly": "npm run build"
@@ -76,19 +77,23 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.11",
-    "@hono/node-server": "^1.19.9",
+    "@hono/node-server": "^2.0.0",
     "boxen": "^8.0.1",
     "chalk": "^5.3.0",
     "chokidar": "^5.0.0",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.3",
-    "diff": "^8.0.3",
+    "diff": "^9.0.0",
     "gradient-string": "^3.0.0",
     "hono": "^4.12.1",
+    "ink": "^7.0.1",
     "inquirer": "^13.3.0",
+    "log-update": "^7.0.1",
     "open": "^11.0.0",
     "ora": "^9.3.0",
     "p-limit": "^7.3.0",
+    "react": "^19.2.5",
+    "string-width": "^8.2.0",
     "yaml": "^2.7.0",
     "zod": "^4.3.5"
   },
@@ -97,10 +102,12 @@
     "@types/gradient-string": "^1.1.6",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^25.4.0",
+    "@types/react": "^19.2.14",
     "@typescript-eslint/eslint-plugin": "^8.58.0",
     "@typescript-eslint/parser": "^8.58.0",
     "eslint": "^10.1.0",
     "globals": "^17.0.0",
+    "ink-testing-library": "^4.0.0",
     "tsx": "^4.19.2",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.0",

package/templates/agents/sequant-explorer.md

@@ -1,6 +1,7 @@
 ---
 name: sequant-explorer
 description: Codebase exploration agent for sequant /spec phase. Searches for existing patterns, components, database schemas, and file structures. Use when gathering context before planning a feature implementation.
+# Note: per anthropics/claude-code#43869 this is currently a no-op; agent runs on parent's model
 model: haiku
 maxTurns: 15
 tools:

package/templates/agents/sequant-qa-checker.md

@@ -1,7 +1,8 @@
 ---
 name: sequant-qa-checker
 description: Quality check agent for sequant /qa phase. Runs type safety, scope/size, security, and documentation checks on diffs. Use when spawned by the /qa skill to perform parallel or sequential quality checks.
-model: haiku
+# Note: per anthropics/claude-code#43869 this is currently a no-op; agent runs on parent's model
+model: sonnet
 permissionMode: bypassPermissions
 effort: low
 maxTurns: 15