sequant 2.3.0 → 2.4.0

package/dist/src/commands/watch.js

@@ -6,6 +6,8 @@
 import { existsSync, statSync, createReadStream, watch } from "fs";
 import chalk from "chalk";
 import { outboxPathFor } from "../lib/relay/paths.js";
+import { listArchives } from "../lib/relay/archive.js";
+import { readPidFile } from "../lib/relay/pid.js";
 import { StateManager } from "../lib/workflow/state-manager.js";
 import { RelayResponseSchema } from "../lib/relay/types.js";
 function formatTimestamp(iso) {
@@ -82,8 +84,10 @@ export async function watchCommand(argsAndOptions) {
     }
     const stateManager = new StateManager();
     const issueState = await stateManager.getIssueState(issueNumber);
+    const cwd = options.cwd ?? process.cwd();
     const outboxPath = outboxPathFor(issueNumber, {
         worktreePath: issueState?.worktree,
+        cwd,
     });
     const pollIntervalMs = options.pollIntervalMs ?? 200;
     const tail = { offset: 0, partial: "" };
@@ -91,16 +95,43 @@ export async function watchCommand(argsAndOptions) {
     if (existsSync(outboxPath)) {
         tail.offset = statSync(outboxPath).size;
     }
+    // Dead-relay detection (#645, Gap 3). The pidfile is written by activateRelay
+    // and removed by deactivateRelay. If it's absent and the outbox is absent at
+    // startup, there is nothing alive to watch — print a useful pointer and exit.
+    const initialPidPresent = readPidFile(issueNumber, cwd) !== null;
+    const initialOutboxPresent = existsSync(outboxPath);
+    if (!initialPidPresent && !initialOutboxPresent) {
+        const archives = listArchives(issueNumber, cwd);
+        const summary = `No active relay for #${issueNumber}.`;
+        const hint = archives[0]
+            ? ` Most recent archive: ${archives[0]}`
+            : " (no archived runs found)";
+        if (options.json) {
+            console.log(JSON.stringify({
+                ok: false,
+                issue: issueNumber,
+                reason: "no-active-relay",
+                archive: archives[0] ?? null,
+            }));
+        }
+        else {
+            console.log(chalk.yellow(summary + hint));
+        }
+        return;
+    }
     if (!options.json) {
         console.log(chalk.gray(`Watching #${issueNumber} outbox — Ctrl+C to stop`));
     }
     let stopped = false;
-    const stop = () => {
+    let endReason = null;
+    const stop = (reason = "signal") => {
         stopped = true;
+        if (!endReason)
+            endReason = reason;
     };
-    options.signal?.addEventListener("abort", stop);
+    options.signal?.addEventListener("abort", () => stop("signal"));
     process.on("SIGINT", () => {
-        stop();
+        stop("signal");
         if (!options.json)
             console.log(chalk.gray("\nStopped watching."));
         process.exit(0);
@@ -125,6 +156,7 @@ export async function watchCommand(argsAndOptions) {
     };
     // Polling loop — also used as a heartbeat when fs.watch is active so we
     // don't miss events on filesystems where watch is unreliable.
+    let sawLivePid = initialPidPresent;
     while (!stopped) {
         try {
             const replies = await readNewLines(outboxPath, tail);
@@ -133,6 +165,23 @@ export async function watchCommand(argsAndOptions) {
         catch {
             /* transient — try again next tick */
         }
+        // Dead-relay detection (#645, Gap 3). Once we've seen a live pidfile, its
+        // absence means the run has deactivated relay (archive complete). Drain
+        // one more poll for late writes, then exit cleanly.
+        const pidAlive = readPidFile(issueNumber, cwd) !== null;
+        if (sawLivePid && !pidAlive) {
+            try {
+                const finalReplies = await readNewLines(outboxPath, tail);
+                emit(finalReplies);
+            }
+            catch {
+                /* swallow */
+            }
+            stop("relay-ended");
+            break;
+        }
+        if (pidAlive)
+            sawLivePid = true;
         await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
     if (watcher) {
@@ -144,4 +193,19 @@ export async function watchCommand(argsAndOptions) {
         }
     }
     void useWatcher; // currently unused beyond best-effort init
+    if (endReason === "relay-ended") {
+        const archives = listArchives(issueNumber, cwd);
+        if (options.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                issue: issueNumber,
+                reason: "relay-ended",
+                archive: archives[0] ?? null,
+            }));
+        }
+        else {
+            const hint = archives[0] ? ` Archive: ${archives[0]}` : "";
+            console.log(chalk.gray(`Run for #${issueNumber} ended.${hint}`));
+        }
+    }
 }

package/dist/src/lib/assess-collision-detect.js

@@ -208,7 +208,7 @@ export function formatCollisionAnnotations(results) {
         if (r.issues.length >= 3 && !chainSuggestion) {
             const ids = r.issues.join(" ");
             chainSuggestion =
-                `Chain: npx sequant run ${ids} --chain --qa-gate -q   ` +
+                `Chain: npx sequant run ${ids} --chain --qa-gate -Q   ` +
                     `# alternative — ${r.issues.length} issues modify ${r.file} ` +
                     `(chain length≥3 historically 1/6 = 17%; see docs/reference/chain-mode-analysis-2026-05.md)`;
         }

package/dist/src/lib/cli-ui/run-renderer-types.d.ts

@@ -76,6 +76,15 @@ export interface IssueRegistration {
      * is known) and switches to the normal phase header once spec completes.
      */
     autoDetect?: boolean;
+    /**
+     * #672 AC-2: the resolved phase pipeline for this issue. When set, the live
+     * zone seeds one pending cell per planned phase so users see the full
+     * roadmap before any phase fires. Cells transition pending → running → ✔/✘
+     * in place via subsequent `onEvent` calls (#672 AC-3). When the plan isn't
+     * known at registration time (auto-detect mode), call `setPhasePlan` once
+     * spec resolves it.
+     */
+    plannedPhases?: string[];
 }
 /** Per-issue summary fields used by the final summary table. */
 export interface IssueSummary {
@@ -106,12 +115,26 @@ export interface RunRenderer {
     registerIssue(reg: IssueRegistration): void;
     /** Feed a progress event from batch-executor. */
     onEvent(event: ProgressEvent): void;
+    /**
+     * #672 AC-2: set or replace the planned phase pipeline for an already-
+     * registered issue. Used by auto-detect mode after spec resolves the plan.
+     * No-op for unregistered issues (defensive — same as `setPullRequest`).
+     * An empty `phases` array clears the plan back to streaming-only behaviour.
+     */
+    setPhasePlan(issue: number, phases: string[]): void;
     /** Mark an issue as completed with PR info. Called by orchestrator. */
     setPullRequest(issue: number, prNumber: number, prUrl: string): void;
     /** Pause live updates so verbose streaming can write through. */
     pause(): void;
     /** Resume live updates after streaming ends. */
     resume(): void;
+    /**
+     * #647 AC-3: print a notice line above the live zone without breaking
+     * log-update's cursor model. Use for retry/fallback messages emitted
+     * from outside the renderer's event flow (e.g., phase-executor retry
+     * paths).
+     */
+    appendNotice(message: string): void;
     /** Render the final summary block. */
     renderSummary(input: SummaryRenderInput): void;
     /** Tear down timers, cursor state, signal listeners. */
@@ -173,6 +196,22 @@ export interface RenderOptions {
      * Default: false (matches existing displaySummary behaviour).
      */
     alwaysRenderSummary?: boolean;
+    /**
+     * #647: inject a `log-update` instance (typically built via
+     * `createLogUpdate(stream)` against a custom stream). Used by the
+     * scrollback-harness regression test to drive the real `log-update`
+     * through a virtual terminal that tracks scrollback. When set, this takes
+     * precedence over both `stdoutWrite` (for the log-update path) and the
+     * default `process.stdout`-bound `logUpdate` import.
+     *
+     * Production code never sets this. Tests that need to assert on
+     * `log-update`'s actual erase semantics use it to replace the test stub.
+     */
+    logUpdateInstance?: {
+        (text: string): void;
+        clear(): void;
+        done(): void;
+    };
 }
 /**
  * Mode the renderer should run in. Auto-detected by `createRunRenderer` from

package/dist/src/lib/cli-ui/run-renderer.d.ts

@@ -13,6 +13,7 @@
  *
  * See issue #618.
  */
+import type { PhasePauseHandle } from "../workflow/types.js";
 import type { IssueRegistration, IssueState, ProgressEvent, RenderOptions, RendererMode, RunRenderer, SummaryRenderInput } from "./run-renderer-types.js";
 /**
  * #624 Item 4: normalized failure signature for dedup decisions.
@@ -35,7 +36,7 @@ export declare function failureSignature(error: string | undefined): string;
  * (no iteration, iteration === 1, or non-positive).
  */
 export declare function formatRetrySuffix(iteration: number | undefined, maxIterations: number, kind: "events" | "header"): string;
-declare abstract class BaseRenderer implements RunRenderer {
+declare abstract class BaseRenderer implements RunRenderer, PhasePauseHandle {
     protected readonly issues: Map<number, IssueState>;
     protected readonly stdoutWrite: (s: string) => void;
     protected readonly stderrWrite: (s: string) => void;
@@ -47,10 +48,18 @@ declare abstract class BaseRenderer implements RunRenderer {
     protected disposed: boolean;
     constructor(options: RenderOptions);
     registerIssue(reg: IssueRegistration): void;
+    setPhasePlan(issue: number, phases: string[]): void;
     onEvent(event: ProgressEvent): void;
     setPullRequest(issue: number, prNumber: number, prUrl: string): void;
     pause(): void;
     resume(): void;
+    /**
+     * #647 AC-3: default notice path — just write to the renderer's stdout
+     * channel. NonTTYRenderer keeps this default (no live zone to manage).
+     * TTYRenderer overrides to clear the live zone before writing so
+     * log-update's cursor model stays consistent with the actual terminal.
+     */
+    appendNotice(message: string): void;
     abstract renderSummary(input: SummaryRenderInput): void;
     dispose(): void;
     protected applyEvent(state: IssueState, event: ProgressEvent): void;
@@ -134,6 +143,14 @@ export declare class TTYRenderer extends BaseRenderer {
     /**
      * #624 Derived AC-D1: expose the test-only log-update stub. Returns `null`
      * when not in test mode (production renders go through real `log-update`).
+     *
+     * #647 AC-D3 warning: this stub does NOT model `log-update`'s ANSI cursor
+     * or scrollback semantics. Tests that assert on `stub.lastFrame` only see
+     * the most recent frame, not whether earlier frames remained stranded in
+     * scrollback. Header-count / duplicate-header assertions MUST use
+     * `scrollback-harness.ts` (real `createLogUpdate` + VirtualTerminal),
+     * otherwise they will pass green even when the production rendering is
+     * broken — see #624 for the precedent.
      */
     getTestStub(): TTYTestStub | null;
     private startLiveTimer;
@@ -150,6 +167,15 @@ export declare class TTYRenderer extends BaseRenderer {
     renderSummary(input: SummaryRenderInput): void;
     protected onPause(): void;
     protected onResume(): void;
+    /**
+     * #647 AC-3: TTYRenderer override. Writes the notice above the live zone
+     * the same way `appendEventLine` does (clear → write → redraw), so
+     * log-update's `previousLineCount` stays consistent with the actual
+     * terminal state. If the renderer is already paused (e.g., during
+     * verbose subprocess streaming), skip the clear/redraw and just write;
+     * the eventual `resume()` will redraw cleanly.
+     */
+    appendNotice(message: string): void;
     protected onDispose(): void;
     private getColumns;
     /**

package/dist/src/lib/cli-ui/run-renderer.js

@@ -13,6 +13,8 @@
  *
  * See issue #618.
  */
+import fs from "node:fs";
+import path from "node:path";
 import chalk from "chalk";
 import logUpdate from "log-update";
 import stringWidth from "string-width";
@@ -118,6 +120,11 @@ class BaseRenderer {
     registerIssue(reg) {
         if (this.issues.has(reg.issueNumber))
             return;
+        // #672 AC-2: seed pending cells when the plan is known at registration.
+        // Empty arrays fall back to streaming-only behaviour (AC-2 edge case).
+        const phases = reg.plannedPhases && reg.plannedPhases.length > 0
+            ? reg.plannedPhases.map((name) => ({ name, status: "pending" }))
+            : [];
         this.issues.set(reg.issueNumber, {
             issueNumber: reg.issueNumber,
             title: reg.title,
@@ -125,10 +132,30 @@ class BaseRenderer {
             branch: reg.branch,
             autoDetect: reg.autoDetect,
             status: "queued",
-            phases: [],
+            phases,
         });
         this.afterStateChange();
     }
+    setPhasePlan(issue, phases) {
+        const state = this.issues.get(issue);
+        if (!state)
+            return;
+        // #672 AC-2: rebuild the phase array from the resolved plan, preserving
+        // any phase state already captured from events that fired before the plan
+        // resolved (e.g. spec ran first in auto-detect mode and finished before
+        // setPhasePlan landed). Phases already seen keep their state; new planned
+        // phases enter as `pending`.
+        const existing = new Map(state.phases.map((p) => [p.name, p]));
+        state.phases = phases.map((name) => existing.get(name) ?? { name, status: "pending" });
+        // Any previously-seen phases that aren't in the new plan still belong on
+        // the row — they actually ran. Append them at the end so the planned order
+        // is preserved for unplayed phases.
+        for (const prev of existing.values()) {
+            if (!phases.includes(prev.name))
+                state.phases.push(prev);
+        }
+        this.afterStateChange();
+    }
     onEvent(event) {
         if (this.disposed)
             return;
@@ -162,6 +189,17 @@ class BaseRenderer {
         this.paused = false;
         this.onResume();
     }
+    /**
+     * #647 AC-3: default notice path — just write to the renderer's stdout
+     * channel. NonTTYRenderer keeps this default (no live zone to manage).
+     * TTYRenderer overrides to clear the live zone before writing so
+     * log-update's cursor model stays consistent with the actual terminal.
+     */
+    appendNotice(message) {
+        if (this.disposed)
+            return;
+        this.stdoutWrite(message + "\n");
+    }
     dispose() {
         if (this.disposed)
             return;
@@ -452,10 +490,120 @@ export class TTYRenderer extends BaseRenderer {
             options.multiIssueRowCap ?? DEFAULT_MULTI_ISSUE_ROW_CAP;
         this.maxLoopIterations =
             options.maxLoopIterations ?? DEFAULT_MAX_LOOP_ITERATIONS;
+        // #647 AC-1: render-state instrumentation gated on `SEQUANT_DEBUG_RENDERER=1`.
+        // Emits one JSON line per log-update callsite so a production replay shows
+        // exactly which mechanism from the #647 issue body is firing (column/row
+        // mismatch, wrap-induced row inflation, etc.). The trace doubles as the
+        // evidence required by AC-1's "Pick the fix direction from §2 only after
+        // instrumentation confirms the mechanism." sub-bullet.
+        //
+        // #664: routes to a file sink instead of stderr. In any terminal where
+        // stdout and stderr share a pty (the normal case), stderr writes scroll
+        // the terminal between log-update redraws — log-update has no record of
+        // them, so `eraseLines(previousLineCount)` misses rows and the prior
+        // frame's top survives in scrollback. The AC-1 capture's "2181×" headline
+        // was 2171× of this amplifier, not the underlying #647 bug. Sinking to
+        // a file removes the amplifier while preserving identical JSON schema +
+        // per-op cadence for diagnostic replay.
+        const debugEnabled = process.env.SEQUANT_DEBUG_RENDERER === "1";
+        let debugFd = null;
+        if (debugEnabled) {
+            // Default sink resolves against `process.cwd()` — matches the rest of
+            // the codebase's `.sequant/` convention (see `src/lib/relay/paths.ts:39`,
+            // `src/lib/ci/config.ts:42`). Invoking `sequant` from a subdirectory
+            // puts the file under that subdirectory's `.sequant/`, where the project
+            // root's `.sequant/*` gitignore does not reach — pass an absolute
+            // override via `SEQUANT_DEBUG_RENDERER_FILE` if that's a concern.
+            //
+            // `||` not `??`: treat an empty SEQUANT_DEBUG_RENDERER_FILE as "use
+            // default" rather than passing "" to openSync (which would throw and
+            // suppress all debug output via the fallback path). Locked in by the
+            // "AC-2 + empty string" test in scrollback-harness.test.ts.
+            const debugPath = process.env.SEQUANT_DEBUG_RENDERER_FILE ||
+                path.join(process.cwd(), ".sequant", "debug-renderer.jsonl");
+            try {
+                fs.mkdirSync(path.dirname(debugPath), { recursive: true });
+                debugFd = fs.openSync(debugPath, "a");
+            }
+            catch (err) {
+                // Fall through to no-op rather than crashing the run. One-shot
+                // startup notice so the user sees why debug output didn't appear.
+                const msg = err instanceof Error ? err.message : String(err);
+                this.stderrWrite(`SEQUANT_DEBUG_RENDERER: file sink unavailable at ${debugPath} (${msg}), debug output suppressed\n`);
+                debugFd = null;
+            }
+        }
+        let frameCounter = 0;
+        const emitDebug = (op, text) => {
+            if (debugFd === null)
+                return;
+            // log-update's render path is roughly:
+            //   output = wrapAnsi(text + "\n", stream.columns, {trim:false, hard:true})
+            //   previousLineCount = output.split("\n").length
+            // So `previousLineCount` is wrap-aware: a 100-char line in an 80-col
+            // stream counts as 2, not 1. We approximate that here using `stringWidth`
+            // (already a dep) instead of `text.split("\n").length`. The metric is
+            // intentionally an approximation — wrap-ansi has word-breaking nuances
+            // — but it's correct enough to spot the diagnostic case AC-1 cares
+            // about: when this count diverges from the actual on-terminal row
+            // count, log-update's `eraseLines` will undershoot.
+            const streamCols = process.stdout.columns ?? this.getColumns() ?? Infinity;
+            let logicalLines;
+            let wrappedLineCount;
+            if (text !== undefined) {
+                const lines = text.split("\n");
+                logicalLines = lines.length + (text.endsWith("\n") ? 0 : 1);
+                wrappedLineCount = lines.reduce((acc, line) => {
+                    const w = stringWidth(line);
+                    return acc + Math.max(1, Math.ceil(w / streamCols));
+                }, 0);
+                // log-update appends a trailing \n before wrapping, so count it.
+                if (!text.endsWith("\n"))
+                    wrappedLineCount++;
+            }
+            const record = {
+                t: this.now() - this.runStartedAt,
+                op,
+                frame: frameCounter,
+                rendererCols: this.getColumns(),
+                rendererRows: this.getRows(),
+                stdoutCols: process.stdout.columns ?? null,
+                stdoutRows: process.stdout.rows ?? null,
+                logicalLines,
+                wrappedLineCount,
+            };
+            // Sync append. `O_APPEND` guarantees atomic per-line writes on POSIX,
+            // and the fd lives for the process lifetime — no close on dispose
+            // because late-fire callbacks could still emit after teardown begins.
+            fs.writeSync(debugFd, `SEQUANT_DEBUG_RENDERER ${JSON.stringify(record)}\n`);
+        };
         // log-update writes to process.stdout via a mutable global instance. When
         // tests inject `stdoutWrite`, route renders through it instead so capture
-        // works deterministically.
-        if (options.stdoutWrite) {
+        // works deterministically. The #647 harness tests instead inject a real
+        // `log-update` instance bound to a virtual terminal — that path bypasses
+        // the stub so we can assert on actual cursor/erase semantics.
+        if (options.logUpdateInstance) {
+            // #647: harness path — drive a real `createLogUpdate(stream)` instance
+            // so the scrollback-aware regression test sees the same ANSI cursor
+            // operations a production user's terminal would receive. Stub is left
+            // null because the harness asserts on the VirtualTerminal directly.
+            const lu = options.logUpdateInstance;
+            this._testStub = null;
+            this.logUpdateImpl = (text) => {
+                frameCounter++;
+                emitDebug("impl", text);
+                lu(text);
+            };
+            this.logUpdateClear = () => {
+                emitDebug("clear");
+                lu.clear();
+            };
+            this.logUpdateDone = () => {
+                emitDebug("done");
+                lu.done();
+            };
+        }
+        else if (options.stdoutWrite) {
             // #624 Derived AC-D1: replacement-aware test stub. Tracks each frame
             // replacement so tests can assert on frame churn without parsing buf.out.
             // `clearCalls` / `doneCalls` verify the renderer actually invokes the
@@ -468,25 +616,39 @@ export class TTYRenderer extends BaseRenderer {
             };
             this._testStub = stub;
             this.logUpdateImpl = (text) => {
+                frameCounter++;
+                emitDebug("impl", text);
                 if (stub.lastFrame)
                     stub.replacementCount++;
                 stub.lastFrame = text;
                 options.stdoutWrite(text + "\n");
             };
             this.logUpdateClear = () => {
+                emitDebug("clear");
                 stub.clearCalls++;
                 stub.lastFrame = "";
             };
             this.logUpdateDone = () => {
+                emitDebug("done");
                 stub.doneCalls++;
                 stub.lastFrame = "";
             };
         }
         else {
             this._testStub = null;
-            this.logUpdateImpl = (text) => logUpdate(text);
-            this.logUpdateClear = () => logUpdate.clear();
-            this.logUpdateDone = () => logUpdate.done();
+            this.logUpdateImpl = (text) => {
+                frameCounter++;
+                emitDebug("impl", text);
+                logUpdate(text);
+            };
+            this.logUpdateClear = () => {
+                emitDebug("clear");
+                logUpdate.clear();
+            };
+            this.logUpdateDone = () => {
+                emitDebug("done");
+                logUpdate.done();
+            };
         }
         this.startLiveTimer();
         this.installSignalListeners();
@@ -494,6 +656,14 @@ export class TTYRenderer extends BaseRenderer {
     /**
      * #624 Derived AC-D1: expose the test-only log-update stub. Returns `null`
      * when not in test mode (production renders go through real `log-update`).
+     *
+     * #647 AC-D3 warning: this stub does NOT model `log-update`'s ANSI cursor
+     * or scrollback semantics. Tests that assert on `stub.lastFrame` only see
+     * the most recent frame, not whether earlier frames remained stranded in
+     * scrollback. Header-count / duplicate-header assertions MUST use
+     * `scrollback-harness.ts` (real `createLogUpdate` + VirtualTerminal),
+     * otherwise they will pass green even when the production rendering is
+     * broken — see #624 for the precedent.
      */
     getTestStub() {
         return this._testStub;
@@ -542,6 +712,14 @@ export class TTYRenderer extends BaseRenderer {
         this.redraw();
     }
     appendEventLine(event, state) {
+        // #672 AC-1: drop the `▸ start` journal line. The live zone already shows
+        // the phase as running in place, so appending a permanent scrollback line
+        // duplicates that information and produces the "two-row" visual reported
+        // in #672. `complete` and `failed` still append (they are the durable
+        // record of what ran). The redraw in `afterEvent` keeps the live zone
+        // fresh so the transition pending → running is still visible.
+        if (event.event === "start")
+            return;
         // Clear the live zone so the appended event becomes a real `console.log`
         // line above it; the live zone redraws below.
         this.logUpdateClear();
@@ -553,10 +731,7 @@ export class TTYRenderer extends BaseRenderer {
             ? ""
             : formatRetrySuffix(phase?.loopIteration, this.maxLoopIterations, "events");
         let line;
-        if (event.event === "start") {
-            line = `  ${c.cyan("▸")} #${event.issue} ${event.phase}${retrySuffix}`;
-        }
-        else if (event.event === "complete") {
+        if (event.event === "complete") {
             const durStr = event.durationSeconds !== undefined
                 ? `  ${formatElapsedTime(event.durationSeconds)}`
                 : "";
@@ -619,6 +794,25 @@ export class TTYRenderer extends BaseRenderer {
         // Live zone redraws on next tick / event automatically.
         this.redraw();
     }
+    /**
+     * #647 AC-3: TTYRenderer override. Writes the notice above the live zone
+     * the same way `appendEventLine` does (clear → write → redraw), so
+     * log-update's `previousLineCount` stays consistent with the actual
+     * terminal state. If the renderer is already paused (e.g., during
+     * verbose subprocess streaming), skip the clear/redraw and just write;
+     * the eventual `resume()` will redraw cleanly.
+     */
+    appendNotice(message) {
+        if (this.disposed)
+            return;
+        if (this.paused) {
+            this.stdoutWrite(message + "\n");
+            return;
+        }
+        this.logUpdateClear();
+        this.stdoutWrite(message + "\n");
+        this.redraw();
+    }
     onDispose() {
         if (this.liveTimer !== null) {
             clearInterval(this.liveTimer);
@@ -732,8 +926,16 @@ export class TTYRenderer extends BaseRenderer {
         const state = [...this.issues.values()][0];
         const c = colorize(this.noColor);
         const header = `SEQUANT WORKFLOW · #${state.issueNumber} · ${formatElapsedTime((this.now() - this.runStartedAt) / 1000)} elapsed`;
+        // #647 AC-3: cap at 78 (not 110) so the rendered grid stays narrower than
+        // any standard 80-col terminal even when the reported `cols` is wider than
+        // the actual terminal (e.g. cached `process.stdout.columns`, TTY emulation
+        // layers, `npx` piped stdout). Total drawn width is
+        // `labelWidth + valueWidth + 9` (2 leading spaces + 3 box-drawing
+        // intersection chars + 4 cell-padding spaces); the prior `- 7` formula
+        // additionally produced rows 2 chars wider than `cols`, compounding the
+        // wrap. Both errors removed.
         const labelWidth = 10;
-        const innerWidth = Math.max(40, Math.min(cols, 110) - labelWidth - 7);
+        const innerWidth = Math.max(40, Math.min(cols, 78) - labelWidth - 9);
         const valueWidth = innerWidth;
         const rows = [];
         const titleSuffix = state.title ? ` — ${state.title}` : "";
@@ -761,8 +963,13 @@ export class TTYRenderer extends BaseRenderer {
         // is appended.
         const c = colorize(this.noColor);
         const header = `SEQUANT WORKFLOW · ${this.runHeader()}`;
+        // #647 AC-3: see note in `renderSingleIssueFrame` — cap at 78 (not 110) so
+        // the rendered grid stays narrower than any standard 80-col terminal under
+        // width-misreporting conditions. The box-drawing total is
+        // `issueColW + statusColW + 9`; the prior `- 7` formula compounded the
+        // overflow.
         const issueColW = 8;
-        const innerWidth = Math.max(50, Math.min(cols, 110) - issueColW - 7);
+        const innerWidth = Math.max(50, Math.min(cols, 78) - issueColW - 9);
         const statusColW = innerWidth;
         const lines = [c.bold(header), ""];
         if (this.banner)
@@ -902,7 +1109,13 @@ export class TTYRenderer extends BaseRenderer {
     statusSubLines(state) {
         const c = colorize(this.noColor);
         const lines = [];
-        if (state.status === "running" || state.status === "queued") {
+        // #672 AC-3: include the failed state so the row that just failed still
+        // renders its phase cells (the failing cell shows ✘ in place). Without
+        // this, a failure on an unstarted phase hides the entire pipeline behind
+        // the header summary, making it impossible to see how far the run got.
+        if (state.status === "running" ||
+            state.status === "queued" ||
+            state.status === "failed") {
             const seq = state.phases
                 .filter((p) => p.name !== "loop")
                 .map((p) => {
@@ -912,7 +1125,11 @@ export class TTYRenderer extends BaseRenderer {
                     return c.red(`${p.name} ✘`);
                 if (p.status === "running")
                     return c.cyan(`${p.name} running`);
-                return c.gray(`${p.name} queued`);
+                // #672 AC-3: pending cells render as `name –` (en dash) so the live
+                // zone reads as a roadmap when a phase plan is set via registration
+                // or `setPhasePlan`. Without a plan, no pending cells are seeded so
+                // this branch is unreachable — preserving prior single-row output.
+                return c.gray(`${p.name} –`);
             })
                 .join("  →  ");
             if (seq)