mergestorm 0.3.24 → 0.3.26

package/dist/stack-watch-obligation.d.ts

@@ -0,0 +1,43 @@
+import type { StackDto } from "./stack-dto.js";
+export declare const STACK_WATCH_NOT_DONE_SENTENCE = "This stack is not landed. Your task is not done. Call stack_wait again with this cursor.";
+export type StackWatchDoneReason = "landed" | "closed" | "archived" | "not_found";
+export type StackWatchReason = StackWatchDoneReason | "open" | "attention" | "unread" | "rate_limited" | "failed";
+export type StackWatchNextArgs = {
+    stack_id: string;
+    enrolled_head_sha?: string | null;
+    after_finished_at?: string | null;
+    bounce_id?: string | null;
+    timeout_s: 45;
+};
+export type StackWatchNext = {
+    tool: "stack_wait";
+    args: StackWatchNextArgs;
+    command: string;
+};
+export type StackWatchObligation = {
+    done: boolean;
+    until: "landed";
+    reason: StackWatchReason;
+    next: StackWatchNext | null;
+    message: string;
+};
+export type StackWatchObligationInput = {
+    stackId: string;
+    terminal: StackWatchDoneReason | null;
+    cursor?: {
+        enrolledHeadSha?: string | null;
+        afterFinishedAt?: string | null;
+        bounceId?: string | null;
+    } | null;
+    status?: string;
+    attention?: {
+        prNumber: number;
+        blocker: string;
+    } | null;
+    retryAfterSeconds?: number;
+    unread?: boolean;
+    freshCursor?: boolean;
+};
+export declare function stackTerminalReason(stack: Pick<StackDto, "archivedAt" | "layers" | "unit"> | null | undefined): StackWatchDoneReason | null;
+export declare function stackWatchNextArgs(stackId: string, cursor: StackWatchObligationInput["cursor"]): StackWatchNextArgs;
+export declare function stackWatchObligation(input: StackWatchObligationInput): StackWatchObligation;

package/dist/stack-watch-obligation.js

