santree 0.5.0 → 0.5.2

package/dist/commands/dashboard.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useReducer, useCallback, useRef, useState } from "react";
 import { Text, Box, useInput, useStdout, useApp } from "ink";
 import Spinner from "ink-spinner";
@@ -9,7 +9,7 @@ import * as fs from "fs";
 import * as path from "path";
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
-import { findMainRepoRoot, createWorktree, getDefaultBranch, getBaseBranch, hasInitScript, getInitScriptPath, removeWorktree, getDiffTool, } from "../lib/git.js";
+import { findMainRepoRoot, createWorktree, getDefaultBranch, getBaseBranch, hasInitScript, getInitScriptPath, removeWorktree, getDiffTool, getWorktreeStatus, stageFile, unstageFile, stageAll, unstageAll, discardFile, } from "../lib/git.js";
 import { run, spawnAsync } from "../lib/exec.js";
 import { resolveAgentBinary } from "../lib/ai.js";
 import { getInstalledClaudeVersion } from "../lib/version.js";
@@ -28,7 +28,7 @@ import ReviewList from "../lib/dashboard/ReviewList.js";
 import ReviewDetailPanel, { buildReviewActions } from "../lib/dashboard/ReviewDetailPanel.js";
 import { CommitOverlay, PrCreateOverlay } from "../lib/dashboard/Overlays.js";
 import { MultilineTextArea } from "../lib/dashboard/MultilineTextArea.js";
-import DiffOverlay, { flattenTreeFiles, computeDiffLayout } from "../lib/dashboard/DiffOverlay.js";
+import DiffOverlay, { flattenTreeFiles, computeDiffLayout, clampDiffLeftWidth, DIFF_DIVIDER_WIDTH, } from "../lib/dashboard/DiffOverlay.js";
 import { CURRENT_VERSION, CLAUDE_CODE_PACKAGE, getLatestVersion, getCachedLatestVersion, getLatestVersionFor, getCachedLatestVersionFor, isUpdateAvailable, } from "../lib/version.js";
 export const description = "Interactive dashboard of your Linear issues";
 const execAsync = promisify(exec);
@@ -193,11 +193,15 @@ function Tab({ active, label, mode }) {
  * Single-line global keymap shown at the bottom-left of the dashboard. The
  * `E workspace` hint only appears when the action is meaningful
  * (`SANTREE_EDITOR` is `code`/`cursor` and a `.code-workspace` file exists in
- * the repo root).
+ * the repo root). When the diff overlay is active, the keymap switches to
+ * diff-specific bindings since the global ones don't apply.
  */
