sequant 2.6.0 → 2.6.2

package/dist/src/commands/update.js

@@ -2,14 +2,36 @@
  * sequant update - Update templates from the package
  */
 import chalk from "chalk";
-import { diffLines } from "diff";
 import inquirer from "inquirer";
 import { spawnSync } from "child_process";
 import { getManifest, updateManifest, getPackageVersion, } from "../lib/manifest.js";
-import { getTemplateContent, listTemplateFiles, processTemplate, } from "../lib/templates.js";
+import { computeTemplateChanges } from "../lib/templates.js";
 import { getConfig, saveConfig } from "../lib/config.js";
 import { getStackConfig, PM_CONFIG, getPackageManagerCommands, } from "../lib/stacks.js";
-import { readFile, writeFile, fileExists } from "../lib/fs.js";
+import { writeFile } from "../lib/fs.js";
+import { isStdinTTY, isCI, getNonInteractiveReason } from "../lib/tty.js";
+/**
+ * True when `update` must not prompt: stdin is not a terminal (piped input) or
+ * we are running in a recognized CI environment. CI is checked explicitly
+ * because some runners allocate a pseudo-TTY — `isStdinTTY()` alone would let
+ * the prompt render and then hang an unattended job forever.
+ */
+function isNonInteractive() {
+    return !isStdinTTY() || isCI();
+}
+/**
+ * Print an actionable message and set a non-zero exit code when a prompt is
+ * required but the shell is non-interactive (piped/CI). Prevents inquirer from
+ * throwing a raw ExitPromptError stack trace. Callers should `return`
+ * immediately after.
+ */
+function refuseNonInteractive() {
+    const reason = getNonInteractiveReason() ?? "stdin is not a terminal";
+    console.error(chalk.red(`\n❌ non-interactive shell (${reason}): \`update\` needs to prompt to continue.`));
+    console.error(chalk.yellow("   Re-run with `--yes` (or `-y`) to apply updates without prompting,"));
+    console.error(chalk.yellow("   or use `--dry-run` to preview changes without applying."));
+    process.exitCode = 1;
+}
 export async function updateCommand(options) {
     console.log(chalk.blue("\nChecking for updates...\n"));
     console.log(chalk.yellow("Note: For seamless auto-updates, install sequant as a Claude Code plugin:\n" +
@@ -58,10 +80,19 @@ export async function updateCommand(options) {
         // Get package manager run command
         const pm = manifest.packageManager || "npm";
         const pmConfig = getPackageManagerCommands(pm);
-        if (options.force) {
+        if (options.force || options.yes) {
             tokens = { DEV_URL: defaultDevUrl, PM_RUN: pmConfig.run };
             console.log(chalk.blue(`Using default dev URL: ${defaultDevUrl}`));
         }
+        else if (options.dryRun) {
+            // Dry-run is read-only: preview with defaults, never prompt or persist.
+            tokens = { DEV_URL: defaultDevUrl, PM_RUN: pmConfig.run };
+            console.log(chalk.blue(`Using default dev URL for preview: ${defaultDevUrl}`));
+        }
+        else if (isNonInteractive()) {
+            refuseNonInteractive();
+            return;
+        }
         else {
             const { inputDevUrl } = await inquirer.prompt([
                 {
@@ -73,57 +104,22 @@ export async function updateCommand(options) {
             ]);
             tokens = { DEV_URL: inputDevUrl, PM_RUN: pmConfig.run };
         }
-        // Save the new config
+        // Persist the new config — but not on a dry-run preview, which must leave
+        // the project untouched.
         config = {
             tokens,
             stack: manifest.stack,
             initialized: manifest.installedAt,
         };
-        await saveConfig(config);
-        console.log(chalk.green("✔ Configuration saved\n"));
-    }
-    // Get list of template files
-    const templateFiles = await listTemplateFiles();
-    const changes = [];
-    for (const templatePath of templateFiles) {
-        const localPath = templatePath.replace("templates/", ".claude/");
-        // Skip if in .local directory (user customizations)
-        if (localPath.includes(".local/")) {
-            continue;
-        }
-        const templateContent = await getTemplateContent(templatePath);
-        const exists = await fileExists(localPath);
-        if (!exists) {
-            changes.push({ path: localPath, status: "new" });
-        }
-        else {
-            const localContent = await readFile(localPath);
-            if (localContent === templateContent) {
-                changes.push({ path: localPath, status: "unchanged" });
-            }
-            else {
-                // Check if there's a local override
-                const localOverridePath = localPath.replace(".claude/", ".claude/.local/");
-                const hasLocalOverride = await fileExists(localOverridePath);
-                if (hasLocalOverride) {
-                    changes.push({ path: localPath, status: "local-override" });
-                }
-                else {
-                    const diff = diffLines(localContent, templateContent)
-                        .map((part) => {
-                        const prefix = part.added ? "+" : part.removed ? "-" : " ";
-                        return part.value
-                            .split("\n")
-                            .filter((l) => l)
-                            .map((l) => `${prefix} ${l}`)
-                            .join("\n");
-                    })
-                        .join("\n");
-                    changes.push({ path: localPath, status: "modified", diff });
-                }
-            }
+        if (!options.dryRun) {
+            await saveConfig(config);
+            console.log(chalk.green("✔ Configuration saved\n"));
         }
     }
+    // Compute changes using the shared, variable-aware comparison.
+    // Templates are rendered (PROJECT_NAME, STACK_NOTES, etc.) before diffing,
+    // and in-place-customizable files (constitution) are protected as overrides.
+    const changes = await computeTemplateChanges(manifest.stack, tokens);
     // Show summary
     const newFiles = changes.filter((c) => c.status === "new");
     const modifiedFiles = changes.filter((c) => c.status === "modified");
@@ -134,8 +130,17 @@ export async function updateCommand(options) {
     console.log(chalk.yellow(`  Modified: ${modifiedFiles.length}`));
     console.log(chalk.gray(`  ✓ Unchanged: ${unchangedFiles.length}`));
     console.log(chalk.blue(`  Local overrides: ${localOverrides.length}`));
-    if (newFiles.length === 0 && modifiedFiles.length === 0) {
-        console.log(chalk.green("\n✔ Everything is up to date!"));
+    // Local overrides are protected by default — only --force overwrites them.
+    const applySet = options.force
+        ? [...newFiles, ...modifiedFiles, ...localOverrides]
+        : [...newFiles, ...modifiedFiles];
+    if (applySet.length === 0) {
+        if (localOverrides.length > 0) {
+            console.log(chalk.blue(`\n✔ No updates to apply. ${localOverrides.length} local override(s) protected (use --force to overwrite).`));
+        }
+        else {
+            console.log(chalk.green("\n✔ Everything is up to date!"));
+        }
         return;
     }
     // Show changes
@@ -154,12 +159,23 @@ export async function updateCommand(options) {
             console.log(chalk.green(`  ${file.path}`));
         }
     }
+    if (options.force && localOverrides.length > 0) {
+        console.log(chalk.bold("\nLocal overrides (forced overwrite):"));
+        for (const file of localOverrides) {
+            console.log(chalk.blue(`  ${file.path}`));
+        }
+    }
     if (options.dryRun) {
         console.log(chalk.gray("\n(dry-run mode - no changes made)"));
         return;
     }
-    // Confirm update
-    if (!options.force) {
+    // Confirm update. --yes and --force both auto-confirm; otherwise we need a
+    // prompt, which is impossible without a TTY — bail cleanly instead of crashing.
+    if (!options.force && !options.yes) {
+        if (isNonInteractive()) {
+            refuseNonInteractive();
+            return;
+        }
         const { proceed } = await inquirer.prompt([
             {
                 type: "confirm",
@@ -173,30 +189,19 @@ export async function updateCommand(options) {
             return;
         }
     }
-    // Apply updates
+    // Apply updates — content was already rendered with the shared variable set
+    // during change detection, so just write it.
     console.log(chalk.blue("\nApplying updates..."));
     let updated = 0;
-    // Build complete variables for template processing
-    const stackConfig = getStackConfig(manifest.stack);
-    const variables = {
-        ...stackConfig.variables,
-        ...tokens,
-        PROJECT_NAME: process.cwd().split("/").pop() || "project",
-        STACK: manifest.stack,
-    };
-    for (const file of [...newFiles, ...modifiedFiles]) {
-        const templatePath = file.path.replace(".claude/", "templates/");
-        let content = await getTemplateContent(templatePath);
-        // Process templates with tokens to replace {{DEV_URL}} etc.
-        content = processTemplate(content, variables);
-        await writeFile(file.path, content);
+    for (const file of applySet) {
+        await writeFile(file.path, file.rendered);
         updated++;
     }
     // Update manifest
     await updateManifest();
     console.log(chalk.green(`\n✔ Updated ${updated} files`));
     // Check if package.json was updated and run install
-    const packageJsonUpdated = [...newFiles, ...modifiedFiles].some((f) => f.path === "package.json" || f.path.endsWith("/package.json"));
+    const packageJsonUpdated = applySet.some((f) => f.path === "package.json" || f.path.endsWith("/package.json"));
     if (packageJsonUpdated) {
         // Use detected package manager or default to npm
         const pm = manifest.packageManager || "npm";

package/dist/src/lib/templates.d.ts

@@ -14,6 +14,56 @@ export declare function listTemplateFiles(): Promise<string[]>;
  * Get content of a template file
  */
 export declare function getTemplateContent(templatePath: string): Promise<string>;
+/**
+ * Files that are meant to be edited in place per project (e.g. the
+ * constitution). When one of these diverges from the rendered template
+ * without a parallel `.claude/.local/` file, it is treated as a protected
+ * local override rather than a stale "modified" file — so the default
+ * (non-`--force`) update/sync path never silently overwrites it.
+ */
+export declare const CUSTOMIZABLE_FILES: string[];
+/**
+ * Whether a local path is a customizable file edited in place per project.
+ */
+export declare function isCustomizableFile(localPath: string): boolean;
+/**
+ * Build the full set of template variables used when rendering templates.
+ *
+ * This is the single source of truth shared by `copyTemplates` (write time)
+ * and `computeTemplateChanges` (diff time) so the two can never drift — a
+ * mismatch here is what caused `constitution.md` to read as "modified" on
+ * every project (the diff used a different/incomplete variable set than the
+ * write). See #708.
+ */
+export declare function buildTemplateVariables(stack: string, tokens?: Record<string, string>, options?: {
+    additionalStacks?: string[];
+}): Promise<Record<string, string>>;
+/**
+ * A single template file's status relative to the installed copy.
+ */
+export interface TemplateChange {
+    /** Installed path under `.claude/` */
+    path: string;
+    /** Source template path under `templates/` */
+    templatePath: string;
+    status: "new" | "modified" | "unchanged" | "local-override";
+    /** Template content rendered with the project's variables */
+    rendered: string;
+    /** Unified-ish diff (installed → rendered), only set for `modified` */
+    diff?: string;
+}
+/**
+ * Compare bundled template content against what's installed under `.claude/`.
+ *
+ * Templates are rendered with the project's variables *before* comparison, so
+ * an unmodified file (e.g. a constitution with `{{PROJECT_NAME}}` expanded)
+ * reads as `unchanged` rather than `modified`. A file that diverges in place is
+ * `local-override` (skip-by-default) when it has a parallel `.claude/.local/`
+ * file or is in the customizable allow-list; otherwise it is `modified`.
+ */
+export declare function computeTemplateChanges(stack: string, tokens?: Record<string, string>, options?: {
+    additionalStacks?: string[];
+}): Promise<TemplateChange[]>;
 /**
  * Result of symlink creation attempt
  */

package/dist/src/lib/templates.js

@@ -4,6 +4,7 @@
 import { readdir, chmod } from "fs/promises";
 import { join, dirname, relative, isAbsolute } from "path";
 import { fileURLToPath } from "url";
+import { diffLines } from "diff";
 import { readFile, writeFile, ensureDir, fileExists, isSymlink, createSymlink, removeFileOrSymlink, } from "./fs.js";
 import { getPackageVersion } from "./manifest.js";
 const SKILLS_VERSION_PATH = ".claude/skills/.sequant-version";
@@ -12,6 +13,11 @@ import { isNativeWindows } from "./system.js";
 import { getProjectName } from "./project-name.js";
 // Get the package templates directory
 export function getTemplatesDir() {
+    // Allow overriding the templates source (used by tests; also lets the dir be
+    // relocated without relying on the compiled-output layout below).
+    if (process.env.SEQUANT_TEMPLATES_DIR) {
+        return process.env.SEQUANT_TEMPLATES_DIR;
+    }
     const __dirname = dirname(fileURLToPath(import.meta.url));
     // Compiled structure: dist/src/lib/templates.js
     // So we need ../../../templates to reach project root templates/
@@ -64,6 +70,132 @@ export async function getTemplateContent(templatePath) {
     const fullPath = join(templatesDir, relativePath);
     return readFile(fullPath);
 }
+/**
+ * Files that are meant to be edited in place per project (e.g. the
+ * constitution). When one of these diverges from the rendered template
+ * without a parallel `.claude/.local/` file, it is treated as a protected
+ * local override rather than a stale "modified" file — so the default
+ * (non-`--force`) update/sync path never silently overwrites it.
+ */
+export const CUSTOMIZABLE_FILES = [".claude/memory/constitution.md"];
+/**
+ * Whether a local path is a customizable file edited in place per project.
+ */
+export function isCustomizableFile(localPath) {
+    // Normalize OS path separators so the allow-list match holds on Windows,
+    // where template paths are assembled with backslashes (#708).
+    return CUSTOMIZABLE_FILES.includes(localPath.replace(/\\/g, "/"));
+}
+/**
+ * Build the full set of template variables used when rendering templates.
+ *
+ * This is the single source of truth shared by `copyTemplates` (write time)
+ * and `computeTemplateChanges` (diff time) so the two can never drift — a
+ * mismatch here is what caused `constitution.md` to read as "modified" on
+ * every project (the diff used a different/incomplete variable set than the
+ * write). See #708.
+ */
+export async function buildTemplateVariables(stack, tokens, options = {}) {
+    const stackConfig = getStackConfig(stack);
+    // Detect project name from available sources (package.json, Cargo.toml, etc.)
+    const projectName = await getProjectName();
+    // Get stack-specific notes for constitution template
+    // Use multi-stack notes if additional stacks are provided
+    const stackNotes = options.additionalStacks && options.additionalStacks.length > 0
+        ? getMultiStackNotes(stack, options.additionalStacks)
+        : getStackNotes(stack);
+    return {
+        ...stackConfig.variables,
+        ...tokens,
+        PROJECT_NAME: projectName,
+        STACK: stack,
+        STACK_NOTES: stackNotes,
+    };
+}
+/**
+ * Compare bundled template content against what's installed under `.claude/`.
+ *
+ * Templates are rendered with the project's variables *before* comparison, so
+ * an unmodified file (e.g. a constitution with `{{PROJECT_NAME}}` expanded)
+ * reads as `unchanged` rather than `modified`. A file that diverges in place is
+ * `local-override` (skip-by-default) when it has a parallel `.claude/.local/`
+ * file or is in the customizable allow-list; otherwise it is `modified`.
+ */
+export async function computeTemplateChanges(stack, tokens, options = {}) {
+    const variables = await buildTemplateVariables(stack, tokens, options);
+    const templateFiles = await listTemplateFiles();
+    const changes = [];
+    for (const templatePath of templateFiles) {
+        // Normalize separators first: listTemplateFiles builds paths with the OS
+        // separator (backslashes on Windows), but the prefix swap and the .local/
+        // and customizable-file checks below all assume forward slashes (#708).
+        const localPath = templatePath
+            .replace(/\\/g, "/")
+            .replace("templates/", ".claude/");
+        // Skip .local files (user customizations are never overwritten)
+        if (localPath.includes(".local/")) {
+            continue;
+        }
+        const rendered = processTemplate(await getTemplateContent(templatePath), variables);
+        const exists = await fileExists(localPath);
+        if (!exists) {
+            changes.push({ path: localPath, templatePath, status: "new", rendered });
+            continue;
+        }
+        const localContent = await readFile(localPath);
+        if (localContent === rendered) {
+            changes.push({
+                path: localPath,
+                templatePath,
+                status: "unchanged",
+                rendered,
+            });
+            continue;
+        }
+        // Content differs after rendering. Protect in-place customizations:
+        // a parallel `.claude/.local/` override, or a known customizable file.
+        //
+        // Note: this protects a managed file that was *edited in place* (e.g. the
+        // constitution) when a parallel `.claude/.local/` twin exists. It is NOT a
+        // skill-loading mechanism — the harness never loads `.claude/.local/skills/
+        // <name>/SKILL.md`, so a full-file SKILL.md shadow does nothing at runtime
+        // (#711). Skills are instead customized via a runtime overlay: each managed
+        // SKILL.md opens (before its first heading) with a directive to honor
+        // `.claude/.local/skills/<name>/overrides.md`, and that overrides file is
+        // auto-skipped above because it lives under `.local/`. The directive sits at
+        // the top, not end-of-file, so it fires reliably even in 3000-line skills.
+        // See docs/guides/customization.md.
+        const localOverridePath = localPath.replace(".claude/", ".claude/.local/");
+        const hasLocalOverride = await fileExists(localOverridePath);
+        if (hasLocalOverride || isCustomizableFile(localPath)) {
+            changes.push({
+                path: localPath,
+                templatePath,
+                status: "local-override",
+                rendered,
+            });
+            continue;
+        }
+        const diff = diffLines(localContent, rendered)
+            .map((part) => {
+            const prefix = part.added ? "+" : part.removed ? "-" : " ";
+            return part.value
+                .split("\n")
+                .filter((l) => l)
+                .map((l) => `${prefix} ${l}`)
+                .join("\n");
+        })
+            .join("\n");
+        changes.push({
+            path: localPath,
+            templatePath,
+            status: "modified",
+            rendered,
+            diff,
+        });
+    }
+    return changes;
+}
 /**
  * Create symlinks for files in a directory, with fallback to copy
  * @param srcDir Source directory containing template files
@@ -159,21 +291,8 @@ export async function symlinkDir(srcDir, destDir, options = {}) {
  */
 export async function copyTemplates(stack, tokens, options = {}) {
     const templatesDir = getTemplatesDir();
-    const stackConfig = getStackConfig(stack);
-    // Detect project name from available sources (package.json, Cargo.toml, etc.)
-    const projectName = await getProjectName();
-    // Get stack-specific notes for constitution template
-    // Use multi-stack notes if additional stacks are provided
-    const stackNotes = options.additionalStacks && options.additionalStacks.length > 0
-        ? getMultiStackNotes(stack, options.additionalStacks)
-        : getStackNotes(stack);
-    const variables = {
-        ...stackConfig.variables,
-        ...tokens,
-        PROJECT_NAME: projectName,
-        STACK: stack,
-        STACK_NOTES: stackNotes,
-    };
+    // Single source of truth for template variables (shared with the diff path)
+    const variables = await buildTemplateVariables(stack, tokens, options);
     async function copyDir(srcDir, destDir) {
         try {
             const entries = await readdir(srcDir, { withFileTypes: true });

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

@@ -19,6 +19,7 @@ export function App({ getSnapshot, onDone, }) {
     const [now, setNow] = useState(() => Date.now());
     const doneFired = useRef(false);
     const { stdout } = useStdout();
+    const [columns, setColumns] = useState(() => stdout?.columns ?? 80);
     // Snapshot poller (drives all state transitions).
     useEffect(() => {
         const id = setInterval(() => {
@@ -37,8 +38,29 @@ export function App({ getSnapshot, onDone, }) {
         const id = setInterval(() => setNow(Date.now()), 1000);
         return () => clearInterval(id);
     }, []);
-    const columns = stdout?.columns ?? 80;
-    const boxWidth = Math.min(columns - 2, 100);
+    // Track the terminal width reactively. ink's own resize handler re-renders
+    // the existing React tree but does NOT re-run this component, so a width read
+    // imperatively in render goes stale until the next poll. In that window ink
+    // repaints boxes at the old (now too-wide) width and the lines wrap, which
+    // misaligns the box borders into the duplicate/garbled frames. Updating
+    // `columns` from the resize event forces an immediate re-layout at the new
+    // width. A 1 Hz fallback poll covers terminals that don't emit `resize`.
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const sync = () => setColumns(stdout.columns ?? 80);
+        stdout.on("resize", sync);
+        sync();
+        const id = setInterval(sync, 1000);
+        return () => {
+            stdout.off("resize", sync);
+            clearInterval(id);
+        };
+    }, [stdout]);
+    // Clamp each box to the current terminal width (minus a 2-col safety margin)
+    // so a box line can never equal or exceed the terminal width and wrap.
+    const safeColumns = columns > 0 ? columns : 80;
+    const boxWidth = Math.max(20, Math.min(safeColumns - 2, 100));
     // #699 AC-4: clamp the number of boxes to the terminal height so a large
     // batch on a short terminal can't overflow the frame (parity with the plain
     // renderer's #624 row cap). Older completed issues collapse into `✔ N done`.

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

@@ -1,6 +1,6 @@
 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 { ACTIVE_PHASE_COLOR, 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";
@@ -20,7 +20,7 @@ export function IssueBox({ state, slot, width, now, }) {
     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 }), _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 }), _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) })) })] }));
+    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 }), _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, activeColor: ACTIVE_PHASE_COLOR }), 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 }), _jsx(Box, { flexDirection: "column", children: state.currentPhase ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "now " }), _jsx(Spinner, { color: ACTIVE_PHASE_COLOR }), _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) {
@@ -37,10 +37,10 @@ function statusLine(state) {
 function Divider({ width }) {
     return _jsx(Text, { color: DIVIDER_COLOR, children: "─".repeat(Math.max(0, width)) });
 }
-function PhaseProgression({ phases, borderColor, }) {
+function PhaseProgression({ phases, activeColor, }) {
     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}`));
+                return (_jsxs(Box, { children: [_jsx(PhaseGlyph, { status: p.status, label: p.name, activeColor: activeColor, elapsedMs: p.elapsedMs }), !isLast ? (_jsxs(Text, { color: DIVIDER_COLOR, children: ["   ", PHASE_GLYPHS.separator, "   "] })) : null] }, `${p.name}-${i}`));
             })] }));
 }
 function PhaseGlyph({ status, label, activeColor, elapsedMs, }) {

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

@@ -0,0 +1,25 @@
+/**
+ * Loader for the Ink TUI module that forces React into its production build.
+ *
+ * `react-reconciler` (pulled in by `ink`) selects its dev-vs-prod bundle from
+ * `process.env.NODE_ENV` **at module-evaluation time**. The development bundle
+ * emits a `performance.measure()` per component render and never calls
+ * `performance.clearMeasures()`. Driven by the TUI's 10 Hz poll over a long
+ * `sequant run`, those entries accumulate in Node's global performance buffer
+ * until it overflows its ~1,000,000-entry cap and prints
+ * `MaxPerformanceEntryBufferExceededWarning` to stderr — a memory leak that
+ * also corrupts the dashboard's in-place redraw (the stderr write scrolls the
+ * terminal between log-update frames; see #647/#664).
+ *
+ * The TUI module is the *only* importer of `react`/`ink`/`react-reconciler`,
+ * and it is always reached through a dynamic `import()`, so bracketing that one
+ * import with `NODE_ENV=production` caches the production reconciler (which has
+ * zero `performance.measure` calls). We restore `NODE_ENV` immediately after so
+ * spawned child processes (claude phases, `npm install`, build steps) do NOT
+ * inherit `NODE_ENV=production` — which would, e.g., make `npm install` skip
+ * devDependencies.
+ *
+ * Only overrides when `NODE_ENV` is unset/empty: an explicit `development` or
+ * `test` (the test runner) is respected so dev warnings remain available there.
+ */
+export declare function loadTui(): Promise<typeof import("./index.js")>;

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

@@ -0,0 +1,41 @@
+/**
+ * Loader for the Ink TUI module that forces React into its production build.
+ *
+ * `react-reconciler` (pulled in by `ink`) selects its dev-vs-prod bundle from
+ * `process.env.NODE_ENV` **at module-evaluation time**. The development bundle
+ * emits a `performance.measure()` per component render and never calls
+ * `performance.clearMeasures()`. Driven by the TUI's 10 Hz poll over a long
+ * `sequant run`, those entries accumulate in Node's global performance buffer
+ * until it overflows its ~1,000,000-entry cap and prints
+ * `MaxPerformanceEntryBufferExceededWarning` to stderr — a memory leak that
+ * also corrupts the dashboard's in-place redraw (the stderr write scrolls the
+ * terminal between log-update frames; see #647/#664).
+ *
+ * The TUI module is the *only* importer of `react`/`ink`/`react-reconciler`,
+ * and it is always reached through a dynamic `import()`, so bracketing that one
+ * import with `NODE_ENV=production` caches the production reconciler (which has
+ * zero `performance.measure` calls). We restore `NODE_ENV` immediately after so
+ * spawned child processes (claude phases, `npm install`, build steps) do NOT
+ * inherit `NODE_ENV=production` — which would, e.g., make `npm install` skip
+ * devDependencies.
+ *
+ * Only overrides when `NODE_ENV` is unset/empty: an explicit `development` or
+ * `test` (the test runner) is respected so dev warnings remain available there.
+ */
+export async function loadTui() {
+    const prev = process.env.NODE_ENV;
+    const override = prev === undefined || prev === "";
+    if (override)
+        process.env.NODE_ENV = "production";
+    try {
+        return await import("./index.js");
+    }
+    finally {
+        if (override) {
+            if (prev === undefined)
+                delete process.env.NODE_ENV;
+            else
+                process.env.NODE_ENV = prev;
+        }
+    }
+}

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

@@ -6,14 +6,32 @@
  * Respects `NO_COLOR` automatically via `ink`/`chalk`.
  */
 import type { IssueStatus, PhaseStatus } from "../../lib/workflow/run-state.js";
+/**
+ * Sequant brand accents, sourced from sequant-landing `src/styles/tokens.css`:
+ *   - `BRAND_ORANGE` is the primary brand color (`--color-primary` dark mode).
+ *   - `BRAND_GREEN` is the accent/success green (`--color-accent`).
+ *
+ * Used to brand the two color signals that matter most at a glance — the
+ * live/active phase and success — while issue-distinction (border rotation),
+ * failure (red), and dividers (gray) stay on robust named ANSI colors.
+ *
+ * Ink/chalk auto-downsamples hex to the nearest ANSI color on terminals
+ * without truecolor, and `NO_COLOR` still strips all color, so these degrade
+ * gracefully without a manual capability check.
+ */
+export declare const BRAND_ORANGE: "#FF8012";
+export declare const BRAND_GREEN: "#10b981";
 /** 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";
+export type BorderColor = (typeof BORDER_ROTATION)[number] | typeof BRAND_GREEN | typeof BRAND_ORANGE | "red" | "gray";
 /** Gray used for horizontal dividers inside each box. */
 export declare const DIVIDER_COLOR: "gray";
-/** Green used for the rolled-up `✔ N done` summary line (#699, parity with the
+/** Brand orange for the live/active phase spinner — the one element the eye
+ *  tracks. Border rotation still distinguishes concurrent issues. */
+export declare const ACTIVE_PHASE_COLOR: "#FF8012";
+/** Brand green for the rolled-up `✔ N done` summary line (#699, parity with the
  *  plain renderer's #624 rollup). */
-export declare const ROLLUP_COLOR: "green";
+export declare const ROLLUP_COLOR: "#10b981";
 /**
  * Pick the border color for an issue.
  * Failed / passed states win over rotation; otherwise rotate by slot.