@@ -0,0 +1,79 @@
+export const STACK_WATCH_NOT_DONE_SENTENCE = "This stack is not landed. Your task is not done. Call stack_wait again with this cursor.";
+const DONE_MESSAGES = {
+    landed: "This stack is landed. The watch is done; stop calling stack_wait for it.",
+    closed: "Every PR in this stack is merged or closed and nothing is left to land, but not every PR landed. The watch is done; tell the human which PRs were closed without landing.",
+    archived: "This stack is archived: the human took it back. The watch is done; stop calling stack_wait for it and do not push to its PRs.",
+    not_found: "No stack with this id exists for this account. Mergestorm deletes a stack once none of its layers is open, so a stack you were watching has most likely landed; a mistyped id or another account's stack reads the same. The watch is done; confirm each PR is merged (gh pr view <n> --json state) before reporting it landed.",
+};
+export function stackTerminalReason(stack) {
+    if (!stack)
+        return "not_found";
+    if (stack.archivedAt)
+        return "archived";
+    const layers = stack.layers;
+    if (layers.some((layer) => layer.state !== "merged" && layer.state !== "closed"))
+        return null;
+    const unit = stack.unit;
+    if (layers.length === 0 && !unit)
+        return null;
+    const landPr = unit?.landPr;
+    if (landPr && landPr.prNumber > 0 && landPr.state !== "merged" && landPr.state !== "closed")
+        return null;
+    if (unit && unit.state !== "landed" && unit.state !== "abandoned")
+        return null;
+    const everyLayerMerged = layers.every((layer) => layer.state === "merged");
+    return everyLayerMerged && (!unit || unit.state === "landed") ? "landed" : "closed";
+}
+export function stackWatchNextArgs(stackId, cursor) {
+    return {
+        stack_id: stackId,
+        ...(cursor && cursor.enrolledHeadSha !== undefined ? { enrolled_head_sha: cursor.enrolledHeadSha } : {}),
+        ...(cursor && cursor.afterFinishedAt !== undefined ? { after_finished_at: cursor.afterFinishedAt } : {}),
+        ...(cursor && cursor.bounceId !== undefined ? { bounce_id: cursor.bounceId } : {}),
+        timeout_s: 45,
+    };
+}
+export function stackWatchObligation(input) {
+    if (input.terminal) {
+        return {
+            done: true,
+            until: "landed",
+            reason: input.terminal,
+            next: null,
+            message: DONE_MESSAGES[input.terminal],
+        };
+    }
+    const args = stackWatchNextArgs(input.stackId, input.cursor);
+    const reason = input.status === "rate_limited"
+        ? "rate_limited"
+        : input.status === "failed"
+            ? "failed"
+            : input.attention ? "attention" : input.unread ? "unread" : "open";
+    const parts = [
+        STACK_WATCH_NOT_DONE_SENTENCE,
+        `Watch stack ${input.stackId} as a whole until it lands or the human takes it back. A clean push, a submit, or one merged layer does not finish it: merging a lower layer can break a layer above it.`,
+    ];
+    if (reason === "rate_limited") {
+        parts.push(`Wait ${input.retryAfterSeconds !== undefined ? `${input.retryAfterSeconds}s` : "retry_after_seconds"} first, then call stack_wait with the same cursor.`);
+    }
+    else if (reason === "failed") {
+        parts.push(`This read failed, which does not end the task. Call stack_wait once more with the same cursor; if that fails too, tell the human that stack ${input.stackId} is not landed and is no longer being watched.`);
+    }
+    else if (reason === "attention" && input.attention) {
+        parts.push(`First fix #${input.attention.prNumber} (${input.attention.blocker}); repair, when present, names the fix. Calling stack_wait again before fixing it returns the same attention. After your push, call stack_wait with this cursor and enrolled_head_sha set to the SHA you pushed.`);
+    }
+    else if (reason === "unread") {
+        parts.push("This tool did not read the stack's state; stack_wait will.");
+    }
+    parts.push(`Next call: stack_wait ${JSON.stringify(args)}.`);
+    if (input.freshCursor) {
+        parts.push("If you already hold a cursor from an earlier stack_wait on this stack, keep passing that cursor instead.");
+    }
+    return {
+        done: false,
+        until: "landed",
+        reason,
+        next: { tool: "stack_wait", args, command: `mg stack wait ${input.stackId} --json` },
+        message: parts.join(" "),
+    };
+}

package/dist/stack-watch.d.ts

@@ -1,8 +1,10 @@
-import { type StackBlocker } from "./stack-blockers.js";
+import { type StackAgentBusy, type StackBlocker, type StackLayerAgents, type StackLandGatePending, type StackRepairHint } from "./stack-blockers.js";
+import { type StackWatchObligation } from "./stack-watch-obligation.js";
 import { apiFetch } from "./api.js";
 import type { Config } from "./config.js";
 export declare const STACK_WATCH_SCHEMA: "mergestorm.stack_watch/v1";
 export declare const STACK_WATCH_DEFAULT_TIMEOUT_MS = 45000;