-function CommandBar({ showWorkspace }) {
+function CommandBar({ showWorkspace, mode = "default", }) {
     const dot = _jsx(Text, { dimColor: true, children: "  ·  " });
     const Key = ({ k }) => (_jsx(Text, { color: "cyan", bold: true, children: k }));
+    if (mode === "diff") {
+        return (_jsxs(Text, { children: [_jsx(Key, { k: "j/k" }), _jsx(Text, { dimColor: true, children: " file" }), dot, _jsx(Key, { k: "\u21E7\u2191\u2193" }), _jsx(Text, { dimColor: true, children: " scroll" }), dot, _jsx(Key, { k: "\u2423" }), _jsx(Text, { dimColor: true, children: " stage" }), dot, _jsx(Key, { k: "a" }), _jsx(Text, { dimColor: true, children: " all" }), dot, _jsx(Key, { k: "d" }), _jsx(Text, { dimColor: true, children: " discard" }), dot, _jsx(Key, { k: "e" }), _jsx(Text, { dimColor: true, children: " edit" }), dot, _jsx(Key, { k: "q" }), _jsx(Text, { dimColor: true, children: " close" })] }));
+    }
     return (_jsxs(Text, { children: [_jsx(Key, { k: "j/k" }), _jsx(Text, { dimColor: true, children: " nav" }), dot, _jsx(Key, { k: "\u21E7\u2191\u2193" }), _jsx(Text, { dimColor: true, children: " scroll" }), dot, _jsx(Key, { k: "1/2" }), _jsx(Text, { dimColor: true, children: " tabs" }), showWorkspace ? (_jsxs(_Fragment, { children: [dot, _jsx(Key, { k: "E" }), _jsx(Text, { dimColor: true, children: " workspace" })] })) : null, dot, _jsx(Key, { k: "R" }), _jsx(Text, { dimColor: true, children: " refresh" }), dot, _jsx(Key, { k: "q" }), _jsx(Text, { dimColor: true, children: " quit" })] }));
 }
 // ── Component ─────────────────────────────────────────────────────────
@@ -218,7 +222,7 @@ export default function Dashboard() {
     const repoRootRef = useRef(null);
     const stateRef = useRef(state);
     stateRef.current = state;
-    const draggingRef = useRef(false);
+    const draggingRef = useRef(null);
     const [termSize, setTermSize] = useState({
         columns: stdout?.columns ?? 80,
         rows: stdout?.rows ?? 24,
@@ -264,6 +268,13 @@ export default function Dashboard() {
     const leftWidthRef = useRef(leftWidth);
     leftWidthRef.current = leftWidth;
     const rightWidth = innerWidth - leftWidth - separatorWidth;
+    // Diff overlay's left pane width — null means "use the default formula"
+    // (computed inside computeDiffLayout). Becomes a number once the user drags
+    // the divider, and persists across overlay open/close while the dashboard
+    // session is alive.
+    const [diffLeftWidth, setDiffLeftWidth] = useState(null);
+    const diffLeftWidthRef = useRef(diffLeftWidth);
+    diffLeftWidthRef.current = diffLeftWidth;
     // Header (1) + tab strip (1) + 2 borders + command bar (1, inside box) = 5 rows
     const contentHeight = Math.max(3, rows - 5);
     const LIST_FOOTER_HEIGHT = 0;
@@ -333,11 +344,20 @@ export default function Dashboard() {
             const sepW = 3;
             // Release — stop dragging
             if (isRelease && draggingRef.current) {
-                draggingRef.current = false;
+                draggingRef.current = null;
                 return;
             }
             // Drag — resize if actively dragging
             if (isDrag && draggingRef.current) {
+                if (draggingRef.current === "diff") {
+                    // DiffOverlay starts at abs col 2 with width=innerWidth; its
+                    // 1-col divider sits at relative col (leftWidth+1) → abs col
+                    // (leftWidth+2). Setting newLeft = col - 2 keeps it under the
+                    // cursor; clampDiffLeftWidth enforces pane minimums.
+                    const innerW = Math.max(40, cols - 2);
+                    setDiffLeftWidth(clampDiffLeftWidth(col - 2, innerW));
+                    return;
+                }
                 // col is 1-based; outer border consumes col 1, so left pane spans cols 2..(lw+1).
                 // Setting newLeft = col - 1 keeps the divider at the user's cursor.
                 const newLeft = Math.max(minW, Math.min(col - 1, cols - 2 - sepW - minW));
@@ -361,12 +381,15 @@ export default function Dashboard() {
                         files: s.diffFiles,
                         fileIndex: s.diffFileIndex,
                         fileScrollOffset: s.diffFileScrollOffset,
+                        leftWidthOverride: diffLeftWidthRef.current ?? undefined,
                     });
                     // Body's first line is at absolute row 6 (title + tab + top border + overlay title + rule)
                     const bodyRow = row - 6;
                     if (bodyRow < 0 || bodyRow >= layout.bodyHeight)
                         return;
-                    if (col <= layout.leftWidth) {
+                    // DiffOverlay starts at abs col 2; left pane occupies abs cols
+                    // 2..(leftWidth+1).
+                    if (col <= layout.leftWidth + 1) {
                         const maxIdx = s.diffFiles.length - 1;
                         if (maxIdx < 0)
                             return;
@@ -414,7 +437,7 @@ export default function Dashboard() {
             }
             if (!isPress)
                 return;
-            // Diff overlay click: select file row in left pane
+            // Diff overlay click: drag divider, or select file row in left pane
             {
                 const s = stateRef.current;
                 if (s.overlay === "diff") {
@@ -427,8 +450,17 @@ export default function Dashboard() {
                         files: s.diffFiles,
                         fileIndex: s.diffFileIndex,
                         fileScrollOffset: s.diffFileScrollOffset,
+                        leftWidthOverride: diffLeftWidthRef.current ?? undefined,
                     });
-                    if (col > layout.leftWidth)
+                    // Divider sits at abs col leftWidth+2 (DiffOverlay starts at
+                    // abs col 2; divider at relative col leftWidth+1). Allow ±1
+                    // tolerance — a 1-col target is hard to hit precisely.
+                    const diffDivAbsCol = layout.leftWidth + 2;
+                    if (col >= diffDivAbsCol - 1 && col <= diffDivAbsCol - 1 + DIFF_DIVIDER_WIDTH + 1) {
+                        draggingRef.current = "diff";
+                        return;
+                    }
+                    if (col > layout.leftWidth + 1)
                         return;
                     const bodyRow = row - 6;
                     if (bodyRow < 0 || bodyRow >= layout.bodyHeight)
@@ -447,7 +479,7 @@ export default function Dashboard() {
             const divStart = lw + 2;
             const divEnd = lw + 1 + sepW;
             if (col >= divStart && col <= divEnd) {
-                draggingRef.current = true;
+                draggingRef.current = "main";
                 return;
             }
             // Left-click press: select item in left pane (cols 2..lw+1)
@@ -487,8 +519,16 @@ export default function Dashboard() {
             await refresh(true);
         };
         init();
-        // Auto-refresh every 30s
-        refreshTimerRef.current = setInterval(() => refresh(), 30_000);
+        // Auto-refresh every 30s. While the diff overlay is open, also bump
+        // the diff refresh tick so new/removed files (created or deleted
+        // outside the dashboard) eventually show up. Stage/unstage already
+        // patch XY in place, so this is purely about file-set drift.
+        refreshTimerRef.current = setInterval(() => {
+            refresh();
+            if (stateRef.current.overlay === "diff") {
+                dispatch({ type: "DIFF_REFRESH_FILES" });
+            }
+        }, 30_000);
         return () => {
             if (refreshTimerRef.current)
                 clearInterval(refreshTimerRef.current);
@@ -554,17 +594,49 @@ export default function Dashboard() {
     useEffect(() => {
         if (state.overlay !== "diff" || !state.diffWorktreePath || !state.diffBaseBranch)
             return;
-        if (!state.diffLoadingFiles)
-            return;
         const cwd = state.diffWorktreePath;
         const base = state.diffBaseBranch;
         void (async () => {
             try {
                 const { stdout: mergeBaseOut } = await execAsync(`git -C "${cwd}" merge-base "${base}" HEAD`);
                 const mergeBase = mergeBaseOut.trim() || base;
-                const { stdout } = await execAsync(`git -C "${cwd}" diff --name-status "${mergeBase}"`);
+                const [{ stdout }, porcelain] = await Promise.all([
+                    execAsync(`git -C "${cwd}" diff --name-status "${mergeBase}"`),
+                    getWorktreeStatus(cwd).catch(() => []),
+                ]);
                 const files = parseNameStatus(stdout);
-                const ordered = flattenTreeFiles(files);
+                // Merge porcelain (working-tree state) into the merge-base file list.
+                // XY status drives stage/unstage UX; untracked files (`??`) only show
+                // up here since `git diff` ignores them.
+                const porcelainByPath = new Map();
+                for (const p of porcelain)
+                    porcelainByPath.set(p.path, p);
+                const enriched = files.map((f) => {
+                    const p = porcelainByPath.get(f.path);
+                    if (!p)
+                        return f;
+                    porcelainByPath.delete(f.path);
+                    return {
+                        ...f,
+                        indexStatus: p.index,
+                        workingStatus: p.working,
+                        isUntracked: p.index === "?" && p.working === "?",
+                    };
+                });
+                // Untracked entries left over → add as new DiffFile rows so they
+                // appear in the tree and can be staged.
+                for (const p of porcelainByPath.values()) {
+                    if (p.index === "?" && p.working === "?") {
+                        enriched.push({
+                            path: p.path,
+                            status: "?",
+                            indexStatus: p.index,
+                            workingStatus: p.working,
+                            isUntracked: true,
+                        });
+                    }
+                }
+                const ordered = flattenTreeFiles(enriched);
                 dispatch({ type: "DIFF_FILES_LOADED", files: ordered, mergeBase });
             }
             catch (err) {
@@ -572,7 +644,7 @@ export default function Dashboard() {
                 dispatch({ type: "DIFF_FILES_ERROR", error: msg });
             }
         })();
-    }, [state.overlay, state.diffWorktreePath, state.diffBaseBranch, state.diffLoadingFiles]);
+    }, [state.overlay, state.diffWorktreePath, state.diffBaseBranch, state.diffRefreshTick]);
     // ── Diff overlay: load content for selected file ──────────────────
     // If SANTREE_DIFF_TOOL is set, pipe `git diff` output through the tool so
     // the user's preferred renderer (delta, diff-so-fancy, etc.) handles
@@ -589,7 +661,15 @@ export default function Dashboard() {
         dispatch({ type: "DIFF_CONTENT_LOADING" });
         void (async () => {
             try {
-                if (tool) {
+                if (file.isUntracked) {
+                    // Untracked files aren't in `git diff` output — fake a "full
+                    // addition" diff via --no-index against /dev/null. git exits 1
+                    // when files differ; that's expected, so capture stdout via
+                    // spawnAsync rather than execAsync (which throws on non-zero).
+                    const { output } = await spawnAsync("git", ["-C", cwd, "diff", "--no-color", "--no-index", "--", "/dev/null", file.path], { cwd });
+                    dispatch({ type: "DIFF_CONTENT_LOADED", content: output });
+                }
+                else if (tool) {
                     // Pipe git diff (with colors enabled so the tool can pass them
                     // through if desired) into the configured tool. Use spawn pipes
                     // rather than shell to avoid quoting concerns.
@@ -1275,6 +1355,42 @@ export default function Dashboard() {
         }
         // Diff overlay
         if (state.overlay === "diff") {
+            // Pending discard modal — intercepts y/n/ESC/q so they don't
+            // also close the diff overlay.
+            if (state.diffPendingDiscard) {
+                const pd = state.diffPendingDiscard;
+                if (input === "y") {
+                    const cwd = state.diffWorktreePath;
+                    if (!cwd) {
+                        dispatch({ type: "DIFF_DISCARD_CANCEL" });
+                        return;
+                    }
+                    (async () => {
+                        try {
+                            await discardFile(cwd, pd.path, pd.isUntracked);
+                            dispatch({ type: "DIFF_DISCARD_CANCEL" });
+                            dispatch({ type: "DIFF_REFRESH_FILES" });
+                            dispatch({
+                                type: "SET_ACTION_MESSAGE",
+                                message: pd.isUntracked
+                                    ? `Deleted ${pd.path}`
+                                    : `Discarded changes in ${pd.path}`,
+                            });
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            dispatch({ type: "DIFF_DISCARD_CANCEL" });
+                            dispatch({ type: "SET_ACTION_MESSAGE", message: `Discard failed: ${msg}` });
+                        }
+                    })();
+                    return;
+                }
+                if (input === "n" || key.escape || input === "q") {
+                    dispatch({ type: "DIFF_DISCARD_CANCEL" });
+                    return;
+                }
+                return;
+            }
             if (key.escape || input === "q") {
                 dispatch({ type: "DIFF_CLOSE" });
                 return;
@@ -1292,6 +1408,7 @@ export default function Dashboard() {
                 files: state.diffFiles,
                 fileIndex: state.diffFileIndex,
                 fileScrollOffset: state.diffFileScrollOffset,
+                leftWidthOverride: diffLeftWidth ?? undefined,
             });
             const totalLines = state.diffContent ? state.diffContent.split("\n").length : 0;
             const maxScroll = Math.max(0, totalLines - layout.bodyHeight);
@@ -1329,6 +1446,98 @@ export default function Dashboard() {
                 dispatch({ type: "DIFF_FILE_SELECT", index: prev });
                 return;
             }
+            // Stage / unstage / discard — only meaningful when the worktree
+            // path is known. All ops dispatch DIFF_REFRESH_FILES so the
+            // porcelain status (and selection) updates immediately.
+            const cwd = state.diffWorktreePath;
+            const currentFile = state.diffFiles[state.diffFileIndex];
+            if (input === " " && cwd && currentFile) {
+                // Toggle: if anything is staged for this file, unstage it;
+                // otherwise stage. Files with no uncommitted state (only
+                // committed changes vs base) have no XY → no-op. Updates XY
+                // in place via porcelain re-fetch — no full reload, no spinner.
+                const xRaw = currentFile.indexStatus;
+                const yRaw = currentFile.workingStatus;
+                if (xRaw === undefined && yRaw === undefined) {
+                    dispatch({
+                        type: "SET_ACTION_MESSAGE",
+                        message: "No uncommitted changes to stage on this file",
+                    });
+                    return;
+                }
+                const x = xRaw ?? " ";
+                const isStaged = x !== " " && x !== "?";
+                const path = currentFile.path;
+                (async () => {
+                    try {
+                        if (isStaged)
+                            await unstageFile(cwd, path);
+                        else
+                            await stageFile(cwd, path);
+                        const porcelain = await getWorktreeStatus(cwd);
+                        dispatch({ type: "DIFF_STATUS_UPDATED", porcelain });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        dispatch({
+                            type: "SET_ACTION_MESSAGE",
+                            message: `${isStaged ? "Unstage" : "Stage"} failed: ${msg}`,
+                        });
+                    }
+                })();
+                return;
+            }
+            if (input === "a" && cwd) {
+                // Stage-all if anything is unstaged or untracked; otherwise
+                // unstage everything. Untracked files have Y === "?" so they
+                // fall under "unstaged" — staging them adds them to the index.
+                // Same in-place porcelain refresh as `space`.
+                const anyUnstaged = state.diffFiles.some((f) => {
+                    const y = f.workingStatus;
+                    return y !== undefined && y !== " ";
+                });
+                (async () => {
+                    try {
+                        if (anyUnstaged)
+                            await stageAll(cwd);
+                        else
+                            await unstageAll(cwd);
+                        const porcelain = await getWorktreeStatus(cwd);
+                        dispatch({ type: "DIFF_STATUS_UPDATED", porcelain });
+                        dispatch({
+                            type: "SET_ACTION_MESSAGE",
+                            message: anyUnstaged ? "Staged all changes" : "Unstaged all changes",
+                        });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        dispatch({ type: "SET_ACTION_MESSAGE", message: `Failed: ${msg}` });
+                    }
+                })();
+                return;
+            }
+            if (input === "d" && currentFile) {
+                if (currentFile.indexStatus === undefined && currentFile.workingStatus === undefined) {
+                    dispatch({
+                        type: "SET_ACTION_MESSAGE",
+                        message: "No uncommitted changes to discard",
+                    });
+                    return;
+                }
+                dispatch({
+                    type: "DIFF_DISCARD_OPEN",
+                    path: currentFile.path,
+                    isUntracked: !!currentFile.isUntracked,
+                });
+                return;
+            }
+            // Open the selected file in the user's editor — useful when
+            // the diff alone isn't enough context. Editor resolution
+            // matches the rest of santree (SANTREE_EDITOR > "code").
+            if (input === "e" && cwd && currentFile) {
+                openInEditor(path.join(cwd, currentFile.path));
+                return;
+            }
             return;
         }
         // Confirm delete overlay
@@ -1851,17 +2060,22 @@ export default function Dashboard() {
                                     const defaultBranch = getDefaultBranch();
                                     const label = branch === defaultBranch ? `${branch} (default)` : branch;
                                     return (_jsx(Text, { children: _jsxs(Text, { color: selected ? "cyan" : undefined, bold: selected, children: [selected ? "> " : "  ", label] }) }, branch));
-                                }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "j/k to navigate, Enter to select, ESC to cancel" })] }) })) : state.overlay === "confirm-delete" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Remove worktree?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: selectedIssue?.worktree?.branch ?? "" }), selectedIssue?.worktree?.dirty && (_jsx(Text, { color: "yellow", children: "Warning: worktree has uncommitted changes" })), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "red", bold: true, children: "y" }), "  Confirm"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "n" }), "  Cancel"] })] }) })) : state.overlay === "diff" ? (_jsx(DiffOverlay, { width: innerWidth, height: contentHeight, ticketId: state.diffTicketId ?? "", baseBranch: state.diffBaseBranch ?? "", files: state.diffFiles, fileIndex: state.diffFileIndex, fileScrollOffset: state.diffFileScrollOffset, content: state.diffContent, contentScrollOffset: state.diffContentScrollOffset, loadingFiles: state.diffLoadingFiles, loadingContent: state.diffLoadingContent, error: state.diffError, selectionBg: theme.selectionBg })) : state.overlay === "confirm-setup" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Run setup script?" }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: ".santree/init.sh" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "green", bold: true, children: "y" }), "  Run setup"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", bold: true, children: "n" }), "  Skip"] })] }) })) : (_jsxs(Box, { flexGrow: 1, children: [_jsx(Box, { width: leftWidth, children: state.activeTab === "reviews" ? (_jsx(ReviewList, { flatReviews: state.flatReviews, selectedIndex: state.reviewSelectedIndex, scrollOffset: state.reviewListScrollOffset, height: contentHeight, width: leftWidth, selectionBg: theme.selectionBg })) : state.flatIssues.length === 0 ? (_jsx(Box, { width: leftWidth, height: contentHeight, justifyContent: "center", alignItems: "center", children: _jsx(Text, { color: "yellow", children: "No active issues" }) })) : (_jsx(IssueList, { groups: state.groups, flatIssues: state.flatIssues, selectedIndex: state.selectedIndex, scrollOffset: state.listScrollOffset, height: contentHeight, width: leftWidth, selectionBg: theme.selectionBg })) }), _jsx(Box, { flexDirection: "column", width: 3, children: Array.from({ length: contentHeight }).map((_, i) => (_jsx(Text, { dimColor: true, children: " │ " }, i))) }), _jsx(Box, { width: rightWidth, children: state.activeTab === "reviews" && state.creatingForTicket ? (_jsxs(Box, { flexDirection: "column", width: rightWidth, height: contentHeight, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Setting up worktree for ", state.creatingForTicket, "..."] }), state.creationLogs
+                                }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "j/k to navigate, Enter to select, ESC to cancel" })] }) })) : state.overlay === "confirm-delete" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Remove worktree?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: selectedIssue?.worktree?.branch ?? "" }), selectedIssue?.worktree?.dirty && (_jsx(Text, { color: "yellow", children: "Warning: worktree has uncommitted changes" })), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "red", bold: true, children: "y" }), "  Confirm"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "n" }), "  Cancel"] })] }) })) : state.overlay === "diff" ? (_jsx(DiffOverlay, { width: innerWidth, height: contentHeight, ticketId: state.diffTicketId ?? "", baseBranch: state.diffBaseBranch ?? "", files: state.diffFiles, fileIndex: state.diffFileIndex, fileScrollOffset: state.diffFileScrollOffset, content: state.diffContent, contentScrollOffset: state.diffContentScrollOffset, loadingFiles: state.diffLoadingFiles, loadingContent: state.diffLoadingContent, error: state.diffError, selectionBg: theme.selectionBg, leftWidthOverride: diffLeftWidth ?? undefined, pendingDiscard: state.diffPendingDiscard })) : state.overlay === "confirm-setup" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Run setup script?" }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: ".santree/init.sh" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "green", bold: true, children: "y" }), "  Run setup"] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", bold: true, children: "n" }), "  Skip"] })] }) })) : (_jsxs(Box, { flexGrow: 1, children: [_jsx(Box, { width: leftWidth, children: state.activeTab === "reviews" ? (_jsx(ReviewList, { flatReviews: state.flatReviews, selectedIndex: state.reviewSelectedIndex, scrollOffset: state.reviewListScrollOffset, height: contentHeight, width: leftWidth, selectionBg: theme.selectionBg })) : state.flatIssues.length === 0 ? (_jsx(Box, { width: leftWidth, height: contentHeight, justifyContent: "center", alignItems: "center", children: _jsx(Text, { color: "yellow", children: "No active issues" }) })) : (_jsx(IssueList, { groups: state.groups, flatIssues: state.flatIssues, selectedIndex: state.selectedIndex, scrollOffset: state.listScrollOffset, height: contentHeight, width: leftWidth, selectionBg: theme.selectionBg })) }), _jsx(Box, { flexDirection: "column", width: 3, children: Array.from({ length: contentHeight }).map((_, i) => (_jsx(Text, { dimColor: true, children: " │ " }, i))) }), _jsx(Box, { width: rightWidth, children: state.activeTab === "reviews" && state.creatingForTicket ? (_jsxs(Box, { flexDirection: "column", width: rightWidth, height: contentHeight, children: [_jsxs(Text, { color: "yellow", bold: true, children: ["Setting up worktree for ", state.creatingForTicket, "..."] }), state.creationLogs
                                             .split("\n")
                                             .slice(-(contentHeight - 1))
-                                            .map((line, i) => (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: line }) }, i)))] })) : state.activeTab === "reviews" ? (_jsx(ReviewDetailPanel, { item: selectedReview, scrollOffset: state.reviewDetailScrollOffset, height: contentHeight, width: rightWidth })) : state.overlay === "commit" ? (_jsx(CommitOverlay, { width: rightWidth, height: contentHeight, branch: state.commitBranch, ticketId: state.commitTicketId, gitStatus: state.commitGitStatus, phase: state.commitPhase, message: state.commitMessage, error: state.commitError, dispatch: dispatch, onSubmit: handleCommitSubmit })) : state.overlay === "pr-create" ? (_jsx(PrCreateOverlay, { width: rightWidth, height: contentHeight, branch: state.prCreateBranch, ticketId: state.prCreateTicketId, phase: state.prCreatePhase, error: state.prCreateError, url: state.prCreateUrl, body: state.prCreateBody, title: state.prCreateTitle, dispatch: dispatch })) : (_jsx(DetailPanel, { issue: selectedIssue, scrollOffset: state.detailScrollOffset, height: contentHeight, width: rightWidth, creatingForTicket: state.creatingForTicket, creationLogs: state.creationLogs })) })] })), _jsxs(Box, { children: [_jsx(Box, { width: leftWidth + separatorWidth, paddingX: 1, children: _jsx(CommandBar, { showWorkspace: hasWorkspaceFile }) }), _jsx(Box, { width: rightWidth, children: _jsx(ActionRow, { activeTab: state.activeTab, selectedIssue: selectedIssue, selectedReview: selectedReview }) })] })] })] }));
+                                            .map((line, i) => (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: line }) }, i)))] })) : state.activeTab === "reviews" ? (_jsx(ReviewDetailPanel, { item: selectedReview, scrollOffset: state.reviewDetailScrollOffset, height: contentHeight, width: rightWidth })) : state.overlay === "commit" ? (_jsx(CommitOverlay, { width: rightWidth, height: contentHeight, branch: state.commitBranch, ticketId: state.commitTicketId, gitStatus: state.commitGitStatus, phase: state.commitPhase, message: state.commitMessage, error: state.commitError, dispatch: dispatch, onSubmit: handleCommitSubmit })) : state.overlay === "pr-create" ? (_jsx(PrCreateOverlay, { width: rightWidth, height: contentHeight, branch: state.prCreateBranch, ticketId: state.prCreateTicketId, phase: state.prCreatePhase, error: state.prCreateError, url: state.prCreateUrl, body: state.prCreateBody, title: state.prCreateTitle, dispatch: dispatch })) : (_jsx(DetailPanel, { issue: selectedIssue, scrollOffset: state.detailScrollOffset, height: contentHeight, width: rightWidth, creatingForTicket: state.creatingForTicket, creationLogs: state.creationLogs })) })] })), _jsx(Box, { children: state.overlay === "diff" ? (_jsx(Box, { width: innerWidth, paddingX: 1, children: _jsx(CommandBar, { showWorkspace: hasWorkspaceFile, mode: "diff" }) })) : (_jsxs(_Fragment, { children: [_jsx(Box, { width: leftWidth + separatorWidth, paddingX: 1, children: _jsx(CommandBar, { showWorkspace: hasWorkspaceFile, mode: "default" }) }), _jsx(Box, { width: rightWidth, children: _jsx(ActionRow, { activeTab: state.activeTab, selectedIssue: selectedIssue, selectedReview: selectedReview, overlay: state.overlay }) })] })) })] })] }));
 }
 /**
  * Renders the per-issue action key hints (Resume / Editor / View diff / …)
  * lifted out of the detail panels so they sit on the same row as the global
  * command bar. Empty when nothing is selected.
  */
