mergestorm 0.3.13 → 0.3.16

package/dist/commands/status.js

@@ -1,5 +1,7 @@
 import { getReview } from "../api.js";
 import { loadConfig } from "../config.js";
+import { showLinePanel } from "../ui/line-tabs.js";
+import { canBrowse, formatJobDetailLines } from "./browse.js";
 import { CommandError, DetachedError, REVIEW_EXIT, isCommandErrorCode, } from "../errors.js";
 import { ansi } from "../ui/ansi.js";
 import { renderFindings } from "../ui/findings.js";
@@ -77,6 +79,13 @@ function printPretty(row) {
         emptyMessage: envelope.status === "completed",
     });
 }
+async function showPretty(row) {
+    if (canBrowse()) {
+        await showLinePanel("Job", formatJobDetailLines(row));
+        return;
+    }
+    printPretty(row);
+}
 export async function cmdStatus(args, opts = {}) {
     const parsed = parseStatusArgs(args, {
         format: opts.defaultFormat ?? "json",
@@ -85,8 +94,14 @@ export async function cmdStatus(args, opts = {}) {
     const interactive = Boolean(opts.interactive && !json);
     const fallback = { jobId: parsed.jobId };
     let jsonPrinted = false;
-    const printJson = (row, extra = {}) => {
-        console.log(JSON.stringify(toReviewJobEnvelope(row, { ...fallback, ...extra })));
+    const printJson = async (row, extra = {}) => {
+        const text = JSON.stringify(toReviewJobEnvelope(row, { ...fallback, ...extra }), null, opts.mode === "shell" ? 2 : undefined);
+        if (opts.mode === "shell") {
+            await showLinePanel("Job", text.split("\n"));
+        }
+        else {
+            console.log(text);
+        }
         jsonPrinted = true;
     };
     try {
@@ -105,12 +120,12 @@ export async function cmdStatus(args, opts = {}) {
                     throw err;
                 if (isCommandErrorCode(err, "api_timeout")) {
                     if (json)
-                        printJson(null, { status: "in_progress", error: err.message });
+                        await printJson(null, { status: "in_progress", error: err.message });
                     throw new CommandError(err.message, REVIEW_EXIT.timeout, "review_timeout");
                 }
                 if (isCommandErrorCode(err, "rate_limited")) {
                     if (json) {
-                        printJson(null, {
+                        await printJson(null, {
                             status: "rate_limited",
                             error: err.message,
                             retryAfterSeconds: err.retryAfterSeconds,
@@ -129,15 +144,15 @@ export async function cmdStatus(args, opts = {}) {
                 : { job_id: parsed.jobId, status: "failed", error: "Invalid review response" };
             if (row.status === "failed" || row.status === "quota_exceeded") {
                 if (json)
-                    printJson(row);
+                    await printJson(row);
                 else
-                    printPretty(row);
+                    await showPretty(row);
                 throw new CommandError(`Review ${row.status}: ${row.error ?? ""}`, row.status === "quota_exceeded" ? REVIEW_EXIT.quota : REVIEW_EXIT.failed, row.status === "quota_exceeded" ? "review_quota" : "review_failed");
             }
             if (json)
-                printJson(row);
+                await printJson(row);
             else
-                printPretty(row);
+                await showPretty(row);
             return;
         }
         if (!json) {
@@ -171,7 +186,7 @@ export async function cmdStatus(args, opts = {}) {
             if (err instanceof ReviewPollTimeoutError) {
                 const message = `Timed out waiting for review ${parsed.jobId}`;
                 if (json) {
-                    printJson(err.lastRow, {
+                    await printJson(err.lastRow, {
                         jobId: parsed.jobId,
                         status: err.lastRow.status ?? "in_progress",
                         error: "Timed out waiting for review.",
@@ -181,7 +196,7 @@ export async function cmdStatus(args, opts = {}) {
             }
             if (isCommandErrorCode(err, "rate_limited")) {
                 if (json) {
-                    printJson(null, {
+                    await printJson(null, {
                         status: "rate_limited",
                         error: err.message,
                         retryAfterSeconds: err.retryAfterSeconds,
@@ -200,15 +215,15 @@ export async function cmdStatus(args, opts = {}) {
         if (row.status === "failed" || row.status === "quota_exceeded") {
             const message = `Review ${row.status}: ${row.error ?? ""}`;
             if (json)
-                printJson(row);
+                await printJson(row);
             else
-                printPretty(row);
+                await showPretty(row);
             throw new CommandError(message, row.status === "quota_exceeded" ? REVIEW_EXIT.quota : REVIEW_EXIT.failed, row.status === "quota_exceeded" ? "review_quota" : "review_failed");
         }
         if (json)
-            printJson(row);
+            await printJson(row);
         else
-            printPretty(row);
+            await showPretty(row);
     }
     catch (err) {
         if (err instanceof DetachedError)
@@ -217,7 +232,7 @@ export async function cmdStatus(args, opts = {}) {
             !jsonPrinted &&
             !(err instanceof Error && err.name === "AbortError")) {
             const message = err instanceof Error ? err.message : String(err);
-            printJson(null, { status: "failed", error: message });
+            await printJson(null, { status: "failed", error: message });
         }
         if (err instanceof CommandError &&
             (err.code === "auth_invalid" || err.code === "missing_api_key")) {

package/dist/commands/whoami.d.ts

@@ -1 +1,3 @@
-export declare function cmdWhoami(args: string[]): Promise<void>;
+export declare function cmdWhoami(args: string[], opts?: {
+    mode?: "oneshot" | "shell";
+}): Promise<void>;

package/dist/commands/whoami.js

@@ -2,13 +2,19 @@ import { getMe } from "../api.js";
 import { apiBase, configPath, loadConfig, resolveApiKey, keyDisplay } from "../config.js";
 import { CommandError } from "../errors.js";
 import { ansi } from "../ui/ansi.js";
-export async function cmdWhoami(args) {
+import { present } from "../ui/present.js";
+import { canBrowse, openTabsBrowser } from "./browse.js";
+export async function cmdWhoami(args, opts = {}) {
     const asJson = args.includes("--json");
     const cfg = await loadConfig();
     const key = resolveApiKey(cfg);
     if (!key) {
         throw new CommandError("Not logged in. Run `mergestorm login`.");
     }
+    if (!asJson && canBrowse()) {
+        await openTabsBrowser("status");
+        return;
+    }
     const me = await getMe(cfg);
     const payload = {
         key_prefix: me?.key.prefix ?? keyDisplay(key),
@@ -20,16 +26,24 @@ export async function cmdWhoami(args) {
         usage: me?.usage ?? null,
     };
     if (asJson) {
-        console.log(JSON.stringify(payload, null, 2));
+        const text = JSON.stringify(payload, null, 2);
+        if (opts.mode === "shell") {
+            await present("Account", text.split("\n"));
+            return;
+        }
+        console.log(text);
         return;
     }
-    console.log(`  Key      ${ansi.bold(String(payload.key_prefix))}${payload.key_name ? ` (${payload.key_name})` : ""}`);
+    const lines = [
+        `  Key      ${ansi.bold(String(payload.key_prefix))}${payload.key_name ? ` (${payload.key_name})` : ""}`,
+    ];
     if (payload.plan_key) {
-        console.log(`  Plan     ${payload.plan_label_key ?? payload.plan_key}`);
+        lines.push(`  Plan     ${payload.plan_label_key ?? payload.plan_key}`);
     }
-    console.log(`  API      ${payload.api_base}`);
-    console.log(`  Config   ${payload.config_path}`);
+    lines.push(`  API      ${payload.api_base}`);
+    lines.push(`  Config   ${payload.config_path}`);
     if (!me) {
-        console.log(ansi.dim("  (live account details unavailable — older API or offline)"));
+        lines.push(ansi.dim("  (live account details unavailable — older API or offline)"));
     }
+    await present("Account", lines);
 }

package/dist/errors.d.ts

@@ -2,7 +2,7 @@
  * Stable machine codes for CommandError control flow.
  * UX copy in `message` may change freely; match on `code`, never on message text.
  */
-export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "missing_api_key" | "registered_parent" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited";
+export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited";
 /** Stable one-shot exit codes for machine callers of `mergestorm review`. */
 export declare const REVIEW_EXIT: {
     readonly success: 0;

package/dist/repo-identity.d.ts

@@ -2,7 +2,7 @@ export declare const LEGACY_STACK_META_REL: string;
 export declare function gitTopLevel(cwd?: string): string;
 export declare function gitCommonDir(cwd?: string): string;
 /**
- * A physical clone and all its linked worktrees share one authoring state.
+ * Each worktree has its own authoring state.
  * Independent clones remain isolated even when they point at the same remote.
  */
 export declare function stableRepoId(cwd?: string): string;

package/dist/repo-identity.js

@@ -41,11 +41,22 @@ export function gitCommonDir(cwd = process.cwd()) {
     }
 }
 /**
- * A physical clone and all its linked worktrees share one authoring state.
+ * Each worktree has its own authoring state.
  * Independent clones remain isolated even when they point at the same remote.
  */
 export function stableRepoId(cwd = process.cwd()) {
-    return createHash("sha256").update(gitCommonDir(cwd)).digest("hex").slice(0, 20);
+    let raw;
+    try {
+        raw = git(["rev-parse", "--git-dir"], cwd).trim();
+    }
+    catch (err) {
+        rethrowIfNotARepo(err);
+    }
+    const absolute = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
+    return createHash("sha256")
+        .update(realpathSync(absolute))
+        .digest("hex")
+        .slice(0, 20);
 }
 export function cliStacksRoot() {
     return path.join(mergestormHome(), "stacks");

package/dist/shell.js

@@ -5,21 +5,15 @@ import { dispatchCommand, shellCommandSpecs, } from "./commands/registry.js";
 import { ansi } from "./ui/ansi.js";
 import { printBannerHeader, shellPrompt } from "./ui/banner.js";
 import { CTRL_C_EXIT_HINT, CtrlCExitGate } from "./ui/ctrl-c-exit.js";
-import { askLine, formatSlashLabel, PromptClosedError } from "./ui/prompt.js";
+import { openHelpBrowser } from "./commands/help.js";
+import { showLinePanel } from "./ui/line-tabs.js";
+import { askLine, PromptClosedError } from "./ui/prompt.js";
+async function showShellNotice(title, message) {
+    const lines = message.split("\n").flatMap((line) => (line ? [`  ${line}`] : [""]));
+    await showLinePanel(title, [...lines, "", `  ${ansi.dim("q to return")}`]);
+}
 /** Shell autocomplete + `/help` � derived from the command registry (STRUCT-01). */
 export const COMMANDS = shellCommandSpecs();
-function printHelp() {
-    const rows = COMMANDS.map((c) => {
-        const label = formatSlashLabel(c).slice(1);
-        return `  ${ansi.green("/" + label.padEnd(20))} ${c.summary}`;
-    }).join("\n");
-    console.log(`
-  ${ansi.bold("Commands")}
-${rows}
-
-  Dashboard: https://mergestorm.ai/settings#api
-`);
-}
 /** Strips an optional leading "/" so both "review" and "/review" work. */
 export function parseLine(line) {
     let trimmed = line.trim();
@@ -34,10 +28,22 @@ export function parseLine(line) {
     return { cmd, args: parts.slice(1) };
 }
 export async function runShell() {
-    try {
-        await printBannerHeader();
-    }
-    catch { /* banner is best-effort */ }
+    // Idle is always the home screen: header + docked prompt. Command TUIs
+    // (usage / credits / status) and printed output become scrollback when
+    // the next askLine homes + ED 0. Do not retire the header after the
+    // first command � that is what floated a bare prompt at the top.
+    let banner = null;
+    const showBanner = async () => {
+        try {
+            banner = await printBannerHeader({ paint: false });
+        }
+        catch {
+            // Keep the previous chrome on a transient refresh failure rather than
+            // blanking the always-on home header.
+        }
+        return banner;
+    };
+    banner = await showBanner();
     const history = [];
     let busyAbort = null;
     const idleCtrlC = new CtrlCExitGate();
@@ -71,6 +77,11 @@ export async function runShell() {
                     prompt: shellPrompt(loggedIn),
                     history,
                     commands: COMMANDS,
+                    ...(banner
+                        ? {
+                            header: (columns, variant) => banner.rows(columns, variant),
+                        }
+                        : {}),
                 });
             }
             catch (err) {
@@ -90,15 +101,12 @@ export async function runShell() {
             if (cmd === "exit" || cmd === "quit")
                 break;
             if (cmd === "help" || cmd === "?") {
-                printHelp();
+                await openHelpBrowser();
                 continue;
             }
             if (cmd === "clear") {
                 output.write("");
-                try {
-                    await printBannerHeader();
-                }
-                catch { /* banner is best-effort */ }
+                await showBanner();
                 continue;
             }
             busyAbort = new AbortController();
@@ -107,33 +115,33 @@ export async function runShell() {
                     mode: "shell",
                     signal: busyAbort.signal,
                     afterAuth: async () => {
-                        try {
-                            await printBannerHeader();
-                        }
-                        catch { /* banner is best-effort */ }
+                        await showBanner();
                     },
                 });
                 if (!ok) {
-                    console.error(ansi.dim(`unknown command "${cmd}" -- type help`));
+                    await showShellNotice("Error", `unknown command "${cmd}"\ntype help for the list`);
                 }
             }
             catch (err) {
                 if (err instanceof DetachedError) {
-                    console.log(`\n${ansi.yellow(err.message)}`);
+                    await showShellNotice("Detached", err.message);
                 }
                 else if (err instanceof CommandError) {
-                    console.error(ansi.red(err.message));
+                    await showShellNotice("Error", err.message);
                 }
                 else if (err instanceof Error && err.name === "AbortError") {
-                    console.log(ansi.dim("\naborted"));
+                    await showShellNotice("Aborted", "aborted");
                 }
                 else {
-                    console.error(ansi.red(err instanceof Error ? err.message : String(err)));
+                    await showShellNotice("Error", err instanceof Error ? err.message : String(err));
                 }
             }
             finally {
                 busyAbort = null;
             }
+            // Re-capture the home header so usage/credits shown above the prompt
+            // reflect what the command just consumed (e.g. review spending a credit).
+            await showBanner();
         }
     }
     finally {

package/dist/stack-dto.d.ts

@@ -45,6 +45,25 @@ export type StackLayerChecks = {
     pending: number;
     failure: number;
     failingName: string | null;
+    /**
+     * True when the persisted `ci_checks` carries a `namedRuns` seed (enrich
+     * writes it so CI webhook deliveries fold into the snapshot). Pre-seeding
+     * rows are false — the webhook cannot fold into them, so the interval poll
+     * must keep enriching until the first enrich seeds one (#1602). Status-only
+     * layers (empty `namedRuns` over a non-empty rollup) are also false — the
+     * webhook refuses to fold into an empty map, so the poll keeps enriching
+     * them (#1602).
+     */
+    namedRunsSeeded?: boolean;
+    /**
+     * True when the persisted `namedRuns` carries the reserved synthetic
+     * "commit status" run at a pending/failure verdict. Webhook deliveries
+     * re-key by check/context name and can never advance that seed, so the
+     * interval poll must keep enriching until the next enrich re-seeds it green
+     * (or drops it). Absent (false) when the seed is green — folds keep that
+     * layer fresh (#1602).
+     */
+    combinedStatusSeeded?: boolean;
 };
 /** Closing / Development-sidebar issue. Cap 3 on the wire. */
 export type StackLinkedIssue = {
@@ -70,6 +89,14 @@ export type StackLayerDto = {
     branch: string;
     parentBranch: string | null;
     prNumber: number;
+    /** Persisted PR timing and diff snapshots from pr_stats. */
+    openedAt: string | null;
+    mergedAt: string | null;
+    closedAt: string | null;
+    additions: number | null;
+    deletions: number | null;
+    openAdditions: number | null;
+    openDeletions: number | null;
     position: number;
     state: StackBranchState;
     title: string | null;
@@ -96,6 +123,12 @@ export type StackLayerDto = {
     mergeable: boolean | null;
     /** GitHub REST mergeable_state; null when unknown. */
     mergeableState: string | null;
+    /** Most recently observed PR head SHA. */
+    headSha?: string | null;
+    /** Head SHA that produced mergeable / mergeableState. */
+    mergeableHeadSha?: string | null;
+    /** GitHub PR draft flag from enrich; the auto-land watcher never enqueues a draft. */
+    draft?: boolean | null;
     /**
      * Vortex-style linked issues (keywords + Development sidebar), cap 3.
      * null until first enrich finds any; kept on merged unit members (unlike CI).
@@ -121,6 +154,14 @@ export type StackLayerDto = {
 };
 export type StackUnitMemberDto = {
     prNumber: number;
+    /** Persisted PR timing and diff snapshots from pr_stats. */
+    openedAt: string | null;
+    mergedAt: string | null;
+    closedAt: string | null;
+    additions: number | null;
+    deletions: number | null;
+    openAdditions: number | null;
+    openDeletions: number | null;
     branch: string;
     position: number;
     seamState: string;
@@ -173,13 +214,63 @@ export type StackDto = {
     trunkBranch: string;
     /** Real trunk the review unit eventually lands into. */
     landTarget: string;
-    autoPromoteWhenGreen: boolean;
     /**
      * Dashboard-only archive (#963): set hides the stack from the active Work
      * list; GitHub PRs stay open. Only PATCH /stacks/:id toggles it.
      */
     archivedAt: string | null;
+    /**
+     * Auto land (#1511): enqueue this unit-less single-PR stack when eligible.
+     * Missing on older payloads is off.
+     */
+    autoEnqueueWhenReady?: boolean;
+    /**
+     * Per-stack Vortex auto-review override. `null` (or missing) follows the
+     * account `auto_review_enabled` flag; a boolean wins in both directions.
+     */
+    autoReviewOverride?: boolean | null;
+    /**
+     * Per-stack Cyclone auto-patch override. `null` (or missing) follows the
+     * account `auto_patch_enabled` flag; a boolean wins in both directions.
+     */
+    autoPatchOverride?: boolean | null;
     layers: StackLayerDto[];
     /** Present when a review-unit row exists for this stack. */
     unit?: StackUnitDto;
 };
+export type MergeQueueEntryState = "queued" | "running" | "waiting" | "landed" | "bounced" | "cancelled";
+export type MergeQueueEnqueuedBy = "human" | "agent";
+export type MergeQueueEnqueuedVia = "dashboard" | "cli" | "chat" | "api" | "mcp";
+export type MergeQueueBounceKind = "ci_failure" | "ci_timeout" | "head_moved" | "tempest_findings" | "seam_findings" | "restack_conflict" | "pr_draft" | "merge_failed" | "gh_error";
+/** Structured bounce handoff — enough for the bar chip and the chat quote. */
+export type MergeQueueBounceDetail = {
+    kind: MergeQueueBounceKind;
+    prNumber?: number;
+    headSha?: string;
+    failingCheck?: string;
+    conflictBranch?: string;
+    conflictDetail?: string;
+    message?: string;
+};
+export type MergeQueueEntryDto = {
+    id: string;
+    stackId: string;
+    owner: string;
+    repo: string;
+    state: MergeQueueEntryState;
+    /** 1-based FIFO among this user's live entries; `0` on bounced history rows (MQ-7). */
+    position: number;
+    waitReason: string | null;
+    bounceReason: string | null;
+    bounceDetail: MergeQueueBounceDetail | null;
+    enqueuedBy: MergeQueueEnqueuedBy;
+    enqueuedVia: MergeQueueEnqueuedVia;
+    enqueuedAt: string;
+    attempts: number;
+    landedPrNumbers: number[];
+    /** Combined PR head the queue verified. Null until the worker records it. */
+    verifyHeadSha: string | null;
+    /** Target tip included in the verified PR head. Null until recorded. */
+    verifyBaseSha: string | null;
+    finishedAt: string | null;
+};

package/dist/stack-meta.d.ts

@@ -5,6 +5,10 @@ export type StackLayerMeta = {
 };
 export type LocalStack = {
     layers: StackLayerMeta[];
+    autoEnqueueWhenReady?: boolean;
+    /** Per-open override carried from `stack create` to `stack submit`; absent = account flag. */
+    autoReviewOverride?: boolean;
+    autoPatchOverride?: boolean;
 };
 export type StackMeta = {
     version: 2;
@@ -20,6 +24,14 @@ export declare function loadStackMeta(cwd?: string, stacksRoot?: string): Promis
 export declare function emptyStackMeta(trunk: string): StackMeta;
 export declare function activeStack(meta: StackMeta): LocalStack;
 export declare function activeLayers(meta: StackMeta): StackLayerMeta[];
+export declare function setActiveAutoEnqueue(meta: StackMeta, enabled: boolean | undefined): StackMeta;
+/** Per-open automation flags remembered on the active local stack until submit. */
+export type LocalStackPolicy = {
+    autoEnqueueWhenReady?: boolean;
+    autoReviewOverride?: boolean;
+    autoPatchOverride?: boolean;
+};
+export declare function setActivePolicy(meta: StackMeta, policy: LocalStackPolicy): StackMeta;
 export declare function saveStackMeta(meta: StackMeta, cwd?: string, stacksRoot?: string): Promise<void>;
 /** Explicit recovery. Does not touch branches, PRs, or registered server stacks. */
 export declare function resetStackMeta(cwd?: string, stacksRoot?: string): Promise<void>;

package/dist/stack-meta.js

@@ -8,6 +8,11 @@ import path from "node:path";
 import { CommandError, isCommandErrorCode } from "./errors.js";
 import { git } from "./git.js";
 import { cliStacksRoot, gitTopLevel, LEGACY_STACK_META_REL, legacyStackMetaPath, repoStateDir, stackMetaPath as resolveStackMetaPath, } from "./repo-identity.js";
+const LOCAL_STACK_FLAGS = [
+    "autoEnqueueWhenReady",
+    "autoReviewOverride",
+    "autoPatchOverride",
+];
 /** Exported only for legacy migration/tests. New state never uses this path. */
 export const STACK_META_REL = LEGACY_STACK_META_REL;
 export function stackMetaPath(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
@@ -35,10 +40,18 @@ function normalizeMeta(raw) {
             if (!stack ||
                 typeof stack !== "object" ||
                 !Array.isArray(stack.layers) ||
-                !stack.layers.every(isLayer)) {
+                !stack.layers.every(isLayer) ||
+                LOCAL_STACK_FLAGS.some((flag) => stack[flag] !== undefined &&
+                    typeof stack[flag] !== "boolean")) {
                 throw new Error("Stack authoring state has a malformed stack entry; run `mg stack reset --force` to clear it.");
             }
-            stacks.push({ layers: stack.layers });
+            const entry = { layers: stack.layers };
+            for (const flag of LOCAL_STACK_FLAGS) {
+                const value = stack[flag];
+                if (typeof value === "boolean")
+                    entry[flag] = value;
+            }
+            stacks.push(entry);
         }
         const active = obj.active;
         if (typeof active !== "number" ||
@@ -165,6 +178,22 @@ export function activeStack(meta) {
 export function activeLayers(meta) {
     return activeStack(meta).layers;
 }
+export function setActiveAutoEnqueue(meta, enabled) {
+    return setActiveStackFlag(meta, "autoEnqueueWhenReady", enabled);
+}
+export function setActivePolicy(meta, policy) {
+    let next = meta;
+    for (const flag of LOCAL_STACK_FLAGS) {
+        next = setActiveStackFlag(next, flag, policy[flag]);
+    }
+    return next;
+}
+function setActiveStackFlag(meta, flag, value) {
+    if (value === undefined)
+        return meta;
+    const stacks = meta.stacks.map((stack, index) => index === meta.active ? { ...stack, [flag]: value } : stack);
+    return { ...meta, stacks };
+}
 export async function saveStackMeta(meta, cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
     const file = stackMetaPath(cwd, stacksRoot);
     const dir = path.dirname(file);
@@ -229,7 +258,7 @@ export function appendLayer(meta, layer) {
         }
     }
     const stacks = meta.stacks.map((stack, index) => index === meta.active
-        ? { layers: [...stack.layers, layer] }
+        ? { ...stack, layers: [...stack.layers, layer] }
         : stack);
     return { ...meta, stacks };
 }

package/dist/ui/ansi.d.ts

@@ -9,4 +9,6 @@ export declare const ansi: {
     brightGreen: (t: string) => string;
     invert: (t: string) => string;
     boldGreen: (t: string) => string;
+    /** Prompt / mark ink. Never 32 — that reads as sick dark green. */
+    boldBrightGreen: (t: string) => string;
 };

package/dist/ui/ansi.js

@@ -24,4 +24,6 @@ export const ansi = {
     brightGreen: (t) => wrap("92", 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),
 };

package/dist/ui/banner.d.ts

@@ -1,4 +1,36 @@
+import { type MeResponse } from "../api.js";
 /** Used by the non-interactive `usage()` path in cli.ts — the boxed banner is shell-only. */
 export declare function printWordmark(): void;
-export declare function printBannerHeader(): Promise<void>;
-export declare function shellPrompt(loggedIn: boolean): string;
+/** Everything the welcome panel needs, captured once so redraws stay sync. */
+export type BannerState = {
+    version: string;
+    me: MeResponse | null;
+    key: string | undefined;
+    keyInvalid: boolean;
+};
+/** Full welcome, mid pane, or Claude-style short chrome that still shows the mark. */
+export type BannerDensity = "full" | "compact" | "mini" | "nano";
+/** `true` = compact. Strings pick the short-pane densities. */
+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[];
+};
+/**
+ * The whole welcome panel as rows, reflowed to `columns`. Every row fits in
+ * `columns - 1` cells so a redraw's cursor math stays honest; below
+ * MIN_BOXED_COLUMNS the frame drops away instead of wrapping.
+ */
+export declare function buildBannerRows(state: BannerState, columns?: number, opts?: {
+    compact?: boolean;
+    density?: BannerDensity;
+}): string[];
+/**
+ * Print the welcome panel and return a handle whose `rows()` reflows the
+ * same data for a new width (used by the prompt's resize redraw).
+ */
+export declare function printBannerHeader(opts?: {
+    /** When false, only build the handle; the prompt paints the rows. */
+    paint?: boolean;
+}): Promise<BannerHandle>;
+export declare function shellPrompt(_loggedIn: boolean): string;