+export declare const STACK_WATCH_BUSY_RECHECK_S = 15;
 /** Resume selectors are fixed for the entire wait, including transient retries. */
 export type StackWatchCursor = {
     readonly stackId: string;
@@ -25,6 +27,11 @@ export type StackWatchEnvelope = {
         headSha: string | null;
     } | null;
     assessment: "available" | "unavailable";
+    busy: StackAgentBusy[];
+    agents: StackLayerAgents | null;
+    repair: StackRepairHint | null;
+    landGatePending: StackLandGatePending | null;
+    watch: StackWatchObligation;
 };
 export type PollStackWatchOptions = {
     timeoutMs?: number;

package/dist/stack-watch.js

@@ -1,9 +1,11 @@
-import { currentLayer, stackBlockers } from "./stack-blockers.js";
+import { currentLayer, layerAgents, stackBlockers, } from "./stack-blockers.js";
+import { stackTerminalReason, stackWatchObligation, } from "./stack-watch-obligation.js";
 import { setTimeout as sleep } from "node:timers/promises";
 import { apiFetch } from "./api.js";
 import { REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, isTransientReviewPollError, isTransientReviewPollStatus, transientRetryWaitMs, } from "./commands/review-client.js";
 export const STACK_WATCH_SCHEMA = "mergestorm.stack_watch/v1";
 export const STACK_WATCH_DEFAULT_TIMEOUT_MS = 45_000;
+export const STACK_WATCH_BUSY_RECHECK_S = 15;
 export class StackWatchTimeoutError extends Error {
     lastEnvelope;
     constructor(lastEnvelope) {
@@ -46,10 +48,20 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
     let lastEnvelope = {
         schema: STACK_WATCH_SCHEMA, status: "failed", stackId: id, blocker: null,
         bounceKind: null, prNumber: null, headSha: null, cursor,
-        issues: [], currentCandidate: null, assessment: "unavailable",
+        issues: [], currentCandidate: null, assessment: "unavailable", busy: [], agents: null, repair: null,
+        landGatePending: null,
     };
+    let terminal = null;
+    const seal = (snapshot, retryAfterSeconds) => ({
+        ...snapshot,
+        watch: stackWatchObligation({
+            stackId: id, terminal, cursor: snapshot.cursor, status: snapshot.status, retryAfterSeconds,
+            attention: snapshot.status === "attention" && snapshot.blocker && snapshot.prNumber != null
+                ? { prNumber: snapshot.prNumber, blocker: snapshot.blocker } : null,
+        }),
+    });
     let transientFailures = 0;
-    const timeout = () => new StackWatchTimeoutError(lastEnvelope);
+    const timeout = () => new StackWatchTimeoutError(seal(lastEnvelope));
     const pause = async (ms) => {
         const remaining = Math.min(ms, Math.max(0, deadline - now()));
         if (remaining > 0)
@@ -75,11 +87,11 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
                     throw timeout();
                 if (timeoutMs !== 0 && isTransientReviewPollError(err) && transientFailures < REVIEW_POLL_MAX_TRANSIENT_RETRIES) {
                     transientFailures += 1;
-                    opts.onTick?.(lastEnvelope);
+                    opts.onTick?.(seal(lastEnvelope));
                     await pause(transientRetryWaitMs({ failureCount: transientFailures, random: opts.random }));
                     continue;
                 }
-                throw new StackWatchError(err instanceof Error ? err.message : String(err), { ...lastEnvelope, status: "failed", assessment: "unavailable" }, { cause: err });
+                throw new StackWatchError(err instanceof Error ? err.message : String(err), seal({ ...lastEnvelope, status: "failed", assessment: "unavailable" }), { cause: err });
             }
             if (response.status === 200)
                 return response.body;
@@ -89,14 +101,14 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
             if (timeoutMs !== 0 && isTransientReviewPollStatus(response.status) && transientFailures < REVIEW_POLL_MAX_TRANSIENT_RETRIES &&
                 (response.status !== 429 || retryWaitMs < deadline - now())) {
                 transientFailures += 1;
-                opts.onTick?.({ ...lastEnvelope, status: response.status === 429 ? "rate_limited" : lastEnvelope.status });
+                opts.onTick?.(seal({ ...lastEnvelope, status: response.status === 429 ? "rate_limited" : lastEnvelope.status }, response.status === 429 ? response.retryAfterSeconds : undefined));
                 await pause(retryWaitMs);
                 continue;
             }
-            throw new StackWatchError(`Stack poll failed (HTTP ${response.status})`, {
+            throw new StackWatchError(`Stack poll failed (HTTP ${response.status})`, seal({
                 ...lastEnvelope, status: response.status === 429 ? "rate_limited" : "failed",
                 assessment: "unavailable",
-            }, undefined, response.retryAfterSeconds);
+            }, response.retryAfterSeconds), undefined, response.retryAfterSeconds);
         }
         throw timeout();
     };
@@ -105,16 +117,22 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         const stack = snapshot && Array.isArray(snapshot.stacks)
             ? snapshot.stacks.find((candidate) => candidate.id.trim().toLowerCase() === id)
             : undefined;
+        if (snapshot && Array.isArray(snapshot.stacks) && !stack) {
+            terminal = "not_found";
+            throw new StackWatchError("Stack not found or not owned by the current user", seal({ ...lastEnvelope, status: "failed", assessment: "unavailable", blocker: null, issues: [], busy: [],
+                prNumber: null, headSha: null, repair: null, agents: null, currentCandidate: null, landGatePending: null }));
+        }
         if (!stack || !Array.isArray(stack.layers)) {
-            throw new StackWatchError("Stack snapshot missing or invalid", { ...lastEnvelope, status: "failed", assessment: "unavailable" });
+            throw new StackWatchError("Stack snapshot missing or invalid", seal({ ...lastEnvelope, status: "failed", assessment: "unavailable" }));
         }
+        terminal = stackTerminalReason(stack);
         return stack;
     };
     const queueRoute = `/api/v1/stacks/queue?stackId=${encodeURIComponent(id)}`;
     const readQueue = async (route, finalSnapshot = false) => {
         const queue = await request(route, finalSnapshot);
         if (!queue || !Array.isArray(queue.entries)) {
-            throw new StackWatchError("Invalid merge queue response", { ...lastEnvelope, status: "failed", assessment: "unavailable" });
+            throw new StackWatchError("Invalid merge queue response", seal({ ...lastEnvelope, status: "failed", assessment: "unavailable" }));
         }
         return {
             entries: queue.entries.filter((entry) => entry.stackId.trim().toLowerCase() === id),
@@ -122,15 +140,16 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         };
     };
     const evaluate = (stack, entries) => {
-        const { attention, issues, currentCandidate, bounce } = stackBlockers(stack, entries, cursor);
+        const { attention, issues, currentCandidate, bounce, busy, agents, repair, landGatePending } = stackBlockers(stack, entries, cursor);
         if (bounce)
             cursor = Object.freeze({ ...cursor, bounceId: bounce.id,
                 ...(bounce.finishedAt !== undefined ? { afterFinishedAt: bounce.finishedAt } : {}) });
-        lastEnvelope = { ...lastEnvelope, cursor, issues, currentCandidate, assessment: "available",
+        const held = busy[0];
+        lastEnvelope = { ...lastEnvelope, cursor, issues, currentCandidate, assessment: "available", busy, agents, repair, landGatePending,
             blocker: attention?.blocker ?? null, bounceKind: attention?.bounceKind ?? null,
-            prNumber: attention?.prNumber ?? currentCandidate?.prNumber ?? null,
-            headSha: attention ? attention.headSha : currentCandidate?.headSha ?? null,
-            status: attention ? "attention" : entries.some((entry) => ["queued", "running", "waiting"].includes(entry.state))
+            prNumber: attention?.prNumber ?? held?.prNumber ?? currentCandidate?.prNumber ?? null,
+            headSha: attention ? attention.headSha : held ? held.headSha : currentCandidate?.headSha ?? null,
+            status: attention ? "attention" : busy.length || landGatePending || entries.some((entry) => ["queued", "running", "waiting"].includes(entry.state))
                 ? "in_progress" : "waiting" };
     };
     let stack = await enrich(timeoutMs === 0);
@@ -139,14 +158,15 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         cursor = Object.freeze({ stackId: id, enrolledHeadSha: layer?.headSha ?? null });
         enrolled = true;
     }
