@ze-norm/cli 0.11.2 → 0.11.5

package/dist/commands/work-render.js

@@ -0,0 +1,590 @@
+/**
+ * Agent-output renderers for `zenorm work`.
+ *
+ * Background: `zenorm work` runs each claimed task by spawning a headless coding
+ * agent (`claude` / `codex`). Those agents' *interactive* TUIs show a clean,
+ * readable transcript (assistant prose + one-line tool calls). Their headless
+ * modes do NOT: `claude -p` text mode hides every tool call, and the JSON event
+ * streams (`--output-format stream-json`, `codex exec --json`) are raw JSONL —
+ * unreadable noise.
+ *
+ * These renderers consume the JSON event streams and re-emit a compact transcript
+ * that mirrors what you'd see in each agent's interactive session — a read-only
+ * view of the agent working — while dropping protocol/metadata noise (hooks,
+ * init banners, token counts, rate-limit pings, raw tool-result bodies).
+ *
+ * Pure functions over single events so they can be unit-tested without spawning
+ * anything. The caller (`AgentRunner`) feeds newline-delimited stdout chunks to a
+ * `LineSplitter` + `renderClaudeEvent` / `renderCodexEvent`.
+ */
+const noColor = "NO_COLOR" in process.env;
+const RESET = noColor ? "" : "\x1b[0m";
+const DIM = noColor ? "" : "\x1b[2m";
+const CYAN = noColor ? "" : "\x1b[36m";
+const BRIGHT_CYAN = noColor ? "" : "\x1b[96m";
+const BLUE = noColor ? "" : "\x1b[34m";
+const GREEN = noColor ? "" : "\x1b[32m";
+const YELLOW = noColor ? "" : "\x1b[33m";
+const RED = noColor ? "" : "\x1b[31m";
+const MAGENTA = noColor ? "" : "\x1b[35m";
+const BOLD = noColor ? "" : "\x1b[1m";
+// A muted grey for the metadata box border (Qwen-style framing). 256-color so
+// it degrades on basic terminals; collapses to "" under NO_COLOR.
+const BORDER = noColor ? "" : "\x1b[38;5;240m";
+// Teal line color for the logo's extruded "3D" outline (the silhouette traced
+// one cell down-right behind the solid bright-cyan glyph faces, Qwen-style).
+const OUTLINE = noColor ? "" : "\x1b[38;5;30m";
+const TOOL_STYLES = {
+    // ◆ write/mutation — green, the calls that change the repo.
+    edit: { glyph: "◆", color: GREEN },
+    // ▸ shell — yellow, commands with side effects worth noticing.
+    run: { glyph: "▸", color: YELLOW },
+    // ○ read — blue, low-stakes inspection.
+    read: { glyph: "○", color: BLUE },
+    // ◇ search — cyan, glob/grep discovery.
+    search: { glyph: "◇", color: CYAN },
+    // ◈ planning — magenta, TodoWrite/task bookkeeping.
+    plan: { glyph: "◈", color: MAGENTA },
+    // ● everything else — plain cyan bullet (the old default).
+    other: { glyph: "●", color: CYAN },
+};
+/** Classify a tool by name into a display bucket (see `ToolKind`). */
+function toolKind(name) {
+    switch (name) {
+        case "Read":
+        case "NotebookRead":
+            return "read";
+        case "Edit":
+        case "Write":
+        case "NotebookEdit":
+        case "MultiEdit":
+            return "edit";
+        case "Bash":
+        case "BashOutput":
+            return "run";
+        case "Glob":
+        case "Grep":
+            return "search";
+        case "TodoWrite":
+            return "plan";
+        default:
+            return "other";
+    }
+}
+/** Format a classified tool summary as a colored, glyph-prefixed bullet line. */
+function toolLine(name, summary) {
+    const { glyph, color } = TOOL_STYLES[toolKind(name)];
+    return `${color}${glyph}${RESET} ${summary}`;
+}
+/**
+ * Accumulates raw stdout bytes and yields complete lines. The agent JSON streams
+ * are newline-delimited JSON; a chunk may split a line, so we buffer the tail.
+ */
+export class LineSplitter {
+    buffer = "";
+    /** Push a chunk; returns any newly-completed lines (without the newline). */
+    push(chunk) {
+        this.buffer += chunk;
+        const parts = this.buffer.split("\n");
+        // The last element is an incomplete line (or "") — keep it buffered.
+        this.buffer = parts.pop() ?? "";
+        return parts;
+    }
+    /** Flush any buffered partial line at end-of-stream. */
+    flush() {
+        if (this.buffer.length === 0)
+            return [];
+        const last = this.buffer;
+        this.buffer = "";
+        return [last];
+    }
+}
+/** Truncate a single-line summary so tool calls stay one line each. */
+function clip(value, max = 80) {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    return oneLine.length > max ? `${oneLine.slice(0, max - 1)}…` : oneLine;
+}
+/**
+ * Visible (printed) width of a string: its length minus any ANSI SGR escapes,
+ * which occupy zero columns. Used to lay out the splash panel + metadata box,
+ * where padding has to align on what's *shown*, not the raw string length. The
+ * logo/box use only width-1 glyphs (`█`, box-drawing), so a codepoint count is
+ * exact here — this is not a general East-Asian-width measure.
+ */
+// eslint-disable-next-line no-control-regex
+const ANSI_SGR = /\x1b\[[0-9;]*m/g;
+function visibleWidth(text) {
+    return [...text.replace(ANSI_SGR, "")].length;
+}
+/** Indent a multi-line assistant message block under a bullet. */
+function indentBlock(text) {
+    return text
+        .trimEnd()
+        .split("\n")
+        .map((line) => `  ${line}`);
+}
+/**
+ * Build a one-line summary of a tool call from its name + input, matching the
+ * gist of what the interactive TUIs print (e.g. `Bash(ls -la)`,
+ * `Edit(src/app.ts)`). Unknown tools fall back to the tool name + clipped JSON.
+ */
+function summarizeTool(name, input) {
+    const obj = (input && typeof input === "object" ? input : {});
+    const str = (k) => typeof obj[k] === "string" ? obj[k] : undefined;
+    switch (name) {
+        case "Bash": {
+            const cmd = str("command");
+            return cmd ? `Bash(${clip(cmd)})` : "Bash";
+        }
+        case "Read":
+        case "NotebookEdit": {
+            const path = str("file_path") ?? str("path") ?? str("notebook_path");
+            return path ? `${name}(${clip(path)})` : name;
+        }
+        case "Edit":
+        case "Write": {
+            const path = str("file_path") ?? str("path");
+            if (!path)
+                return name;
+            // Surface a coarse size hint for writes/edits so the transcript conveys
+            // "small tweak" vs "wrote a big file" without dumping the diff. Edit uses
+            // new_string length; Write uses content length.
+            const body = str("new_string") ?? str("content");
+            const lines = body ? body.split("\n").length : undefined;
+            const suffix = lines !== undefined ? ` ${DIM}+${lines}L${RESET}` : "";
+            return `${name}(${clip(path)})${suffix}`;
+        }
+        case "Glob":
+        case "Grep": {
+            const pattern = str("pattern") ?? str("query");
+            return pattern ? `${name}(${clip(pattern)})` : name;
+        }
+        case "TodoWrite":
+            return "TodoWrite";
+        default: {
+            // Generic: show the tool name and a clipped scalar arg if there's an
+            // obvious one, else just the name.
+            const firstScalar = Object.values(obj).find((v) => typeof v === "string" || typeof v === "number");
+            return firstScalar !== undefined ? `${name}(${clip(String(firstScalar))})` : name;
+        }
+    }
+}
+/**
+ * Render ONE parsed Claude `--output-format stream-json` event into transcript
+ * lines (possibly empty). We render off the *complete* `assistant` events (not
+ * the partial `stream_event` deltas) so each block is whole; everything else —
+ * `system`/`stream_event`/`rate_limit_event`/`user` tool-result bodies — is
+ * dropped as noise. The final `result` event is summarized as a dim footer.
+ */
+export function renderClaudeEvent(event) {
+    if (!event || typeof event !== "object")
+        return [];
+    const e = event;
+    const type = e["type"];
+    if (type === "assistant") {
+        const message = e["message"];
+        const content = Array.isArray(message?.["content"]) ? message["content"] : [];
+        const out = [];
+        for (const block of content) {
+            if (block["type"] === "text" && typeof block["text"] === "string") {
+                const text = block["text"].trim();
+                if (text)
+                    out.push(...indentBlock(text));
+            }
+            else if (block["type"] === "tool_use" && typeof block["name"] === "string") {
+                const name = block["name"];
+                out.push(toolLine(name, summarizeTool(name, block["input"])));
+            }
+        }
+        return out;
+    }
+    if (type === "result") {
+        const isError = e["is_error"] === true;
+        const turns = typeof e["num_turns"] === "number" ? e["num_turns"] : undefined;
+        const ms = typeof e["duration_ms"] === "number" ? e["duration_ms"] : undefined;
+        const meta = [
+            turns !== undefined ? `${turns} turn${turns === 1 ? "" : "s"}` : undefined,
+            ms !== undefined ? `${(ms / 1000).toFixed(1)}s` : undefined,
+        ].filter((b) => b !== undefined);
+        return [transcriptFooter(isError, meta)];
+    }
+    // system / stream_event / rate_limit_event / user tool-results → noise.
+    return [];
+}
+/**
+ * Render ONE parsed Codex `exec --json` event (JSONL) into transcript lines.
+ * Codex emits `thread.started` / `turn.started` / `item.*` / `turn.completed` /
+ * `error`. We surface assistant messages, command/file-change items, and a dim
+ * completion/error footer; thread/turn lifecycle + token metadata are dropped.
+ */
+export function renderCodexEvent(event) {
+    if (!event || typeof event !== "object")
+        return [];
+    const e = event;
+    const type = e["type"];
+    if (typeof type !== "string")
+        return [];
+    if (type === "error") {
+        const msg = typeof e["message"] === "string" ? e["message"] : "unknown error";
+        return [transcriptFooter(true, [clip(msg, 120)])];
+    }
+    if (type === "turn.failed") {
+        const err = e["error"];
+        const msg = typeof err?.["message"] === "string" ? err["message"] : "turn failed";
+        return [transcriptFooter(true, [clip(msg, 120)])];
+    }
+    if (type === "turn.completed") {
+        return [transcriptFooter(false, [])];
+    }
+    // Codex item events carry the actual work. Shape:
+    //   {"type":"item.completed","item":{"type":"agent_message"|"command_execution"
+    //    |"file_change"|"reasoning",...}}
+    if (type === "item.completed" || type === "item.started") {
+        const item = e["item"];
+        if (!item)
+            return [];
+        const itemType = item["type"];
+        if (itemType === "agent_message") {
+            const text = typeof item["text"] === "string" ? item["text"].trim() : "";
+            // Only emit the full message once (on completion) to avoid duplicate prose.
+            return type === "item.completed" && text ? indentBlock(text) : [];
+        }
+        if (itemType === "command_execution") {
+            // Show the command when it starts; skip the completion echo.
+            if (type !== "item.started")
+                return [];
+            const cmd = typeof item["command"] === "string" ? item["command"] : undefined;
+            return cmd ? [toolLine("Bash", `Bash(${clip(cmd)})`)] : [];
+        }
+        if (itemType === "file_change") {
+            if (type !== "item.completed")
+                return [];
+            // Codex file_change items carry a `changes: [{path, kind}]` array; older
+            // shapes used a flat `path`/`file`. Summarize either form as an Edit line.
+            const changes = Array.isArray(item["changes"]) ? item["changes"] : [];
+            const paths = changes
+                .map((c) => (typeof c["path"] === "string" ? c["path"] : undefined))
+                .filter((p) => p !== undefined);
+            if (paths.length === 1)
+                return [toolLine("Edit", `Edit(${clip(paths[0])})`)];
+            if (paths.length > 1)
+                return [toolLine("Edit", `Edit(${paths.length} files)`)];
+            const flat = typeof item["path"] === "string"
+                ? item["path"]
+                : typeof item["file"] === "string"
+                    ? item["file"]
+                    : undefined;
+            return flat ? [toolLine("Edit", `Edit(${clip(flat)})`)] : [];
+        }
+        // reasoning / other item kinds → noise.
+        return [];
+    }
+    // thread.started / turn.started / token metadata → noise.
+    return [];
+}
+/**
+ * Wrap a typed event renderer with JSON parsing. Non-JSON lines (rare stray
+ * stderr-on-stdout) are passed through verbatim so nothing is silently eaten,
+ * but empty/whitespace lines are dropped.
+ */
+function makeRenderer(render) {
+    return (jsonLine) => {
+        const trimmed = jsonLine.trim();
+        if (!trimmed)
+            return [];
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            // Not JSON — likely a plain status line the agent wrote to stdout. Keep it
+            // rather than drop it, so unexpected output is still visible.
+            return [trimmed];
+        }
+        return render(parsed);
+    };
+}
+export const claudeRenderer = makeRenderer(renderClaudeEvent);
+export const codexRenderer = makeRenderer(renderCodexEvent);
+/**
+ * The dim footer that closes each agent's transcript. Done turns green with a
+ * check; an errored/aborted turn turns red with a cross. `meta` is the trailing
+ * detail (turns/duration, or an error message). Kept as a shared helper so the
+ * Claude `result` and Codex `turn.completed`/`error` footers render alike.
+ *
+ * NOTE: the literal words "done"/"error" are asserted by the renderer tests, so
+ * keep them as the leading token.
+ */
+export function transcriptFooter(isError, meta) {
+    const label = isError ? `${RED}✗ error${RESET}` : `${GREEN}✓ done${RESET}`;
+    const tail = meta.length > 0 ? `${DIM} · ${meta.join(" · ")}${RESET}` : "";
+    return `${label}${tail}`;
+}
+/** Width of the horizontal rules used to frame the daemon session + tasks. */
+const RULE_WIDTH = 60;
+const RULE = "─".repeat(RULE_WIDTH);
+/**
+ * Heavy task header printed once when a task starts. The leading rule + blank
+ * line give multi-task runs clear visual separation (tasks stop blurring into
+ * one another); `index` is the 1-based run counter within this session.
+ */
+export function taskHeader(shortTaskId, title, agentName, index) {
+    const counter = index !== undefined ? `${BOLD}${CYAN}#${index}${RESET} ` : "";
+    return (`\n${DIM}${RULE}${RESET}\n` +
+        `${counter}${BOLD}▌ ${title}${RESET} ${DIM}(${shortTaskId} · ${agentName})${RESET}`);
+}
+/**
+ * The ZeNorm splash logo: the brand mark (the interlocking Z / hourglass from
+ * apps/web/public/zenorm-icon.svg) on the LEFT, the `ZeNorm` wordmark on the
+ * RIGHT. Rendered once at daemon launch.
+ *
+ * Built from a 7-row, solid-fill (`█`) pixel font — no box-drawing "shadow"
+ * frame (that earlier version rendered as illegible noise). The wordmark is
+ * mixed-case: `Z` and `N` are full 7-row caps; `e o r m` are lowercase glyphs
+ * that occupy the lower five rows (x-height — top two rows blank), so it reads
+ * as `ZeNorm`. Glyph widths vary (caps wider than the round lowercase); rows are
+ * concatenated with a 1-col gap.
+ */
+const LOGO_ROWS = 7;
+/**
+ * 7-row glyphs for the wordmark. Each glyph's rows are equal width (the renderer
+ * pads with a trailing space); caps fill all 7 rows, lowercase the lower 5.
+ */
+const LOGO_GLYPHS = {
+    Z: ["██████", "    ██", "   ██ ", "  ██  ", " ██   ", "██    ", "██████"],
+    e: ["      ", "      ", " ████ ", "██  ██", "██████", "██    ", " ████ "],
+    N: ["██   ██", "███  ██", "████ ██", "██ ████", "██  ███", "██   ██", "██   ██"],
+    o: ["      ", "      ", " ████ ", "██  ██", "██  ██", "██  ██", " ████ "],
+    r: ["      ", "      ", "██ ███", "███   ", "██    ", "██    ", "██    "],
+    m: ["        ", "        ", "███ ███ ", "██ ██ ██", "██ ██ ██", "██ ██ ██", "██ ██ ██"],
+};
+/**
+ * The brand mark — the actual `zenorm-icon.svg`, rasterized. Hand-drawn block
+ * ASCII of this hourglass read as mush at terminal sizes, so instead the SVG's
+ * alpha mask was rendered to a 25×16-pixel bitmap and packed into half-block
+ * cells (`▀`/`▄`/`█`): each character is two stacked pixels, so 9 text rows carry
+ * 18 px of vertical detail — the floor at which all four features (the two outer
+ * interlocking triangles AND the two nested solid wedges) survive; at 8 rows the
+ * inner wedges merge into the diagonals or drop out. Sized to roughly the
+ * wordmark's height (the 9-row icon is just one row taller than the 8-row
+ * wordmark, which is vertically centered beside it) so the mark and the `ZeNorm`
+ * text read at the same scale. The horizontal axis is pre-stretched ~1.2× (to
+ * undo the terminal's ~2:1 cell aspect without fattening the mark) so it keeps the
+ * SVG's taller-than-wide proportions. Regenerate from the SVG with
+ * `scripts/render-icon.py` if the brand mark changes. Every glyph here is width-1,
+ * so `visibleWidth`'s codepoint count stays exact for the splash layout.
+ */
+const LOGO_ICON = [
+    "▀█████████████████",
+    "  ▀█▄  ▄▄▄▄  ▄██▀",
+    "    ██▄ ▀▀ ▄██▀",
+    "     ▀█▀ ▄██▀",
+    "       ▄██▀",
+    "     ▄██▀ ▄█▄",
+    "    ██▀ ▄▄ ▀██",
+    "  ▄█▀  ▀▀▀▀  ▀█▄",
+    "▄████████████████▄",
+];
+/** Render the wordmark `ZeNorm` as 7 parallel rows of glyph art. */
+function wordmarkRows() {
+    const rows = Array.from({ length: LOGO_ROWS }, () => "");
+    for (const ch of "ZeNorm") {
+        const glyph = LOGO_GLYPHS[ch];
+        if (!glyph)
+            throw new Error(`No splash glyph defined for "${ch}".`);
+        for (let i = 0; i < LOGO_ROWS; i += 1)
+            rows[i] += `${glyph[i]} `;
+    }
+    return rows;
+}
+/** Extrusion offset (cells) of the 3D outline behind the glyph faces. */
+const SHADOW_DX = 1;
+const SHADOW_DY = 1;
+/**
+ * Box-drawing line for an outline cell, chosen from which of its 4 orthogonal
+ * neighbours are *also* outline cells, so the extruded silhouette connects into
+ * continuous strokes (── runs, │ verticals, ╭╮╰╯ corners) instead of dots. Keyed
+ * by a 4-bit mask: up=8, down=4, left=2, right=1.
+ */
+const OUTLINE_LINES = {
+    0: "·", 1: "─", 2: "─", 3: "─", 4: "│", 5: "╭", 6: "╮", 7: "┬",
+    8: "│", 9: "╰", 10: "╯", 11: "┴", 12: "│", 13: "├", 14: "┤", 15: "┼",
+};
+/**
+ * Composite the logo art into colored rows with a Qwen-style extruded 3D edge:
+ * solid bright-cyan glyph faces, plus a teal line outline tracing the glyph
+ * silhouette one cell down-right. `art` rows are plain `█`/space strings.
+ *
+ * The face is every `█` cell. The outline is every cell that is empty in the
+ * face layer but filled in the face layer shifted up-left by the extrusion
+ * offset — i.e. the bottom-right contour that an extrusion would expose. Each
+ * outline cell picks a connecting box-drawing glyph from its outline neighbours.
+ */
+function extrudeRows(art) {
+    const width = Math.max(...art.map((r) => r.length));
+    const face = art.map((row) => [...row.padEnd(width)].map((c) => c === "█"));
+    const cell = (x, y) => y >= 0 && y < face.length && x >= 0 && x < width && face[y][x] === true;
+    // Outline cell: empty in the face, but the source cell (offset up-left) is a
+    // face — the silhouette the extrusion reveals to the down-right.
+    const isOutline = (x, y) => !cell(x, y) && cell(x - SHADOW_DX, y - SHADOW_DY);
+    const outWidth = width + SHADOW_DX;
+    const outHeight = art.length + SHADOW_DY;
+    const rows = [];
+    for (let y = 0; y < outHeight; y += 1) {
+        let line = "";
+        let style = "";
+        const setStyle = (next) => {
+            if (next !== style) {
+                line += RESET + next;
+                style = next;
+            }
+        };
+        for (let x = 0; x < outWidth; x += 1) {
+            if (cell(x, y)) {
+                setStyle(`${BOLD}${BRIGHT_CYAN}`);
+                line += "█";
+            }
+            else if (isOutline(x, y)) {
+                setStyle(OUTLINE);
+                const mask = (isOutline(x, y - 1) ? 8 : 0) |
+                    (isOutline(x, y + 1) ? 4 : 0) |
+                    (isOutline(x - 1, y) ? 2 : 0) |
+                    (isOutline(x + 1, y) ? 1 : 0);
+                line += OUTLINE_LINES[mask];
+            }
+            else {
+                setStyle("");
+                line += " ";
+            }
+        }
+        rows.push(line + RESET);
+    }
+    return rows;
+}
+/** The icon's printed width (its widest row), for padding the splash gutter. */
+const ICON_WIDTH = Math.max(...LOGO_ICON.map((r) => [...r].length));
+/**
+ * Render the rasterized brand mark in brand cyan. Each row is right-padded to the
+ * icon's full width (so the gutter to the wordmark stays aligned), then the whole
+ * row is wrapped in one color run — the half-block glyphs are the ink, the spaces
+ * are transparent background, so a single SGR span per line both colors the mark
+ * and keeps the escape count tiny. Under NO_COLOR the span collapses to "" and
+ * the half-blocks still draw.
+ */
+function iconRows() {
+    return LOGO_ICON.map((row) => {
+        const padded = [...row].join("").padEnd(ICON_WIDTH);
+        return `${BOLD}${BRIGHT_CYAN}${padded}${RESET}`;
+    });
+}
+/**
+ * The full multi-line splash logo (no surrounding blank lines): the rasterized
+ * brand mark on the left (brand-cyan half-blocks), the `ZeNorm` wordmark on the
+ * right (3D-extruded, 5-space gutter). The icon stands one row taller than the
+ * wordmark (9 vs 8), so the shorter wordmark is vertically centered against it
+ * with blank padding. Under NO_COLOR the color escapes collapse to "" (the
+ * half-block mark and the wordmark's box outline still draw). Exported so it can
+ * be rendered/asserted on its own.
+ */
+export function splashLogo() {
+    const icon = iconRows();
+    const word = extrudeRows(wordmarkRows());
+    const blankIconRow = " ".repeat(ICON_WIDTH);
+    const height = Math.max(icon.length, word.length);
+    // Center the shorter block vertically against the taller one.
+    const wordPad = Math.floor((height - word.length) / 2);
+    const rows = [];
+    for (let i = 0; i < height; i += 1) {
+        const left = icon[i] ?? blankIconRow;
+        const wordIdx = i - wordPad;
+        const right = wordIdx >= 0 && wordIdx < word.length ? word[wordIdx] : "";
+        rows.push(`  ${left}     ${right}`);
+    }
+    return rows.join("\n");
+}
+/**
+ * Frame a block of already-styled lines in a rounded box (Qwen-style metadata
+ * panel). `lines` may contain ANSI escapes; padding aligns on visible width. One
+ * cell of inner padding on each side. Under NO_COLOR the border greys collapse
+ * but the box-drawing characters still render, so the frame survives.
+ */
+function metaBox(lines) {
+    const inner = Math.max(...lines.map(visibleWidth));
+    const horizontal = "─".repeat(inner + 2);
+    const out = [`${BORDER}╭${horizontal}╮${RESET}`];
+    for (const line of lines) {
+        const fill = " ".repeat(inner - visibleWidth(line));
+        out.push(`${BORDER}│${RESET} ${line}${fill} ${BORDER}│${RESET}`);
+    }
+    out.push(`${BORDER}╰${horizontal}╯${RESET}`);
+    return out;
+}
+/**
+ * The startup banner for the daemon. Shown once at launch (not just under
+ * `--dry-run`) so a real run announces what it's doing instead of sitting
+ * silently until the first task lands. Leads with the ZeNorm splash logo, then
+ * the run parameters.
+ */
+export function daemonBanner(opts) {
+    const mode = [opts.once ? "once" : undefined, opts.dryRun ? "dry-run" : undefined]
+        .filter((m) => m !== undefined)
+        .join(", ");
+    const modeSuffix = mode ? ` ${DIM}(${mode})${RESET}` : "";
+    // The metadata sits in a rounded box beside the same `>_ ZeNorm` header
+    // treatment Qwen uses, with the run parameters under it.
+    const box = metaBox([
+        `${BOLD}${BRIGHT_CYAN}>_${RESET} ${BOLD}ZeNorm${RESET}${modeSuffix}`,
+        `${DIM}spec-authoring agent · claim-and-run daemon${RESET}`,
+        "",
+        `${DIM}agent     ${RESET}${opts.agent}`,
+        `${DIM}repo      ${RESET}${opts.repo}`,
+        `${DIM}interval  ${RESET}${opts.intervalSeconds}s`,
+    ]);
+    return [
+        "",
+        splashLogo(),
+        "",
+        ...box,
+        `${DIM}  Polling for ready tasks — Ctrl-C to stop.${RESET}`,
+    ].join("\n");
+}
+/** A spinner-free, dim status line for the daemon's idle/lifecycle states. */
+export function statusLine(message) {
+    return `${DIM}· ${message}${RESET}`;
+}
+/**
+ * The per-task outcome line printed after a task's transcript closes: a bold
+ * green check for success or a bold red cross for failure, with the title, id,
+ * and wall-clock duration. This is the daemon's own verdict (distinct from the
+ * agent's transcript footer) so the run log reads as a sequence of outcomes.
+ */
+export function taskOutcome(opts) {
+    const seconds = (opts.durationMs / 1000).toFixed(1);
+    const mark = opts.ok ? `${GREEN}${BOLD}✓${RESET}` : `${RED}${BOLD}✗${RESET}`;
+    const verb = opts.ok ? `${GREEN}completed${RESET}` : `${RED}failed${RESET}`;
+    return `${mark} ${verb} ${opts.title} ${DIM}(${opts.shortTaskId} · ${seconds}s)${RESET}`;
+}
+/**
+ * A loud, framed failure banner for a task that threw. Spells out which task
+ * failed, the error, and that it was released back to `todo` so the failure is
+ * impossible to miss in a scrolling daemon log (vs. a single dim line).
+ */
+export function failureBanner(opts) {
+    return [
+        `${RED}${BOLD}✗ task failed${RESET} ${opts.title} ${DIM}(${opts.shortTaskId})${RESET}`,
+        `${RED}  ${opts.error}${RESET}`,
+        `${DIM}  released back to todo — it can be re-claimed.${RESET}`,
+    ].join("\n");
+}
+/**
+ * The session summary printed when the daemon shuts down (Ctrl-C or `--once`
+ * exhausted). Closes the run with a rule + a one-line tally so the user sees the
+ * total instead of having to count outcome lines by eye.
+ */
+export function sessionSummary(opts) {
+    const parts = [`${GREEN}${opts.completed} completed${RESET}`];
+    if (opts.failed > 0)
+        parts.push(`${RED}${opts.failed} failed${RESET}`);
+    const tally = opts.completed === 0 && opts.failed === 0 ? `${DIM}no tasks run${RESET}` : parts.join(`${DIM} · ${RESET}`);
+    return `\n${DIM}${RULE}${RESET}\n${BOLD}◣ session ended${RESET} ${DIM}·${RESET} ${tally}`;
+}