-function ActionRow({ activeTab, selectedIssue, selectedReview, }) {
+function ActionRow({ activeTab, selectedIssue, selectedReview, overlay, }) {
+    // During the diff overlay, none of the per-issue actions apply (View diff
+    // is what got us here, Commit/PR/etc. need the detail panel context). Keep
+    // the row blank so the diff-specific CommandBar reads cleanly.
+    if (overlay === "diff")
+        return _jsx(Text, { children: " " });
     const items = activeTab === "reviews"
         ? selectedReview
             ? buildReviewActions(selectedReview)

package/dist/lib/dashboard/DiffOverlay.d.ts

@@ -14,6 +14,19 @@ interface Props {
     error: string | null;
     /** Theme-adapted selection background. Falls back to dark navy. */
     selectionBg?: string;
+    /**
+     * User-set left pane width (from divider drag). Falls back to the default
+     * formula when undefined. Always clamped against pane minimums.
+     */
+    leftWidthOverride?: number;
+    /**
+     * When non-null, render a confirmation modal over the body asking the user
+     * to confirm discarding tracked changes or deleting an untracked file.
+     */
+    pendingDiscard?: {
+        path: string;
+        isUntracked: boolean;
+    } | null;
 }
 interface RenderedRow {
     prefix: string;
@@ -22,6 +35,10 @@ interface RenderedRow {
     dim?: boolean;
     bold?: boolean;
     fileIndex: number | null;
+    xy?: {
+        index: string;
+        working: string;
+    };
 }
 export declare function flattenTreeFiles(files: DiffFile[]): DiffFile[];
 export interface DiffLayout {
@@ -39,12 +56,18 @@ export interface DiffLayout {
  * Shared between DiffOverlay (rendering) and the dashboard mouse handler
  * (mapping click coords back to file indices).
  */
+export declare const DIFF_LEFT_MIN = 20;
+export declare const DIFF_RIGHT_MIN = 20;
+export declare const DIFF_DIVIDER_WIDTH = 1;
+export declare function defaultDiffLeftWidth(width: number): number;
+export declare function clampDiffLeftWidth(leftWidth: number, width: number): number;
 export declare function computeDiffLayout(opts: {
     width: number;
     height: number;
     files: DiffFile[];
     fileIndex: number;
     fileScrollOffset: number;
+    leftWidthOverride?: number;
 }): DiffLayout;
-export default function DiffOverlay({ width, height, ticketId, baseBranch, files, fileIndex, fileScrollOffset, content, contentScrollOffset, loadingFiles, loadingContent, error, selectionBg, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function DiffOverlay({ width, height, ticketId, baseBranch, files, fileIndex, fileScrollOffset, content, contentScrollOffset, loadingFiles, loadingContent, error, selectionBg, leftWidthOverride, pendingDiscard, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/lib/dashboard/DiffOverlay.js

@@ -75,12 +75,37 @@ function renderTree(dir, depth, rows, fileCounter) {
         }
         else {
             const idx = fileCounter.value++;
-            rows.push({
-                prefix: indent,
-                label: `${child.file.status} ${child.name}`,
-                color: statusColor(child.file.status),
-                fileIndex: idx,
-            });
+            const file = child.file;
+            const hasUncommitted = file.indexStatus !== undefined || file.workingStatus !== undefined;
+            if (hasUncommitted) {
+                // Lazygit-style XY display — XY conveys the staged/unstaged state,
+                // so we drop the merge-base status letter from the label to avoid
+                // redundant "M  M foo.ts"-style rows. The XY chars are colored at
+                // render time (green for index, red for working).
+                rows.push({
+                    prefix: indent,
+                    label: child.name,
+                    fileIndex: idx,
+                    xy: {
+                        index: file.indexStatus ?? " ",
+                        working: file.workingStatus ?? " ",
+                    },
+                });
+            }
+            else {
+                // Committed-only files (no working-tree state vs HEAD). Dimmed
+                // so the user can tell at a glance that stage/unstage/discard
+                // don't apply — only files showing a colored XY column are
+                // actionable. The merge-base status letter still tells the
+                // reviewer what changed vs base.
+                rows.push({
+                    prefix: indent,
+                    label: `${file.status} ${child.name}`,
+                    color: statusColor(file.status),
+                    dim: true,
+                    fileIndex: idx,
+                });
+            }
         }
     }
 }
@@ -112,12 +137,24 @@ export function flattenTreeFiles(files) {
  * Shared between DiffOverlay (rendering) and the dashboard mouse handler
  * (mapping click coords back to file indices).
  */
+export const DIFF_LEFT_MIN = 20;
+export const DIFF_RIGHT_MIN = 20;
+export const DIFF_DIVIDER_WIDTH = 1;
+export function defaultDiffLeftWidth(width) {
+    return Math.min(48, Math.max(24, Math.floor(width * 0.32)));
+}
+export function clampDiffLeftWidth(leftWidth, width) {
+    const max = Math.max(DIFF_LEFT_MIN, width - DIFF_DIVIDER_WIDTH - DIFF_RIGHT_MIN);
+    return Math.max(DIFF_LEFT_MIN, Math.min(leftWidth, max));
+}
 export function computeDiffLayout(opts) {
     const headerHeight = 2;
-    const footerHeight = 1;
-    const bodyHeight = Math.max(3, opts.height - headerHeight - footerHeight);
-    const leftWidth = Math.min(48, Math.max(24, Math.floor(opts.width * 0.32)));
-    const rightWidth = Math.max(20, opts.width - leftWidth - 1);
+    // Keymap footer lives in the dashboard's global CommandBar — don't reserve
+    // a row here or we'd render two stacked keymap rows.
+    const bodyHeight = Math.max(3, opts.height - headerHeight);
+    const requestedLeft = opts.leftWidthOverride ?? defaultDiffLeftWidth(opts.width);
+    const leftWidth = clampDiffLeftWidth(requestedLeft, opts.width);
+    const rightWidth = Math.max(DIFF_RIGHT_MIN, opts.width - leftWidth - DIFF_DIVIDER_WIDTH);
     const rows = [];
     const tree = buildTree(opts.files);
     renderTree(tree, 0, rows, { value: 0 });
@@ -194,8 +231,15 @@ function truncateVisible(s, max) {
     return out + "…";
 }
 // ── Component ─────────────────────────────────────────────────────────
-export default function DiffOverlay({ width, height, ticketId, baseBranch, files, fileIndex, fileScrollOffset, content, contentScrollOffset, loadingFiles, loadingContent, error, selectionBg = "#1e3a5f", }) {
-    const layout = computeDiffLayout({ width, height, files, fileIndex, fileScrollOffset });
+export default function DiffOverlay({ width, height, ticketId, baseBranch, files, fileIndex, fileScrollOffset, content, contentScrollOffset, loadingFiles, loadingContent, error, selectionBg = "#1e3a5f", leftWidthOverride, pendingDiscard = null, }) {
+    const layout = computeDiffLayout({
+        width,
+        height,
+        files,
+        fileIndex,
+        fileScrollOffset,
+        leftWidthOverride,
+    });
     const { bodyHeight, leftWidth, rightWidth, rows, effectiveScroll, selectedRowIdx } = layout;
     const visibleRows = rows.slice(effectiveScroll, effectiveScroll + bodyHeight);
     // Right pane: split content into lines and slice for scroll. If the content
@@ -226,18 +270,30 @@ export default function DiffOverlay({ width, height, ticketId, baseBranch, files
         const p = currentFile.path;
         truncatedPath = p.length > pathRoom ? "…" + p.slice(-Math.max(0, pathRoom - 1)) : p;
     }
-    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, overflow: "hidden", children: [_jsxs(Box, { flexShrink: 0, width: width, children: [_jsx(Text, { bold: true, color: "cyan", children: "Diff" }), _jsx(Text, { dimColor: true, children: meta }), currentFile && pathRoom > 0 && _jsx(Text, { dimColor: true, children: sep }), currentFile && pathRoom > 0 && _jsx(Text, { children: truncatedPath })] }), _jsx(Box, { flexShrink: 0, width: width, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: "─".repeat(width) }) }), _jsxs(Box, { height: bodyHeight, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", width: leftWidth, height: bodyHeight, overflow: "hidden", paddingRight: 1, children: loadingFiles ? (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " Loading files..." })] })) : error ? (_jsx(Text, { color: "red", children: error })) : files.length === 0 ? (_jsx(Text, { dimColor: true, children: "No changes" })) : (visibleRows.map((row, i) => {
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, overflow: "hidden", children: [_jsxs(Box, { flexShrink: 0, width: width, children: [_jsx(Text, { bold: true, color: "cyan", children: "Diff" }), _jsx(Text, { dimColor: true, children: meta }), currentFile && pathRoom > 0 && _jsx(Text, { dimColor: true, children: sep }), currentFile && pathRoom > 0 && _jsx(Text, { children: truncatedPath })] }), _jsx(Box, { flexShrink: 0, width: width, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: "─".repeat(width) }) }), pendingDiscard ? (_jsx(Box, { height: bodyHeight, flexShrink: 0, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, color: "red", children: pendingDiscard.isUntracked ? "Delete file?" : "Discard changes?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: pendingDiscard.path }), pendingDiscard.isUntracked && (_jsx(Text, { color: "yellow", children: "Warning: untracked file will be permanently deleted" })), !pendingDiscard.isUntracked && (_jsx(Text, { color: "yellow", children: "Warning: uncommitted changes will be lost" })), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "red", bold: true, children: "y" }), "  Confirm"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "n" }), "  Cancel"] })] }) })) : (_jsxs(Box, { height: bodyHeight, flexShrink: 0, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", width: leftWidth, height: bodyHeight, overflow: "hidden", paddingRight: 1, children: loadingFiles ? (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " Loading files..." })] })) : error ? (_jsx(Text, { color: "red", children: error })) : files.length === 0 ? (_jsx(Text, { dimColor: true, children: "No changes" })) : (visibleRows.map((row, i) => {
                             const absIdx = effectiveScroll + i;
                             const isSelected = absIdx === selectedRowIdx;
+                            const bg = isSelected ? selectionBg : undefined;
+                            // Lazygit-style XY rendering — index char (green) + working
+                            // char (red), then a separator and the file name. Each
+                            // nested <Text> gets the same backgroundColor so the
+                            // selection highlight covers the whole row uniformly.
+                            if (row.xy) {
+                                const x = row.xy.index || " ";
+                                const y = row.xy.working || " ";
+                                const xColor = x.trim() ? "green" : "gray";
+                                const yColor = y.trim() ? "red" : "gray";
+                                return (_jsxs(Text, { backgroundColor: bg, bold: row.bold || isSelected, wrap: "truncate", children: [_jsx(Text, { backgroundColor: bg, children: row.prefix }), _jsx(Text, { color: xColor, backgroundColor: bg, bold: true, children: x }), _jsx(Text, { color: yColor, backgroundColor: bg, bold: true, children: y }), _jsx(Text, { backgroundColor: bg, children: ` ${row.label}` })] }, i));
+                            }
                             const text = `${row.prefix}${row.label}`;
                             // Selected row keeps its own color (file-status hue or directory
                             // blue) but gets the theme-aware selection bg + bold so it stays
                             // readable in light and dark modes alike.
-                            return (_jsx(Text, { color: row.color, backgroundColor: isSelected ? selectionBg : undefined, bold: row.bold || isSelected, dimColor: row.dim, wrap: "truncate", children: text }, i));
+                            return (_jsx(Text, { color: row.color, backgroundColor: bg, bold: row.bold || isSelected, dimColor: row.dim, wrap: "truncate", children: text }, i));
                         })) }), _jsx(Box, { flexDirection: "column", height: bodyHeight, children: Array.from({ length: bodyHeight }).map((_, i) => (_jsx(Text, { dimColor: true, children: "\u2502" }, i))) }), _jsx(Box, { flexDirection: "column", width: rightWidth, height: bodyHeight, overflow: "hidden", paddingLeft: 1, children: loadingContent ? (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " Loading diff..." })] })) : !currentFile ? (_jsx(Text, { dimColor: true, children: "Select a file" })) : visibleLines.length === 0 ? (_jsx(Text, { dimColor: true, children: "(empty diff)" })) : (visibleLines.map((line, i) => {
                             // rightWidth includes the paddingLeft={1} of the wrapper Box,
                             // so usable column count is rightWidth - 1.
                             const cell = truncateVisible(line.text || " ", Math.max(1, rightWidth - 1));
                             return (_jsx(Text, { color: line.color, bold: line.bold, dimColor: line.dim, children: cell }, i));
-                        })) })] }), _jsx(Box, { flexShrink: 0, width: width, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: "j/k file \u2022 J/K scroll \u2022 g/G top/bot \u2022 click select \u2022 wheel scroll \u2022 q close" }) })] }));
+                        })) })] }))] }));
 }

