mintree 0.1.2

package/dist/commands/dashboard.js

@@ -0,0 +1,849 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import TextInput from "ink-text-input";
+import Spinner from "ink-spinner";
+import { execSync } from "child_process";
+import { createRequire } from "module";
+import { findBranchConventionDoc, findMainRepoRoot, getMintreeDir, pathExists, } from "../lib/git.js";
+import { resolveClaudeBinary } from "../lib/claude.js";
+import { tryExec } from "../lib/exec.js";
+import { ALLOWED_TYPES } from "../lib/branch.js";
+import { runCreate } from "../lib/worktreeCreate.js";
+import { runRemove } from "../lib/worktreeRemove.js";
+import { buildCreateMarkers, emitMarkers } from "../lib/markers.js";
+import { loadDashboard, } from "../lib/dashboard.js";
+const require = createRequire(import.meta.url);
+const { version: mintreeVersion } = require("../../package.json");
+export const description = "Interactive dashboard listing open issues assigned to you with worktree + session state";
+// xterm/iTerm/etc switch to the alternate screen buffer with these escape
+// codes. Using the buffer means the dashboard owns the whole window for its
+// lifetime, and the previous shell content reappears unchanged the moment
+// we switch back. ALT_SCREEN_ENTER also homes the cursor so the first Ink
+// render starts at row 1.
+const ALT_SCREEN_ENTER = "\x1b[?1049h\x1b[H";
+const ALT_SCREEN_LEAVE = "\x1b[?1049l";
+// SGR mouse tracking — \x1b[?1002h enables button-event tracking (press,
+// release, drag, wheel); \x1b[?1006h switches reports to the SGR extended
+// format \x1b[<button;col;row(M|m), which works past col/row 223 and is
+// what we parse below. We only consume wheel events; press/release fall
+// through harmlessly.
+const MOUSE_ON = "\x1b[?1002h\x1b[?1006h";
+const MOUSE_OFF = "\x1b[?1006l\x1b[?1002l";
+const MOUSE_SGR_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+const SCROLL_STEP = 3;
+function StateIcon({ state }) {
+    if (!state)
+        return _jsx(Text, { dimColor: true, children: "\u00B7" });
+    switch (state) {
+        case "active":
+            return _jsx(Text, { color: "green", children: "\u25CF" });
+        case "waiting":
+            return _jsx(Text, { color: "yellow", children: "!" });
+        case "idle":
+            return _jsx(Text, { dimColor: true, children: "\u25CB" });
+        case "exited":
+            return _jsx(Text, { dimColor: true, children: "\u2014" });
+    }
+}
+function truncate(s, max) {
+    if (max <= 1)
+        return s.slice(0, max);
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + "…";
+}
+/**
+ * Compact "X ago" formatter for ISO 8601 timestamps. Returns "—" for
+ * unparseable input so callers can use it directly in JSX without needing
+ * to handle the missing/invalid case themselves.
+ */
+function relativeTime(iso) {
+    if (!iso)
+        return "—";
+    const t = Date.parse(iso);
+    if (Number.isNaN(t))
+        return "—";
+    const seconds = Math.floor((Date.now() - t) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months}mo ago`;
+    const years = Math.floor(days / 365);
+    return `${years}y ago`;
+}
+// Default cap on the number of words mintree pulls from the issue title to
+// build the suggested branch description. Five words matches the typical
+// "<type>/<issue>-<short-kebab-desc>" convention found in most projects.
+// The user can always extend the desc by hand in the overlay.
+const SUGGESTED_DESC_MAX_WORDS = 5;
+/**
+ * Suggests a default kebab-case description from an issue title. Strips
+ * non-ascii / punctuation, collapses whitespace, and caps at SUGGESTED_DESC
+ * _MAX_WORDS so a verbose title doesn't produce an unreadable branch name.
+ */
+function kebabize(title) {
+    return title
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "") // strip diacritics
+        .replace(/[^a-z0-9\s-]/g, " ")
+        .split(/\s+/)
+        .filter(Boolean)
+        .slice(0, SUGGESTED_DESC_MAX_WORDS)
+        .join("-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Sanitises whatever the user typed into the desc field on every keystroke.
+ * Same rules as kebabize but without the word cap — this is for live input.
+ */
+function sanitizeDesc(value) {
+    return value
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+/, "");
+}
+function openInBrowser(url) {
+    try {
+        const cmd = process.platform === "darwin"
+            ? "open"
+            : process.platform === "win32"
+                ? "start"
+                : "xdg-open";
+        execSync(`${cmd} ${shQuote(url)}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function useTerminalSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({
+        columns: stdout?.columns ?? 100,
+        rows: stdout?.rows ?? 24,
+    });
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const onResize = () => setSize({ columns: stdout.columns ?? 100, rows: stdout.rows ?? 24 });
+        stdout.on("resize", onResize);
+        return () => {
+            stdout.off("resize", onResize);
+        };
+    }, [stdout]);
+    return size;
+}
+function HeaderRow({ repoName, claudeVersion, issueCount, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "green", children: "mintree" }), _jsx(Text, { dimColor: true, children: `  v${mintreeVersion}` }), claudeVersion && _jsx(Text, { dimColor: true, children: `   ·   claude ${claudeVersion}` }), repoName && _jsx(Text, { dimColor: true, children: `   ·   ${repoName}` })] }), _jsx(Box, { children: _jsx(Text, { bold: true, backgroundColor: "cyan", color: "black", children: ` Issues (${issueCount}) ` }) })] }));
+}
+function FooterRow({ phase, overlayKind, }) {
+    if (phase === "error") {
+        return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "q quit" }) }));
+    }
+    if (overlayKind === "create") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Tab" }), _jsx(Text, { dimColor: true, children: " switch field   " }), _jsx(Text, { bold: true, children: "\u2190/\u2192" }), _jsx(Text, { dimColor: true, children: " change type   " }), _jsx(Text, { bold: true, children: "Enter" }), _jsx(Text, { dimColor: true, children: " create + work" })] }), _jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Esc" }), _jsx(Text, { dimColor: true, children: " cancel" })] })] }));
+    }
+    if (overlayKind === "remove") {
+        return (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "y/Y" }), _jsx(Text, { dimColor: true, children: " confirm   " }), _jsx(Text, { bold: true, children: "n/Esc" }), _jsx(Text, { dimColor: true, children: " cancel" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { bold: true, children: "j/k" }), _jsx(Text, { dimColor: true, children: " nav   " }), _jsx(Text, { bold: true, children: "\u21B5" }), _jsx(Text, { dimColor: true, children: " work (resume / create)   " }), _jsx(Text, { bold: true, children: "w" }), _jsx(Text, { dimColor: true, children: " work (always create)   " }), _jsx(Text, { bold: true, children: "d" }), _jsx(Text, { dimColor: true, children: " remove" })] }) }), _jsxs(Box, { children: [_jsx(Text, { bold: true, children: "r" }), _jsx(Text, { dimColor: true, children: " refresh   " }), _jsx(Text, { bold: true, children: "o" }), _jsx(Text, { dimColor: true, children: " open in browser   " }), _jsx(Text, { bold: true, children: "PgUp/PgDn" }), _jsx(Text, { dimColor: true, children: "/" }), _jsx(Text, { bold: true, children: "wheel" }), _jsx(Text, { dimColor: true, children: " scroll detail   " }), _jsx(Text, { bold: true, children: "q" }), _jsx(Text, { dimColor: true, children: " quit" })] })] }));
+}
+function RemoveOverlayView({ overlay }) {
+    return (_jsxs(Box, { flexGrow: 1, flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: "Remove worktree" }), _jsx(Text, { dimColor: true, children: ` for #${overlay.issue.issue.number}` })] }), _jsx(Box, { marginTop: 0, children: _jsx(Text, { children: overlay.issue.issue.title }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Branch: " }), _jsx(Text, { color: "cyan", children: overlay.branch })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "State:  " }), overlay.dirty ? (_jsx(Text, { color: "yellow", children: "dirty (uncommitted changes will be lost)" })) : (_jsx(Text, { color: "green", children: "clean" }))] })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Text, { dimColor: true, children: "Removing the worktree leaves the branch and the issue's session_id in place. You can re-attach later with `mintree worktree create`." }) }), _jsx(Box, { marginTop: 1, children: overlay.dirty ? (_jsxs(Text, { children: ["This worktree is dirty. Press ", _jsx(Text, { bold: true, color: "red", children: "Y" }), " to force-remove,", " ", _jsx(Text, { bold: true, children: "N" }), "/", _jsx(Text, { bold: true, children: "Esc" }), " to cancel."] })) : (_jsxs(Text, { children: ["Press ", _jsx(Text, { bold: true, color: "green", children: "y" }), " to remove,", " ", _jsx(Text, { bold: true, children: "N" }), "/", _jsx(Text, { bold: true, children: "Esc" }), " to cancel."] })) }), overlay.error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", overlay.error] }) }))] }));
+}
+function CreateOverlayView({ overlay, onDescChange, onPromptChange, }) {
+    const labelWidth = 14;
+    const branchPreview = `${overlay.type}/${overlay.issue.issue.number}-${overlay.desc}`;
+    return (_jsxs(Box, { flexGrow: 1, flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: "Create worktree" }), _jsx(Text, { dimColor: true, children: ` for #${overlay.issue.issue.number}` })] }), _jsx(Box, { marginTop: 0, children: _jsx(Text, { children: overlay.issue.issue.title }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Box, { width: labelWidth, children: _jsx(Text, { bold: overlay.field === "type", children: overlay.field === "type" ? "▸ Type:" : "  Type:" }) }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "<  " }), _jsx(Text, { color: overlay.field === "type" ? "cyan" : undefined, bold: overlay.field === "type", children: overlay.type }), _jsx(Text, { dimColor: true, children: "  >" })] }), overlay.field === "type" && (_jsx(Text, { dimColor: true, children: "   (use ← / → to cycle)" }))] }), _jsxs(Box, { marginTop: 0, children: [_jsx(Box, { width: labelWidth, children: _jsx(Text, { bold: overlay.field === "desc", children: overlay.field === "desc" ? "▸ Description:" : "  Description:" }) }), _jsx(Box, { children: overlay.field === "desc" ? (_jsx(TextInput, { value: overlay.desc, onChange: onDescChange, placeholder: "kebab-case" })) : (_jsx(Text, { children: overlay.desc || "(empty)" })) })] }), _jsxs(Box, { marginTop: 0, children: [_jsx(Box, { width: labelWidth, children: _jsx(Text, { bold: overlay.field === "prompt", children: overlay.field === "prompt" ? "▸ Prompt:" : "  Prompt:" }) }), _jsx(Box, { children: overlay.field === "prompt" ? (_jsx(TextInput, { value: overlay.prompt, onChange: onPromptChange, placeholder: "(optional) initial message for Claude" })) : (_jsx(Text, { dimColor: true, children: overlay.prompt || "(optional — Claude starts with no message)" })) })] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Box, { width: labelWidth, children: _jsx(Text, { dimColor: true, children: "  Branch:" }) }), _jsx(Text, { color: "green", children: branchPreview })] }), _jsxs(Box, { children: [_jsx(Box, { width: labelWidth, children: _jsx(Text, { dimColor: true, children: "  Mode:" }) }), _jsx(Text, { dimColor: true, children: "--work (Claude launches in the new worktree)" })] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Suggestion is a kebab of the title (capped at ", SUGGESTED_DESC_MAX_WORDS, " words). Edit it to match your repo's branch conventions."] }), overlay.conventionDoc && (_jsx(Text, { dimColor: true, children: `This repo has \`${overlay.conventionDoc}\` — review it before creating.` }))] }), overlay.error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", overlay.error] }) }))] }));
+}
+function stateChar(state) {
+    if (!state)
+        return "·";
+    if (state === "active")
+        return "●";
+    if (state === "waiting")
+        return "!";
+    if (state === "idle")
+        return "○";
+    return "—";
+}
+function IssueListRow({ d, selected, identifierWidth, maxTitleWidth, }) {
+    const idText = `#${d.issue.number}`.padEnd(identifierWidth, " ");
+    const icon = stateChar(d.session?.state ?? null);
+    const title = truncate(d.issue.title, maxTitleWidth);
+    // One single Text with a single string so the background highlight is
+    // continuous across the whole row. Coloured per-state icons live in the
+    // detail pane instead — keeps the list selection visually solid.
+    const line = ` ${idText}  ${icon}  ${title}`;
+    return (_jsx(Box, { children: _jsx(Text, { backgroundColor: selected ? "blue" : undefined, color: selected ? "white" : undefined, children: line }) }));
+}
+// Word-wraps a single line at `width` columns, breaking on the last space
+// before the limit when that yields a reasonable cut. Falls back to a hard
+// cut for unbroken runs (long URLs, code-fence content) so the detail pane
+// width is never exceeded. An empty input returns [""] so blank lines round-
+// trip through the wrapper.
+function wrapLine(s, width) {
+    if (width <= 0)
+        return [s];
+    if (s.length <= width)
+        return [s];
+    const out = [];
+    let rest = s;
+    while (rest.length > width) {
+        const space = rest.lastIndexOf(" ", width);
+        const cut = space > Math.floor(width * 0.4) ? space : width;
+        out.push(rest.slice(0, cut));
+        rest = rest.slice(cut).replace(/^ +/, "");
+    }
+    if (rest.length > 0)
+        out.push(rest);
+    return out;
+}
+// Wraps a markdown-ish body to fit `width`, preserving paragraph breaks
+// (consecutive empty lines collapse to one) and trimming leading/trailing
+// blank lines. Used to feed the description into the flat-line renderer.
+function wrapBody(body, width) {
+    const raw = body.replace(/\r\n/g, "\n").split("\n").map(l => l.trimEnd());
+    while (raw.length > 0 && raw[0] === "")
+        raw.shift();
+    while (raw.length > 0 && raw[raw.length - 1] === "")
+        raw.pop();
+    const out = [];
+    let lastBlank = false;
+    for (const l of raw) {
+        if (l === "") {
+            if (!lastBlank)
+                out.push("");
+            lastBlank = true;
+            continue;
+        }
+        lastBlank = false;
+        for (const w of wrapLine(l, Math.max(1, width)))
+            out.push(w);
+    }
+    return out;
+}
+function sessionIconColor(state) {
+    switch (state) {
+        case "active":
+            return { text: "●", color: "green" };
+        case "waiting":
+            return { text: "!", color: "yellow" };
+        case "idle":
+            return { text: "○", dim: true };
+        case "exited":
+            return { text: "—", dim: true };
+    }
+}
+// Builds the detail pane as a flat array of styled lines so the renderer
+// can slice by `scrollOffset` and the user can scroll the entire pane (not
+// just the description). Word-wraps the issue body and title at `width` so
+// long content stays inside the pane instead of getting truncated with "…".
+function buildDetailLines(d, width) {
+    const lines = [];
+    const blank = () => [{ text: " " }];
+    const w = Math.max(20, width);
+    const titlePrefix = `#${d.issue.number} `;
+    const titleWrapped = wrapLine(d.issue.title, Math.max(8, w - titlePrefix.length));
+    titleWrapped.forEach((chunk, i) => {
+        if (i === 0) {
+            lines.push([{ text: titlePrefix, bold: true }, { text: chunk, bold: true }]);
+        }
+        else {
+            lines.push([{ text: " ".repeat(titlePrefix.length) + chunk, bold: true }]);
+        }
+    });
+    const labels = d.issue.labels.map(l => l.name);
+    const labelText = labels.length > 0 ? labels.map(l => `[${l}]`).join(" ") : "(no labels)";
+    for (const w2 of wrapLine(labelText, w))
+        lines.push([{ text: w2, dim: true }]);
+    lines.push([
+        {
+            text: `updated ${relativeTime(d.issue.updatedAt)} · created ${relativeTime(d.issue.createdAt)}`,
+            dim: true,
+        },
+    ]);
+    lines.push(blank());
+    for (const u of wrapLine(d.issue.url, w))
+        lines.push([{ text: u, dim: true }]);
+    const body = (d.issue.body ?? "").trim();
+    if (body.length > 0) {
+        lines.push(blank());
+        lines.push([{ text: "📝 Description", bold: true }]);
+        for (const bl of wrapBody(body, w - 1)) {
+            lines.push([{ text: bl ? ` ${bl}` : " ", dim: true }]);
+        }
+    }
+    lines.push(blank());
+    lines.push([{ text: "⌥ Worktree", bold: true }]);
+    if (d.worktree) {
+        for (const w2 of wrapLine(` branch: ${d.worktree.branch}`, w))
+            lines.push([{ text: w2, dim: true }]);
+        for (const w2 of wrapLine(` path:   ${d.worktree.path}`, w))
+            lines.push([{ text: w2, dim: true }]);
+        const statusLine = [{ text: ` status: `, dim: true }];
+        statusLine.push(d.worktree.dirty
+            ? { text: "dirty", color: "yellow" }
+            : { text: "clean", color: "green" });
+        if (d.worktree.ab) {
+            statusLine.push({
+                text: `  +${d.worktree.ab.ahead} / -${d.worktree.ab.behind}`,
+                dim: true,
+            });
+        }
+        lines.push(statusLine);
+        if (d.worktree.sessionId) {
+            lines.push([{ text: ` session: ${d.worktree.sessionId.slice(0, 8)}…`, dim: true }]);
+        }
+    }
+    else {
+        lines.push([{ text: " no worktree for this issue", dim: true }]);
+    }
+    lines.push(blank());
+    lines.push([{ text: "● Pull Request", bold: true }]);
+    if (d.pr) {
+        const stateColor = d.pr.state === "OPEN" ? "green" : d.pr.state === "MERGED" ? "magenta" : "yellow";
+        lines.push([
+            { text: ` #${d.pr.number}  `, dim: true },
+            { text: d.pr.state, color: stateColor },
+        ]);
+        for (const w2 of wrapLine(` ${d.pr.url}`, w))
+            lines.push([{ text: w2, dim: true }]);
+    }
+    else {
+        lines.push([{ text: " no PR yet", dim: true }]);
+    }
+    lines.push(blank());
+    lines.push([{ text: "◌ Session", bold: true }]);
+    if (d.session) {
+        const ic = sessionIconColor(d.session.state);
+        lines.push([
+            { text: ` state: `, dim: true },
+            { text: ic.text, color: ic.color, dim: ic.dim },
+            { text: ` ${d.session.state}`, dim: true },
+        ]);
+        if (d.session.message) {
+            for (const w2 of wrapLine(` message: ${d.session.message}`, w))
+                lines.push([{ text: w2, dim: true }]);
+        }
+        if (d.session.at)
+            lines.push([{ text: ` at:      ${d.session.at}`, dim: true }]);
+    }
+    else {
+        lines.push([{ text: " no live session signal", dim: true }]);
+    }
+    return lines;
+}
+function DetailPane({ d, contentWidth, contentHeight, scrollOffset, }) {
+    if (!d) {
+        return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "No issue selected." }) }));
+    }
+    const lines = buildDetailLines(d, contentWidth);
+    const totalLines = lines.length;
+    const canScroll = totalLines > contentHeight;
+    // Reserve last row for the scroll hint when overflow exists.
+    const visibleHeight = Math.max(1, canScroll ? contentHeight - 1 : contentHeight);
+    const maxOffset = Math.max(0, totalLines - visibleHeight);
+    const offset = Math.min(Math.max(0, scrollOffset), maxOffset);
+    const visible = lines.slice(offset, offset + visibleHeight);
+    let scrollHint = null;
+    if (canScroll) {
+        const atTop = offset === 0;
+        const atBottom = offset + visibleHeight >= totalLines;
+        const range = `(${offset + 1}-${Math.min(offset + visibleHeight, totalLines)} / ${totalLines})`;
+        const arrows = atTop ? "↓" : atBottom ? "↑" : "↑↓";
+        scrollHint = `${arrows} scroll ${range}`;
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [visible.map((segs, i) => (_jsx(Box, { children: _jsx(Text, { children: segs.map((seg, j) => (_jsx(Text, { color: seg.color, bold: seg.bold, dimColor: seg.dim, children: seg.text }, j))) }) }, i))), scrollHint && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: scrollHint }) }))] }));
+}
+export default function Dashboard() {
+    const { exit } = useApp();
+    const [state, setState] = useState({ phase: "loading" });
+    const [repoName, setRepoName] = useState(null);
+    const [claudeVersion, setClaudeVersion] = useState(null);
+    const { columns, rows } = useTerminalSize();
+    // Switch to the alt-screen buffer once, synchronously, on the first render
+    // pass. Doing this here (instead of inside a useEffect) is what makes the
+    // loading state already write into the alt-screen — useEffect only fires
+    // after the first commit, which leaves "Loading..." stranded on the parent
+    // buffer when the dashboard exits. The ref keeps it idempotent.
+    const altScreenEntered = useRef(false);
+    if (!altScreenEntered.current) {
+        process.stdout.write(ALT_SCREEN_ENTER);
+        altScreenEntered.current = true;
+    }
+    useEffect(() => {
+        return () => {
+            process.stdout.write(ALT_SCREEN_LEAVE);
+        };
+    }, []);
+    // Live value for the mouse handler (mounted once) to read without
+    // re-binding on every resize.
+    const listWidthRef = useRef(0);
+    const refresh = async () => {
+        const root = findMainRepoRoot();
+        if (!root) {
+            setState({
+                phase: "error",
+                message: "Not in a git repository.",
+                hint: "Run `git init` and then `mintree init`.",
+            });
+            return;
+        }
+        if (!pathExists(getMintreeDir(root))) {
+            setState({
+                phase: "error",
+                message: ".mintree/ not found in this repo.",
+                hint: "Run `mintree init` first.",
+            });
+            return;
+        }
+        const issues = await loadDashboard(root);
+        if (!issues) {
+            setState({
+                phase: "error",
+                message: "Could not fetch issues from GitHub.",
+                hint: "Check `mintree doctor` — gh must be authenticated and the repo must live on GitHub.",
+            });
+            return;
+        }
+        setState(prev => {
+            const previousIndex = prev.phase === "ready" ? prev.selectedIndex : 0;
+            const previousOverlay = prev.phase === "ready" ? prev.overlay : null;
+            const previousToast = prev.phase === "ready" ? prev.toast : null;
+            const previousScroll = prev.phase === "ready" ? prev.detailScrollOffset : 0;
+            const clamped = Math.min(previousIndex, Math.max(0, issues.length - 1));
+            // Preserve scroll only when the selected issue stayed put — clamping
+            // to a different row means the user is now reading something else.
+            const detailScrollOffset = clamped === previousIndex ? previousScroll : 0;
+            return {
+                phase: "ready",
+                issues,
+                selectedIndex: clamped,
+                detailScrollOffset,
+                refreshing: false,
+                overlay: previousOverlay,
+                toast: previousToast,
+            };
+        });
+    };
+    useEffect(() => {
+        void refresh();
+        // Cheap meta-info for the header row, fetched once on mount.
+        (async () => {
+            const repo = await tryExec("gh repo view --json nameWithOwner --jq .nameWithOwner 2>/dev/null");
+            setRepoName(repo);
+            const bin = resolveClaudeBinary();
+            if (bin) {
+                const v = await tryExec(`"${bin}" --version 2>/dev/null | head -1`);
+                if (v) {
+                    const m = v.match(/([\d.]+)/);
+                    setClaudeVersion(m && m[1] ? m[1] : v);
+                }
+            }
+        })();
+    }, []);
+    // SGR mouse tracking: enable on mount, disable on unmount, and route
+    // wheel events. Press/release/drag are ignored — we only care about
+    // scroll. Wheel button 64 = up, 65 = down.
+    useEffect(() => {
+        if (!process.stdin.isTTY)
+            return;
+        process.stdout.write(MOUSE_ON);
+        const onData = (data) => {
+            const str = data.toString("utf-8");
+            MOUSE_SGR_RE.lastIndex = 0;
+            let match;
+            while ((match = MOUSE_SGR_RE.exec(str)) !== null) {
+                if (match[4] !== "M")
+                    continue;
+                const button = parseInt(match[1], 10);
+                if (button !== 64 && button !== 65)
+                    continue;
+                const col = parseInt(match[2], 10);
+                const delta = button === 65 ? SCROLL_STEP : -SCROLL_STEP;
+                const lw = listWidthRef.current;
+                const inLeftPane = col <= lw;
+                // Functional setState so a fast wheel doesn't read stale
+                // scroll/selection through the ref between dispatches.
+                setState(prev => {
+                    if (prev.phase !== "ready")
+                        return prev;
+                    if (prev.overlay)
+                        return prev; // overlay pauses scroll routing
+                    if (inLeftPane) {
+                        const next = Math.max(0, Math.min(prev.issues.length - 1, prev.selectedIndex + delta));
+                        if (next === prev.selectedIndex)
+                            return prev;
+                        return { ...prev, selectedIndex: next, detailScrollOffset: 0 };
+                    }
+                    const next = Math.max(0, prev.detailScrollOffset + delta);
+                    if (next === prev.detailScrollOffset)
+                        return prev;
+                    return { ...prev, detailScrollOffset: next };
+                });
+            }
+        };
+        process.stdin.on("data", onData);
+        return () => {
+            process.stdout.write(MOUSE_OFF);
+            process.stdin.removeListener("data", onData);
+        };
+    }, []);
+    // While the create overlay is open, ink-text-input owns stdin and reads
+    // the leading ESC of every mouse report as key.escape — which dismisses
+    // the overlay on any click/scroll. Pause SGR tracking until the overlay
+    // closes, then re-enable.
+    useEffect(() => {
+        if (state.phase !== "ready" || !state.overlay)
+            return;
+        if (!process.stdin.isTTY)
+            return;
+        process.stdout.write(MOUSE_OFF);
+        return () => {
+            process.stdout.write(MOUSE_ON);
+        };
+    }, [state.phase === "ready" && state.overlay ? state.overlay.kind : null]);
+    // Auto-refresh every 30s while the dashboard is idle. Skipped while an
+    // overlay is open so we don't yank state from under a confirmation, and
+    // while a manual refresh is in flight to avoid stomping on its spinner.
+    const stateRef = useRef(state);
+    useEffect(() => {
+        stateRef.current = state;
+    }, [state]);
+    useEffect(() => {
+        const id = setInterval(() => {
+            const s = stateRef.current;
+            if (s.phase !== "ready")
+                return;
+            if (s.overlay)
+                return;
+            if (s.refreshing)
+                return;
+            void refresh();
+        }, 30_000);
+        return () => clearInterval(id);
+    }, []);
+    useInput((input, key) => {
+        // Esc closes the create overlay first if it's open; only then quits the
+        // dashboard. Ctrl-C and `q` always quit (the desc TextInput swallows
+        // raw `q` when it has focus, so `q` while editing types a literal q).
+        if (state.phase === "ready" && state.overlay) {
+            handleOverlayInput(input, key);
+            return;
+        }
+        if (input === "q" || key.escape || (input === "c" && key.ctrl)) {
+            exit();
+            return;
+        }
+        if (state.phase !== "ready")
+            return;
+        if (key.upArrow || input === "k") {
+            setState({
+                ...state,
+                selectedIndex: Math.max(0, state.selectedIndex - 1),
+                detailScrollOffset: 0,
+            });
+            return;
+        }
+        if (key.downArrow || input === "j") {
+            setState({
+                ...state,
+                selectedIndex: Math.min(state.issues.length - 1, state.selectedIndex + 1),
+                detailScrollOffset: 0,
+            });
+            return;
+        }
+        if (key.pageUp) {
+            setState({
+                ...state,
+                detailScrollOffset: Math.max(0, state.detailScrollOffset - SCROLL_STEP),
+            });
+            return;
+        }
+        if (key.pageDown) {
+            setState({
+                ...state,
+                detailScrollOffset: state.detailScrollOffset + SCROLL_STEP,
+            });
+            return;
+        }
+        if (input === "r") {
+            setState({ ...state, refreshing: true });
+            void refresh();
+            return;
+        }
+        if (input === "o") {
+            const issue = state.issues[state.selectedIndex];
+            if (issue)
+                openInBrowser(issue.issue.url);
+            return;
+        }
+        if (input === "w") {
+            const issue = state.issues[state.selectedIndex];
+            if (!issue)
+                return;
+            if (issue.worktree) {
+                // Already has a worktree — `w` would be a no-op; `↵` resumes.
+                return;
+            }
+            openCreateOverlay(issue);
+            return;
+        }
+        if (key.return) {
+            const issue = state.issues[state.selectedIndex];
+            if (!issue)
+                return;
+            if (issue.worktree) {
+                // Resume Claude in the existing worktree: same marker handshake
+                // as `worktree create --work`, minus the create. The wrapper
+                // will cd + run `mintree worktree work`, which itself sees the
+                // session_id in metadata and uses --resume.
+                emitMarkers([
+                    `MINTREE_CD:${issue.worktree.path}`,
+                    "MINTREE_WORK:1",
+                ]);
+                exit();
+                return;
+            }
+            openCreateOverlay(issue);
+            return;
+        }
+        if (input === "d") {
+            const issue = state.issues[state.selectedIndex];
+            if (!issue || !issue.worktree)
+                return;
+            setState({
+                ...state,
+                overlay: {
+                    kind: "remove",
+                    issue,
+                    branch: issue.worktree.branch,
+                    dirty: issue.worktree.dirty,
+                    error: null,
+                },
+                toast: null,
+            });
+            return;
+        }
+    });
+    function openCreateOverlay(issue) {
+        if (state.phase !== "ready")
+            return;
+        const root = findMainRepoRoot();
+        setState({
+            ...state,
+            overlay: {
+                kind: "create",
+                issue,
+                type: "feat",
+                desc: kebabize(issue.issue.title) || `issue-${issue.issue.number}`,
+                prompt: "",
+                field: "type",
+                error: null,
+                conventionDoc: root ? findBranchConventionDoc(root) : null,
+            },
+            toast: null,
+        });
+    }
+    function handleOverlayInput(input, key) {
+        if (state.phase !== "ready" || !state.overlay)
+            return;
+        const overlay = state.overlay;
+        if (key.escape || (input === "c" && key.ctrl)) {
+            setState({ ...state, overlay: null });
+            return;
+        }
+        if (overlay.kind === "remove") {
+            handleRemoveOverlayInput(input, key, overlay);
+            return;
+        }
+        // Create overlay from here on.
+        if (key.tab) {
+            const nextField = overlay.field === "type"
+                ? "desc"
+                : overlay.field === "desc"
+                    ? "prompt"
+                    : "type";
+            setState({
+                ...state,
+                overlay: { ...overlay, field: nextField },
+            });
+            return;
+        }
+        if (overlay.field === "type") {
+            if (key.leftArrow || input === "h") {
+                const idx = ALLOWED_TYPES.indexOf(overlay.type);
+                const next = ALLOWED_TYPES[(idx - 1 + ALLOWED_TYPES.length) % ALLOWED_TYPES.length];
+                setState({ ...state, overlay: { ...overlay, type: next } });
+                return;
+            }
+            if (key.rightArrow || input === "l") {
+                const idx = ALLOWED_TYPES.indexOf(overlay.type);
+                const next = ALLOWED_TYPES[(idx + 1) % ALLOWED_TYPES.length];
+                setState({ ...state, overlay: { ...overlay, type: next } });
+                return;
+            }
+        }
+        if (key.return) {
+            void confirmCreate(overlay);
+            return;
+        }
+        // Any other input while in the desc field is handled by <TextInput>'s
+        // own onChange, not here — useInput still fires for those keystrokes
+        // but we want them to fall through.
+    }
+    function handleRemoveOverlayInput(input, key, overlay) {
+        if (state.phase !== "ready")
+            return;
+        // Force-confirm with capital Y when dirty; lowercase y otherwise.
+        // Either Enter alone counts as "no" so we don't accidentally remove
+        // dirty state on a stray return.
+        if (input === "y" && !overlay.dirty) {
+            void confirmRemove(overlay, false);
+            return;
+        }
+        if (input === "Y" && overlay.dirty) {
+            void confirmRemove(overlay, true);
+            return;
+        }
+        if (input === "n" || input === "N" || key.return) {
+            setState({ ...state, overlay: null });
+            return;
+        }
+    }
+    async function confirmCreate(overlay) {
+        if (state.phase !== "ready")
+            return;
+        const desc = overlay.desc.trim();
+        if (!desc) {
+            setState({
+                ...state,
+                overlay: { ...overlay, error: "Description is required." },
+            });
+            return;
+        }
+        const branch = `${overlay.type}/${overlay.issue.issue.number}-${desc}`;
+        const prompt = overlay.prompt.trim();
+        const result = runCreate(branch, {
+            work: true,
+            ...(prompt.length > 0 ? { prompt } : {}),
+        });
+        if (!result.ok) {
+            setState({
+                ...state,
+                overlay: { ...overlay, error: result.message + (result.hint ? ` — ${result.hint}` : "") },
+            });
+            return;
+        }
+        emitMarkers(buildCreateMarkers({
+            worktreePath: result.worktreePath,
+            work: result.work,
+            promptFile: result.promptFile,
+            permissionMode: result.permissionMode,
+        }));
+        exit();
+    }
+    async function confirmRemove(overlay, force) {
+        if (state.phase !== "ready")
+            return;
+        const result = runRemove(overlay.branch, force);
+        if (!result.ok) {
+            setState({
+                ...state,
+                overlay: { ...overlay, error: result.message + (result.hint ? ` — ${result.hint}` : "") },
+            });
+            return;
+        }
+        // Close the overlay, surface a toast, and refetch so the row updates
+        // (worktree/session/PR all flip back to null).
+        setState({
+            ...state,
+            overlay: null,
+            toast: {
+                kind: "success",
+                text: result.variant === "pruned-orphan"
+                    ? `Pruned dangling reference for ${result.branch}.`
+                    : `Removed worktree for ${result.branch}.${result.wasDirty ? " (forced past dirty)" : ""}`,
+            },
+        });
+        void refresh();
+    }
+    if (state.phase === "loading") {
+        return (_jsxs(Box, { width: columns, height: rows, alignItems: "center", justifyContent: "center", children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Loading issues..." })] }));
+    }
+    if (state.phase === "error") {
+        return (_jsxs(Box, { width: columns, height: rows, flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", state.message] }), state.hint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", state.hint] }) })), _jsx(Box, { marginTop: 1, children: _jsx(FooterRow, { phase: "error" }) })] }));
+    }
+    const { issues, selectedIndex, refreshing, overlay, toast } = state;
+    const selected = issues[selectedIndex] ?? null;
+    const onOverlayDescChange = (next) => {
+        if (state.phase !== "ready" || !state.overlay)
+            return;
+        if (state.overlay.kind !== "create")
+            return;
+        setState({
+            ...state,
+            overlay: { ...state.overlay, desc: sanitizeDesc(next), error: null },
+        });
+    };
+    const onOverlayPromptChange = (next) => {
+        if (state.phase !== "ready" || !state.overlay)
+            return;
+        if (state.overlay.kind !== "create")
+            return;
+        setState({
+            ...state,
+            overlay: { ...state.overlay, prompt: next, error: null },
+        });
+    };
+    // Left pane is the issue list — it only needs room for "#N  ICON  title".
+    // We give it ~40% of the width so the detail pane (URLs, descriptions,
+    // branch paths) has the room it actually needs.
+    const listWidthPct = 0.40;
+    const listWidth = Math.max(32, Math.floor(columns * listWidthPct));
+    const detailWidth = columns - listWidth - 2; // border slack
+    const identifierWidth = Math.max(3, ...issues.map(d => `#${d.issue.number}`.length));
+    // Lista ocupa todo menos: " #N  ICON  " (id + 4 cols of pad/icon).
+    const maxTitleWidth = Math.max(8, listWidth - identifierWidth - 8);
+    // Reserve rows: header (2), top borders (1), footer (3).
+    const listVisibleRows = Math.max(3, rows - 9);
+    // Detail pane content height inside the bordered box. Header eats 2 rows,
+    // the box's borders eat 2, the footer eats 2-3 — match the list reserve so
+    // both panes anchor to the same outer chrome.
+    const detailContentHeight = Math.max(3, rows - 9);
+    // Mouse handler needs the current list width to route wheel events to the
+    // correct pane. Ref lets the stdin listener (mounted once) read the live
+    // value without re-binding on every resize.
+    listWidthRef.current = listWidth;
+    const startIdx = Math.max(0, Math.min(Math.max(0, issues.length - listVisibleRows), selectedIndex - Math.floor(listVisibleRows / 2)));
+    const endIdx = Math.min(issues.length, startIdx + listVisibleRows);
+    const slice = issues.slice(startIdx, endIdx);
+    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [_jsx(Box, { paddingX: 1, paddingTop: 0, flexDirection: "column", children: _jsx(HeaderRow, { repoName: repoName, claudeVersion: claudeVersion, issueCount: issues.length }) }), overlay ? (_jsx(Box, { flexGrow: 1, flexDirection: "column", borderStyle: "round", borderColor: overlay.kind === "remove" ? "yellow" : "cyan", children: overlay.kind === "create" ? (_jsx(CreateOverlayView, { overlay: overlay, onDescChange: onOverlayDescChange, onPromptChange: onOverlayPromptChange })) : (_jsx(RemoveOverlayView, { overlay: overlay })) })) : (_jsxs(Box, { flexGrow: 1, flexDirection: "row", children: [_jsx(Box, { width: listWidth, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: issues.length === 0 ? (_jsx(Text, { dimColor: true, children: "No open issues assigned to you in this repo." })) : (_jsxs(_Fragment, { children: [slice.map((d, i) => {
+                                    const absoluteIdx = startIdx + i;
+                                    return (_jsx(IssueListRow, { d: d, selected: absoluteIdx === selectedIndex, identifierWidth: identifierWidth, maxTitleWidth: maxTitleWidth }, d.issue.number));
+                                }), startIdx > 0 && (_jsxs(Text, { dimColor: true, children: ["\u2191 ", startIdx, " more above"] })), endIdx < issues.length && (_jsxs(Text, { dimColor: true, children: ["\u2193 ", issues.length - endIdx, " more below"] }))] })) }), _jsx(Box, { width: detailWidth, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(DetailPane, { d: selected, contentWidth: detailWidth - 4, contentHeight: detailContentHeight, scrollOffset: state.detailScrollOffset }) })] })), _jsxs(Box, { paddingX: 1, flexDirection: "column", children: [toast && (_jsx(Box, { children: _jsxs(Text, { color: toast.kind === "success"
+                                ? "green"
+                                : toast.kind === "error"
+                                    ? "red"
+                                    : "cyan", children: [toast.kind === "success" ? "✓ " : toast.kind === "error" ? "✗ " : "· ", toast.text] }) })), refreshing && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " refreshing" })] })), _jsx(FooterRow, { phase: "ready", overlayKind: overlay?.kind })] })] }));
+}