-    lastEnvelope = { ...lastEnvelope, cursor, prNumber: layer?.prNumber ?? null, headSha: layer?.headSha ?? null };
+    lastEnvelope = { ...lastEnvelope, cursor, prNumber: layer?.prNumber ?? null, headSha: layer?.headSha ?? null,
+        agents: layer ? layerAgents(layer) : null };
     let queue = await readQueue(queueRoute, timeoutMs === 0);
     evaluate(stack, queue.entries);
-    if (lastEnvelope.status === "attention" || timeoutMs === 0)
-        return lastEnvelope;
+    if (lastEnvelope.status === "attention" || timeoutMs === 0 || terminal)
+        return seal(lastEnvelope);
     while (now() < deadline) {
         const heldAt = now();
-        const seconds = Math.min(45, Math.max(1, Math.ceil((deadline - heldAt) / 1000)));
+        const seconds = Math.min(lastEnvelope.busy.length ? STACK_WATCH_BUSY_RECHECK_S : 45, Math.max(1, Math.ceil((deadline - heldAt) / 1000)));
         const seen = queue.fingerprint ? `&seen=${encodeURIComponent(queue.fingerprint)}` : "";
         const held = await readQueue(`${queueRoute}&wait=${seconds}${seen}`);
         if (JSON.stringify(held.entries) === JSON.stringify(queue.entries)) {
@@ -155,12 +175,13 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         queue = held;
         stack = await enrich(true);
         const refreshed = currentLayer(stack);
-        lastEnvelope = { ...lastEnvelope, prNumber: refreshed?.prNumber ?? null, headSha: refreshed?.headSha ?? null };
+        lastEnvelope = { ...lastEnvelope, prNumber: refreshed?.prNumber ?? null, headSha: refreshed?.headSha ?? null,
+            agents: refreshed ? layerAgents(refreshed) : null };
         transientFailures = 0;
         evaluate(stack, queue.entries);
-        if (lastEnvelope.status === "attention")
-            return lastEnvelope;
-        opts.onTick?.(lastEnvelope);
+        if (lastEnvelope.status === "attention" || terminal)
+            return seal(lastEnvelope);
+        opts.onTick?.(seal(lastEnvelope));
     }
     throw timeout();
 }