package/dist/lib/dashboard/ReviewList.js

@@ -9,20 +9,20 @@ function checksIndicator(checks) {
         return { text: "\u2713", color: "green" };
     return { text: "\u25cf", color: "yellow" };
 }
-const FOOTER_HEIGHT = 2;
 const HEADER_ROWS = 1;
 export function getReviewListRowCount(flatReviews) {
     return HEADER_ROWS + flatReviews.length;
 }
 export default function ReviewList({ flatReviews, selectedIndex, scrollOffset, height, width, selectionBg = "#1e3a5f", }) {
-    const listHeight = height - FOOTER_HEIGHT;
+    // Keymap footer lives in the dashboard's global CommandBar \u2014 use the full
+    // pane height for the list so we don't render two stacked keymap rows.
+    const listHeight = height;
     const numColWidth = 6;
     const authorColWidth = 12;
     const changesColWidth = 10;
     const checksColWidth = 2;
     const fixedWidth = 2 + numColWidth + 1 + authorColWidth + 1 + changesColWidth + 1 + checksColWidth;
     const titleMaxWidth = Math.max(width - fixedWidth, 10);
-    const footerRule = "\u2500".repeat(width);
     const totalRows = HEADER_ROWS + flatReviews.length;
     const visibleStart = scrollOffset;
     const visibleEnd = Math.min(visibleStart + listHeight, totalRows);
@@ -49,5 +49,5 @@ export default function ReviewList({ flatReviews, selectedIndex, scrollOffset, h
         const bg = selected ? selectionBg : undefined;
         rows.push(_jsxs(Box, { width: width, children: [_jsxs(Text, { backgroundColor: bg, bold: selected, children: [cursor, " "] }), _jsx(Text, { backgroundColor: bg, color: pr.isDraft ? "gray" : "green", children: num.padEnd(numColWidth) }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, bold: selected, children: title.padEnd(titleMaxWidth) }), _jsx(Text, { backgroundColor: bg, dimColor: true, children: author.padStart(authorColWidth) }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsxs(Text, { backgroundColor: bg, children: [_jsx(Text, { color: "green", children: `+${item.additions}` }), _jsx(Text, { dimColor: true, children: "/" }), _jsx(Text, { color: "red", children: `-${item.deletions}` }), "".padStart(Math.max(0, changesColWidth - changes.length))] }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: selected ? (ci.color === "gray" ? "gray" : ci.color) : ci.color, children: ci.text.padStart(checksColWidth) })] }, `${pr.number}`));
     }
-    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(Box, { flexDirection: "column", height: listHeight, children: rows }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: footerRule }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", bold: true, children: "j/k" }), _jsx(Text, { color: "white", children: " Navigate" }), "   ", _jsxs(Text, { color: "cyan", bold: true, children: ["Shift + ", "\u2191\u2193"] }), _jsx(Text, { color: "white", children: " Scroll detail" }), "   ", _jsx(Text, { color: "cyan", bold: true, children: "o" }), _jsx(Text, { color: "white", children: " Open PR" }), "   ", _jsx(Text, { color: "cyan", bold: true, children: "Tab" }), _jsx(Text, { color: "white", children: " Issues" }), "   ", _jsx(Text, { color: "cyan", bold: true, children: "q" }), _jsx(Text, { color: "white", children: " Quit" })] })] })] }));
+    return (_jsx(Box, { flexDirection: "column", width: width, height: height, children: _jsx(Box, { flexDirection: "column", height: listHeight, children: rows }) }));
 }

package/dist/lib/dashboard/types.d.ts

@@ -69,6 +69,9 @@ export interface DiffFile {
     path: string;
     status: DiffFileStatus;
     oldPath?: string;
+    indexStatus?: string;
+    workingStatus?: string;
+    isUntracked?: boolean;
 }
 export type CommitPhase = "idle" | "confirm-stage" | "awaiting-message" | "committing" | "pushing" | "done" | "error";
 export type PrCreatePhase = "idle" | "choose-mode" | "pushing" | "filling" | "review" | "confirm" | "creating" | "done" | "error";
@@ -126,6 +129,11 @@ export interface DashboardState {
     diffLoadingFiles: boolean;
     diffLoadingContent: boolean;
     diffError: string | null;
+    diffPendingDiscard: {
+        path: string;
+        isUntracked: boolean;
+    } | null;
+    diffRefreshTick: number;
 }
 export type DashboardAction = {
     type: "SET_DATA";
@@ -286,6 +294,21 @@ export type DashboardAction = {
 } | {
     type: "DIFF_CONTENT_SCROLL";
     offset: number;
+} | {
+    type: "DIFF_REFRESH_FILES";
+} | {
+    type: "DIFF_STATUS_UPDATED";
+    porcelain: {
+        path: string;
+        index: string;
+        working: string;
+    }[];
+} | {
+    type: "DIFF_DISCARD_OPEN";
+    path: string;
+    isUntracked: boolean;
+} | {
+    type: "DIFF_DISCARD_CANCEL";
 } | {
     type: "DIFF_CLOSE";
 };

package/dist/lib/dashboard/types.js

@@ -53,6 +53,8 @@ export const initialState = {
     diffLoadingFiles: false,
     diffLoadingContent: false,
     diffError: null,
+    diffPendingDiscard: null,
+    diffRefreshTick: 0,
 };
 export function reducer(state, action) {
     switch (action.type) {
@@ -301,17 +303,73 @@ export function reducer(state, action) {
                 diffLoadingFiles: true,
                 diffLoadingContent: false,
                 diffError: null,
+                diffPendingDiscard: null,
+                diffRefreshTick: 0,
             };
-        case "DIFF_FILES_LOADED":
+        case "DIFF_FILES_LOADED": {
+            // Preserve the user's selection across reloads (after stage/unstage/
+            // discard) by matching the previously-selected file's path. Falls back
+            // to the clamped index when the path is gone (e.g. file was discarded).
+            const prevPath = state.diffFiles[state.diffFileIndex]?.path;
+            let newIndex = 0;
+            if (prevPath) {
+                const found = action.files.findIndex((f) => f.path === prevPath);
+                if (found >= 0)
+                    newIndex = found;
+                else
+                    newIndex = Math.min(state.diffFileIndex, Math.max(0, action.files.length - 1));
+            }
             return {
                 ...state,
                 diffFiles: action.files,
                 diffMergeBase: action.mergeBase,
-                diffFileIndex: 0,
-                diffFileScrollOffset: 0,
+                diffFileIndex: newIndex,
                 diffLoadingFiles: false,
                 diffError: null,
             };
+        }
+        case "DIFF_REFRESH_FILES":
+            // Silent re-fetch — bumps the tick the loader effect depends on,
+            // without flipping diffLoadingFiles. The current file list stays
+            // rendered until the new one arrives, so there's no spinner blink.
+            return { ...state, diffRefreshTick: state.diffRefreshTick + 1 };
+        case "DIFF_STATUS_UPDATED": {
+            // In-place XY patch — used by stage/unstage where the file SET
+            // doesn't change, only the per-file porcelain status. Avoids the
+            // full reload's network/git latency and the spinner that goes
+            // with it.
+            const byPath = new Map();
+            for (const p of action.porcelain)
+                byPath.set(p.path, p);
+            const next = state.diffFiles.map((f) => {
+                const p = byPath.get(f.path);
+                if (!p) {
+                    // File no longer has any working-tree state — back to
+                    // committed-only. Strip the XY fields.
+                    if (f.indexStatus === undefined && f.workingStatus === undefined)
+                        return f;
+                    const cleared = { ...f };
+                    delete cleared.indexStatus;
+                    delete cleared.workingStatus;
+                    delete cleared.isUntracked;
+                    return cleared;
+                }
+                return {
+                    ...f,
+                    indexStatus: p.index,
+                    workingStatus: p.working,
+                    isUntracked: p.index === "?" && p.working === "?",
+                };
+            });
+            return { ...state, diffFiles: next };
+        }
+        case "DIFF_DISCARD_OPEN":
+            return {
+                ...state,
+                diffPendingDiscard: { path: action.path, isUntracked: action.isUntracked },
+            };
+        case "DIFF_DISCARD_CANCEL":
+            return { ...state, diffPendingDiscard: null };
         case "DIFF_FILES_ERROR":
             return {
                 ...state,
@@ -353,6 +411,7 @@ export function reducer(state, action) {
                 diffLoadingFiles: false,
                 diffLoadingContent: false,
                 diffError: null,
+                diffPendingDiscard: null,
             };
         default:
             return state;

package/dist/lib/git.d.ts

@@ -271,6 +271,45 @@ export declare function getDiffStat(baseBranch: string): string | null;
  * Returns null if there are no changes or on failure.
  */
 export declare function getDiffContent(baseBranch: string): string | null;
+/**
+ * One entry from `git status --porcelain=v1 -z`.
+ * `index` (X) = staged state; `working` (Y) = unstaged state. Each is a single
+ * char per the porcelain format: ' ', 'M', 'A', 'D', 'R', 'C', 'U', '?', '!'.
+ */
+export interface PorcelainEntry {
+    path: string;
+    index: string;
+    working: string;
+    oldPath?: string;
+}
+/**
+ * Read working-tree status as a list of porcelain entries. Uses NUL-delimited
+ * output so paths with spaces, quotes, or newlines parse unambiguously.
+ */
+export declare function getWorktreeStatus(cwd: string): Promise<PorcelainEntry[]>;
+/**
+ * Stage a single file. Works for new (untracked) and modified files.
+ */
+export declare function stageFile(cwd: string, filePath: string): Promise<void>;
+/**
+ * Unstage a single file. Uses `git restore --staged` (porcelain command,
+ * available since git 2.23 — already required elsewhere in santree).
+ */
+export declare function unstageFile(cwd: string, filePath: string): Promise<void>;
+/**
+ * Stage every uncommitted change in the worktree (new files, modifications, deletions).
+ */
+export declare function stageAll(cwd: string): Promise<void>;
+/**
+ * Unstage everything in the index (mixed reset on HEAD; working tree untouched).
+ */
+export declare function unstageAll(cwd: string): Promise<void>;
+/**
+ * Discard uncommitted changes for a single file.
+ * - Tracked: `git checkout HEAD -- <path>` restores both index and working tree.
+ * - Untracked: deletes the file from disk via fs.unlink.
+ */
+export declare function discardFile(cwd: string, filePath: string, isUntracked: boolean): Promise<void>;
 /**
  * Read the session state file for a given ticket.
  * Returns null if missing or "exited".

package/dist/lib/git.js

@@ -2,7 +2,7 @@ import { execSync, exec } from "child_process";
 import { promisify } from "util";
 import * as path from "path";
 import * as fs from "fs";
-import { run, runAsync } from "./exec.js";
+import { run, runAsync, spawnAsync } from "./exec.js";
 import { getMultiplexer } from "./multiplexer/index.js";
 const execAsync = promisify(exec);
 /**
@@ -623,6 +623,94 @@ export function getDiffStat(baseBranch) {
 export function getDiffContent(baseBranch) {
     return run(`git diff ${baseBranch}..HEAD`, { maxBuffer: 10 * 1024 * 1024 }) || null;
 }
+/**
+ * Read working-tree status as a list of porcelain entries. Uses NUL-delimited
+ * output so paths with spaces, quotes, or newlines parse unambiguously.
+ */
+export async function getWorktreeStatus(cwd) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "status", "--porcelain=v1", "-z"], {
+        cwd,
+    });
+    if (code !== 0) {
+        throw new Error(`git status failed: ${output.trim()}`);
+    }
+    const entries = [];
+    const records = output.split("\0");
+    for (let i = 0; i < records.length; i++) {
+        const rec = records[i];
+        if (!rec)
+            continue;
+        // Format: "XY <path>" — first 2 chars are status, then a space.
+        if (rec.length < 3)
+            continue;
+        const index = rec.charAt(0);
+        const working = rec.charAt(1);
+        const main = rec.slice(3);
+        // Renames/copies are followed by a NUL-terminated oldPath in the next record.
+        if (index === "R" || index === "C" || working === "R" || working === "C") {
+            const oldPath = records[i + 1] ?? "";
+            i += 1;
+            entries.push({ index, working, path: main, oldPath });
+        }
+        else {
+            entries.push({ index, working, path: main });
+        }
+    }
+    return entries;
+}
+/**
+ * Stage a single file. Works for new (untracked) and modified files.
+ */
+export async function stageFile(cwd, filePath) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "add", "--", filePath], { cwd });
+    if (code !== 0) {
+        throw new Error(`git add failed: ${output.trim()}`);
+    }
+}
+/**
+ * Unstage a single file. Uses `git restore --staged` (porcelain command,
+ * available since git 2.23 — already required elsewhere in santree).
+ */
+export async function unstageFile(cwd, filePath) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "restore", "--staged", "--", filePath], { cwd });
+    if (code !== 0) {
+        throw new Error(`git restore --staged failed: ${output.trim()}`);
+    }
+}
+/**
+ * Stage every uncommitted change in the worktree (new files, modifications, deletions).
+ */
+export async function stageAll(cwd) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "add", "-A"], { cwd });
+    if (code !== 0) {
+        throw new Error(`git add -A failed: ${output.trim()}`);
+    }
+}
+/**
+ * Unstage everything in the index (mixed reset on HEAD; working tree untouched).
+ */
+export async function unstageAll(cwd) {
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "reset"], { cwd });
+    if (code !== 0) {
+        throw new Error(`git reset failed: ${output.trim()}`);
+    }
+}
+/**
+ * Discard uncommitted changes for a single file.
+ * - Tracked: `git checkout HEAD -- <path>` restores both index and working tree.
+ * - Untracked: deletes the file from disk via fs.unlink.
+ */
+export async function discardFile(cwd, filePath, isUntracked) {
+    if (isUntracked) {
+        const absolute = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+        await fs.promises.unlink(absolute);
+        return;
+    }
+    const { code, output } = await spawnAsync("git", ["-C", cwd, "checkout", "HEAD", "--", filePath], { cwd });
+    if (code !== 0) {
+        throw new Error(`git checkout HEAD failed: ${output.trim()}`);
+    }
+}
 /**
  * Get the path to the .santree/session-states directory.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "santree",
-	"version": "0.5.0",
+	"version": "0.5.2",
 	"description": "Git worktree manager",
 	"license": "MIT",
 	"author": "Santiago Toscanini",