package/dist/ui/ansi.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Brand ink. xterm-256 77 (#5FAF5F) � muted green that Terminal.app
+ * actually paints. 24-bit `38;2;61;�` was read as palette 61 (purple).
+ */
+export declare const BRAND_GREEN: {
+    readonly hex: "#5FAF5F";
+    readonly index: 77;
+};
+export declare const BRAND_GREEN_SGR: string;
+/** Full-cell fill. Glyphs like ? leave a hairline; a space with this bg does not. */
+export declare const BRAND_FILL_SGR: string;
 export declare const ansi: {
     readonly enabled: boolean;
     green: (t: string) => string;
@@ -7,8 +18,10 @@ export declare const ansi: {
     yellow: (t: string) => string;
     gray: (t: string) => string;
     brightGreen: (t: string) => string;
+    /** Solid cell (space + fg/bg 77). Stacks flush � no ? hairline. */
+    brandFill: (t: string) => string;
     invert: (t: string) => string;
     boldGreen: (t: string) => string;
-    /** Prompt / mark ink. Never 32 — that reads as sick dark green. */
+    /** Prompt / mark ink. Never ANSI 32, 92, or 24-bit. */
     boldBrightGreen: (t: string) => string;
 };

package/dist/ui/ansi.js

@@ -9,7 +9,25 @@ function computeEnabled() {
 function wrap(code, text) {
     if (!computeEnabled())
         return text;
-    return `[${code}m${text}`;
+    return `\x1b[${code}m${text}\x1b[0m`;
+}
+/**
+ * Brand ink. xterm-256 77 (#5FAF5F) � muted green that Terminal.app
+ * actually paints. 24-bit `38;2;61;�` was read as palette 61 (purple).
+ */
+export const BRAND_GREEN = { hex: "#5FAF5F", index: 77 };
+export const BRAND_GREEN_SGR = `38;5;${BRAND_GREEN.index}`;
+/** Full-cell fill. Glyphs like ? leave a hairline; a space with this bg does not. */
+export const BRAND_FILL_SGR = `${BRAND_GREEN_SGR};48;5;${BRAND_GREEN.index}`;
+function brandGreen(text, bold = false) {
+    if (!computeEnabled())
+        return text;
+    return `\x1b[${bold ? "1;" : ""}${BRAND_GREEN_SGR}m${text}\x1b[0m`;
+}
+function brandFill(text) {
+    if (!computeEnabled())
+        return text;
+    return `\x1b[${BRAND_FILL_SGR}m${text}\x1b[0m`;
 }
 export const ansi = {
     get enabled() {
@@ -21,9 +39,11 @@ export const ansi = {
     red: (t) => wrap("31", t),
     yellow: (t) => wrap("33", t),
     gray: (t) => wrap("90", t),
-    brightGreen: (t) => wrap("92", t),
+    brightGreen: (t) => brandGreen(t),
+    /** Solid cell (space + fg/bg 77). Stacks flush � no ? hairline. */
+    brandFill: (t) => brandFill(t),
     invert: (t) => wrap("7", t),
-    boldGreen: (t) => (computeEnabled() ? `${t}` : t),
-    /** Prompt / mark ink. Never 32 — that reads as sick dark green. */
-    boldBrightGreen: (t) => (computeEnabled() ? `${t}` : t),
+    boldGreen: (t) => (computeEnabled() ? `\x1b[1;32m${t}\x1b[0m` : t),
+    /** Prompt / mark ink. Never ANSI 32, 92, or 24-bit. */
+    boldBrightGreen: (t) => brandGreen(t, true),
 };

package/dist/ui/banner.d.ts

@@ -14,7 +14,7 @@ export type BannerDensity = "full" | "compact" | "mini" | "nano";
 export type BannerVariant = boolean | "mini" | "nano";
 /** Handle returned by {@link printBannerHeader}; `rows` reflows for a resize. */
 export type BannerHandle = {
-    rows(columns?: number, variant?: BannerVariant): string[];
+    rows(columns?: number, variant?: BannerVariant, frame?: number): string[];
 };
 /**
  * The whole welcome panel as rows, reflowed to `columns`. Every row fits in
@@ -24,6 +24,7 @@ export type BannerHandle = {
 export declare function buildBannerRows(state: BannerState, columns?: number, opts?: {
     compact?: boolean;
     density?: BannerDensity;
+    frame?: number;
 }): string[];
 /**
  * Print the welcome panel and return a handle whose `rows()` reflows the

package/dist/ui/banner.js

@@ -3,8 +3,8 @@ import { CommandError } from "../errors.js";
 import { keyDisplay, loadConfig, resolveApiKey } from "../config.js";
 import { cliVersion } from "../version.js";
 import { ansi } from "./ansi.js";
-import { frameWidth, padVisible, preferBoxedUi, roundedBox, terminalColumns, visibleWidth, } from "./box.js";
-import { STORM_MARK, STORM_MARK_WIDTH } from "./logo.js";
+import { frameWidth, padVisible, preferBoxedUi, roundedBox, sideBySide, terminalColumns, visibleWidth, } from "./box.js";
+import { paintSpriteRow, TORNADO_LOGO, TORNADO_LOGO_WIDTH } from "./logo.js";
 import { formatResetLabel, usageBar } from "./usage.js";
 const WORDMARK = `
  __  __ ___ ___  ___ ___ ___ _____ ___  ___ __  __
@@ -105,6 +105,12 @@ const WHATS_NEW = {
     "0.3.24": [
         "mg settings --auto-land-settle (15-300 seconds)",
     ],
+    "0.3.25": [
+        "stack wait holds a PR while Cyclone or Vortex works",
+    ],
+    "0.3.26": [
+        "stack results say the watch ends only at land",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")
@@ -196,57 +202,30 @@ export function buildBannerRows(state, columns, opts) {
     const contentCells = boxed
         ? Math.max(20, outer - 4)
         : Math.max(20, terminalColumns(80, columns) - 1);
-    const indent = STORM_MARK_WIDTH + 2;
-    const pad = " ".repeat(indent);
+    const markLines = TORNADO_LOGO;
+    const markWidth = TORNADO_LOGO_WIDTH;
+    const gap = 2;
+    const rightCells = Math.max(8, contentCells - markWidth - gap);
     const clip = (line) => visibleWidth(line) > contentCells ? padVisible(line, contentCells) : line;
-    const mark = (row) => padVisible(ansi.brightGreen(STORM_MARK[row] ?? ""), indent);
+    const clipRight = (line) => visibleWidth(line) > rightCells ? padVisible(line, rightCells) : line;
     const title = `${ansi.boldBrightGreen("mergestorm")} ${ansi.dim(`v${state.version}`)}`;
-    if (density === "nano") {
-        const one = `${mark(0)}${title}  ${statusLine(state)}`;
-        return [clip(one)];
-    }
-    if (density === "mini") {
-        // Short pane: mark + who you are, then the same cues as the full home.
-        const line0 = clip(`${mark(0)}${title}  ${statusLine(state)}`);
-        const line1 = state.me && !state.keyInvalid
-            ? clip(`${mark(1)}${usageLine(state.me, contentCells, indent)}`)
-            : clip(mark(1));
-        const room = contentCells - indent;
-        const blurb = tagline(room);
-        const tips = tipsLine(room);
-        const fresh = whatsNewLine(state.version, room);
-        return [
-            line0,
-            line1,
-            ...(blurb ? [clip(`${pad}${blurb}`)] : []),
-            ...(tips ? [clip(`${pad}${tips}`)] : []),
-            ...(fresh ? [clip(`${pad}${fresh}`)] : []),
-        ];
-    }
-    const content = [
-        clip(`${pad}${title}`),
-        clip(`${mark(0)}${statusLine(state)}`),
-    ];
+    const right = [clipRight(title), clipRight(statusLine(state))];
     if (state.me && !state.keyInvalid) {
-        content.push(clip(`${mark(1)}${usageLine(state.me, contentCells, indent)}`));
-    }
-    else {
-        content.push(clip(mark(1)));
+        right.push(clipRight(usageLine(state.me, rightCells, 0)));
     }
-    const room = contentCells - indent;
-    const blurb = tagline(room);
-    const tips = tipsLine(room);
-    const fresh = whatsNewLine(state.version, room);
+    const blurb = tagline(rightCells);
+    const tips = tipsLine(rightCells);
+    const fresh = whatsNewLine(state.version, rightCells);
     if (blurb)
-        content.push(clip(`${pad}${blurb}`));
+        right.push(clipRight(blurb));
     if (tips)
-        content.push(clip(`${pad}${tips}`));
+        right.push(clipRight(tips));
     if (fresh)
-        content.push(clip(`${pad}${fresh}`));
-    if (boxed && density === "full") {
-        content.splice(3, 0, "");
-        return [...roundedBox(content, { width: outer, padding: 1 })];
-    }
+        right.push(clipRight(fresh));
+    const markCol = markLines.map((line) => padVisible(paintSpriteRow(line), markWidth));
+    const content = sideBySide(markCol, density === "nano" ? right.slice(0, 3) : right, markWidth, gap).map(clip);
+    if (density === "mini" || density === "nano")
+        return content;
     if (boxed) {
         return [...roundedBox(content, { width: outer, padding: 1 })];
     }
@@ -282,7 +261,7 @@ export async function printBannerHeader(opts) {
         }
     }
     return {
-        rows: (columns, variant) => buildBannerRows(state, columns, { density: densityFromVariant(variant) }),
+        rows: (columns, variant, frame) => buildBannerRows(state, columns, { density: densityFromVariant(variant), frame }),
     };
 }
 export function shellPrompt(_loggedIn) {

package/dist/ui/logo.d.ts

@@ -1,13 +1,18 @@
 /**
- * Compact two-row storm mark (Fable / 0.3.14 home). Colored by the caller.
- * Block elements (U+2580..259F) are one cell each; no emoji, no gradients.
+ * The home mark: a tornado drawn as five horizontal bars and one square tail,
+ * each an upper-half band (▀). One column is one bar-height wide; half-column
+ * ends use the upper quadrants (▝ ▘) so every edge lands where the source art
+ * puts it. Same X/width as the SVG, shifted up half a cell. Painted fg 77.
  */
-export declare const STORM_MARK: string[];
-/** Widest row of the mark, in cells (every mark glyph is single-cell). */
-export declare const STORM_MARK_WIDTH: number;
-/** @deprecated Alias — the home panel uses {@link STORM_MARK}. */
 export declare const TORNADO_LOGO: string[];
-/** @deprecated Alias. */
+/** Single idle frame. Kept for callers that index frames. */
+export declare const TORNADO_FRAMES: string[][];
+/** Every sprite glyph is one column. */
 export declare const TORNADO_LOGO_WIDTH: number;
-/** @deprecated Compact home is the full two-row mark. */
 export declare const TORNADO_LOGO_COMPACT: string[];
+/** @deprecated Use {@link TORNADO_LOGO}. */
+export declare const STORM_MARK: string[];
+/** @deprecated Use {@link TORNADO_LOGO_WIDTH}. */
+export declare const STORM_MARK_WIDTH: number;
+/** Paint one sprite row: each run of glyphs in brand green 77, spaces left bare. */
+export declare function paintSpriteRow(row: string): string;

package/dist/ui/logo.js

@@ -1,16 +1,28 @@
+import { ansi } from "./ansi.js";
 /**
- * Compact two-row storm mark (Fable / 0.3.14 home). Colored by the caller.
- * Block elements (U+2580..259F) are one cell each; no emoji, no gradients.
+ * The home mark: a tornado drawn as five horizontal bars and one square tail,
+ * each an upper-half band (▀). One column is one bar-height wide; half-column
+ * ends use the upper quadrants (▝ ▘) so every edge lands where the source art
+ * puts it. Same X/width as the SVG, shifted up half a cell. Painted fg 77.
  */
-export const STORM_MARK = [
-    "▟██▛",
-    " ▜▙",
+export const TORNADO_LOGO = [
+    " ▀▀▀▀▀▀▀▀▀▀▘",
+    "▀▀▀▀▀▀▀▀▀   ",
+    " ▀▀▀▀▀▀     ",
+    "  ▝▀▀▀▀▀    ",
+    "    ▝▀▀▘    ",
+    "      ▀     ",
 ];
-/** Widest row of the mark, in cells (every mark glyph is single-cell). */
-export const STORM_MARK_WIDTH = Math.max(...STORM_MARK.map((line) => line.length));
-/** @deprecated Alias — the home panel uses {@link STORM_MARK}. */
-export const TORNADO_LOGO = STORM_MARK;
-/** @deprecated Alias. */
-export const TORNADO_LOGO_WIDTH = STORM_MARK_WIDTH;
-/** @deprecated Compact home is the full two-row mark. */
-export const TORNADO_LOGO_COMPACT = STORM_MARK;
+/** Single idle frame. Kept for callers that index frames. */
+export const TORNADO_FRAMES = [TORNADO_LOGO];
+/** Every sprite glyph is one column. */
+export const TORNADO_LOGO_WIDTH = Math.max(...TORNADO_LOGO.map((line) => [...line].length));
+export const TORNADO_LOGO_COMPACT = TORNADO_LOGO;
+/** @deprecated Use {@link TORNADO_LOGO}. */
+export const STORM_MARK = TORNADO_LOGO;
+/** @deprecated Use {@link TORNADO_LOGO_WIDTH}. */
+export const STORM_MARK_WIDTH = TORNADO_LOGO_WIDTH;
+/** Paint one sprite row: each run of glyphs in brand green 77, spaces left bare. */
+export function paintSpriteRow(row) {
+    return row.replace(/[^ ]+/g, (run) => ansi.brightGreen(run));
+}

package/dist/ui/prompt.d.ts

@@ -23,7 +23,7 @@ export interface AskLineOptions {
      * resize cannot desync CUU counts. Pass `true` for compact, `"mini"` /
      * `"nano"` for a short pane that still shows the mark.
      */
-    header?: (columns?: number, variant?: boolean | "mini" | "nano") => string[];
+    header?: (columns?: number, variant?: boolean | "mini" | "nano", frame?: number) => string[];
 }
 /** Thrown when the user asks to close the prompt (Ctrl+D empty, or Ctrl+C twice). */
 export declare class PromptClosedError extends Error {
@@ -47,6 +47,16 @@ export declare function promptClearOverlay(boxed: boolean): string;
  * frame's row count is unknowable after the terminal rewraps.
  */
 export declare const HEADER_REDRAW_PREFIX = "\u001B[H\u001B[0J";
+export declare const MOUSE_ENABLE = "\u001B[?1000h\u001B[?1006h";
+export declare const MOUSE_DISABLE = "\u001B[?1000l\u001B[?1006l";
+export type SpriteRect = {
+    col: number;
+    row: number;
+    width: number;
+    height: number;
+};
+/** SGR coordinates and the rectangle are both 1-based. */
+export declare function hitTestSprite(col: number, row: number, rect: SpriteRect): boolean;
 export declare const DROPDOWN_MAX_COMMAND_ROWS = 8;
 export declare function formatSlashLabel(spec: CommandSpec): string;
 export declare function specMatchesTerm(spec: CommandSpec, term: string): boolean;