santree 0.2.15 → 0.4.0

package/dist/commands/helpers/text-editor.js

@@ -0,0 +1,118 @@
+import { useEffect, useRef } from "react";
+import { useApp } from "ink";
+import { option } from "pastel";
+import { z } from "zod/v4";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const description = "Open $EDITOR on a temp file, then print the path on stdout (compose with --context-file).";
+export const options = z.object({
+    initial: z
+        .string()
+        .optional()
+        .describe(option({ description: "Pre-fill the editor buffer with this text" })),
+    from: z
+        .string()
+        .optional()
+        .describe(option({ description: "Pre-fill the editor buffer with the contents of this file" })),
+    ext: z
+        .string()
+        .default("md")
+        .describe(option({ description: "Temp file extension (default: md)" })),
+    editor: z
+        .string()
+        .optional()
+        .describe(option({ description: "Override the editor command (default: $VISUAL || $EDITOR || vim)" })),
+});
+function resolveEditor(override) {
+    const raw = override ?? process.env["VISUAL"] ?? process.env["EDITOR"] ?? "vim";
+    const parts = raw.split(/\s+/).filter(Boolean);
+    const cmd = parts[0] ?? "vim";
+    return { cmd, args: parts.slice(1) };
+}
+// Render null and write all UI feedback to stderr so stdout stays clean for
+// shell capture: `file=$(st helpers text-editor) && st worktree work --context-file "$file"`.
+export default function TextEditor({ options: opts }) {
+    const { exit } = useApp();
+    const hasRun = useRef(false);
+    useEffect(() => {
+        if (hasRun.current)
+            return;
+        hasRun.current = true;
+        const ext = opts.ext.replace(/^\./, "");
+        const filePath = path.join(os.tmpdir(), `santree-edit-${Date.now()}.${ext}`);
+        const seed = (() => {
+            if (opts.from) {
+                try {
+                    return fs.readFileSync(opts.from, "utf-8");
+                }
+                catch {
+                    return opts.initial ?? "";
+                }
+            }
+            return opts.initial ?? "";
+        })();
+        try {
+            fs.writeFileSync(filePath, seed);
+        }
+        catch (err) {
+            process.stderr.write(`Failed to create temp file: ${err.message}\n`);
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        // Ink put stdin in raw mode on mount; release it for the editor.
+        const wasRaw = process.stdin.isTTY ? process.stdin.isRaw : false;
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { }
+        }
+        const { cmd, args } = resolveEditor(opts.editor);
+        const result = spawnSync(cmd, [...args, filePath], { stdio: "inherit" });
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+            try {
+                process.stdin.setRawMode(wasRaw);
+            }
+            catch { }
+        }
+        if (result.error || result.status !== 0) {
+            process.stderr.write(result.error
+                ? `Failed to launch editor '${cmd}': ${result.error.message}\n`
+                : `Editor '${cmd}' exited with status ${result.status}\n`);
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { }
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        let content = "";
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch (err) {
+            process.stderr.write(`Failed to read temp file: ${err.message}\n`);
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        // Empty buffer => treat as cancel (matches `git commit` behavior)
+        if (content.trim().length === 0) {
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { }
+            process.stderr.write("Cancelled (empty buffer)\n");
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        process.stdout.write(`${filePath}\n`);
+        exit();
+    }, [opts, exit]);
+    return null;
+}

package/dist/commands/worktree/create.d.ts

@@ -5,6 +5,7 @@ export declare const options: z.ZodObject<{
     work: z.ZodOptional<z.ZodBoolean>;
     plan: z.ZodOptional<z.ZodBoolean>;
     "no-pull": z.ZodOptional<z.ZodBoolean>;
+    window: z.ZodOptional<z.ZodBoolean>;
     tmux: z.ZodOptional<z.ZodBoolean>;
     name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/commands/worktree/create.js

@@ -3,36 +3,21 @@ import { useEffect, useState } from "react";
 import { Text, Box } from "ink";
 import Spinner from "ink-spinner";
 import { z } from "zod";
-import { execSync } from "child_process";
 import * as fs from "fs";
 import { createWorktree, findMainRepoRoot, getDefaultBranch, pullLatest, hasInitScript, getInitScriptPath, extractTicketId, } from "../../lib/git.js";
 import { spawnAsync } from "../../lib/exec.js";
+import { getMultiplexer } from "../../lib/multiplexer/index.js";
 export const description = "Create a new worktree from a branch";
 export const options = z.object({
     base: z.string().optional().describe("Base branch to create from"),
     work: z.boolean().optional().describe("Launch Claude after creating"),
     plan: z.boolean().optional().describe("With --work, only plan"),
     "no-pull": z.boolean().optional().describe("Skip pulling latest changes"),
-    tmux: z.boolean().optional().describe("Create a new tmux window"),
-    name: z.string().optional().describe("Custom tmux window name"),
+    window: z.boolean().optional().describe("Create a new multiplexer window/workspace (tmux/cmux)"),
+    tmux: z.boolean().optional().describe("Alias for --window (deprecated)"),
+    name: z.string().optional().describe("Custom window/workspace name"),
 });
 export const args = z.tuple([z.string().optional().describe("Branch name")]);
-function isInTmux() {
-    return !!process.env.TMUX;
-}
-function createTmuxWindow(name, path, runCommand) {
-    try {
-        execSync(`tmux new-window -n "${name}" -c "${path}"`, { stdio: "ignore" });
-        // If a command is provided, send it to the new window
-        if (runCommand) {
-            execSync(`tmux send-keys -t "${name}" "${runCommand}" Enter`, { stdio: "ignore" });
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function getWindowName(branchName, customName) {
     if (customName)
         return customName;
@@ -50,35 +35,38 @@ export default function Create({ options, args }) {
     const [message, setMessage] = useState("");
     const [worktreePath, setWorktreePath] = useState("");
     const [baseBranch, setBaseBranch] = useState(null);
-    const [tmuxWindowName, setTmuxWindowName] = useState(null);
-    function finalize(path, branch) {
-        // Handle tmux window creation
-        if (options.tmux) {
-            if (!isInTmux()) {
-                setMessage("Worktree created, but not in tmux session");
+    const [muxWindowName, setMuxWindowName] = useState(null);
+    const [muxKind, setMuxKind] = useState(null);
+    async function finalize(path, branch) {
+        const wantsWindow = options.window || options.tmux;
+        if (wantsWindow) {
+            const mux = getMultiplexer();
+            if (!mux.isActive()) {
+                setMessage("Worktree created, but no active multiplexer");
                 setStatus("done");
                 console.log(`SANTREE_CD:${path}`);
                 return;
             }
-            setStatus("tmux");
-            setMessage("Creating tmux window...");
+            setStatus("spawning-window");
+            setMessage(`Creating ${mux.kind} window...`);
             const windowName = getWindowName(branch, options.name);
-            setTmuxWindowName(windowName);
-            // Build command to run in new window (if --work is set)
+            setMuxWindowName(windowName);
+            setMuxKind(mux.kind);
             let runCommand;
             if (options.work) {
                 runCommand = options.plan ? "st worktree work --plan" : "st worktree work";
             }
-            if (!createTmuxWindow(windowName, path, runCommand)) {
-                setMessage("Worktree created, but failed to create tmux window");
+            const result = await mux.createWindow({ name: windowName, cwd: path, command: runCommand });
+            if (!result.ok) {
+                setMessage(`Worktree created, but failed to create ${mux.kind} window${result.message ? `: ${result.message}` : ""}`);
                 setStatus("done");
                 console.log(`SANTREE_CD:${path}`);
                 return;
             }
             setStatus("done");
             const workInfo = options.work ? (options.plan ? " + Claude (plan)" : " + Claude") : "";
-            setMessage(`Worktree and tmux window created!${workInfo}`);
-            // Don't output SANTREE_CD when tmux window is created - user is already in new window
+            setMessage(`Worktree and ${mux.kind} window created!${workInfo}`);
+            // Don't output SANTREE_CD when a window is created — user is already in the new window
             return;
         }
         setStatus("done");
@@ -133,7 +121,7 @@ export default function Create({ options, args }) {
                     }
                     catch {
                         setMessage("Warning: Init script exists but is not executable");
-                        finalize(result.path, branch);
+                        await finalize(result.path, branch);
                         return;
                     }
                     const initResult = await spawnAsync(initScript, [], {
@@ -147,10 +135,10 @@ export default function Create({ options, args }) {
                     if (initResult.code !== 0) {
                         setMessage(`Warning: Init script exited with code ${initResult.code}`);
                     }
-                    finalize(result.path, branch);
+                    await finalize(result.path, branch);
                 }
                 else {
-                    finalize(result.path, branch);
+                    await finalize(result.path, branch);
                 }
             }
             else {
@@ -165,9 +153,13 @@ export default function Create({ options, args }) {
         options.work,
         options.plan,
         options["no-pull"],
+        options.window,
         options.tmux,
         options.name,
     ]);
-    const isLoading = status === "pulling" || status === "creating" || status === "init-script" || status === "tmux";
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83C\uDF31 Create Worktree" }) }), branchName && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : status === "done" ? "green" : "blue", paddingX: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branchName })] }), baseBranch && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "base:" }), _jsx(Text, { color: "blue", children: baseBranch })] })), options["no-pull"] && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "skip pull:" }), _jsx(Text, { color: "yellow", children: "yes" })] })), options.work && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "after:" }), _jsx(Text, { backgroundColor: "magenta", color: "white", children: options.plan ? " plan " : " work " })] })), options.tmux && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "tmux:" }), _jsx(Text, { backgroundColor: "green", color: "white", children: ` ${options.name || "auto"} ` })] }))] })), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", message] })] })), status === "done" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] }), _jsxs(Text, { dimColor: true, children: [" ", worktreePath] }), tmuxWindowName && _jsxs(Text, { dimColor: true, children: [" tmux window: ", tmuxWindowName] })] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
+    const isLoading = status === "pulling" ||
+        status === "creating" ||
+        status === "init-script" ||
+        status === "spawning-window";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83C\uDF31 Create Worktree" }) }), branchName && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : status === "done" ? "green" : "blue", paddingX: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branchName })] }), baseBranch && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "base:" }), _jsx(Text, { color: "blue", children: baseBranch })] })), options["no-pull"] && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "skip pull:" }), _jsx(Text, { color: "yellow", children: "yes" })] })), options.work && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "after:" }), _jsx(Text, { backgroundColor: "magenta", color: "white", children: options.plan ? " plan " : " work " })] })), (options.window || options.tmux) && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "window:" }), _jsx(Text, { backgroundColor: "green", color: "white", children: ` ${options.name || "auto"} ` })] }))] })), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", message] })] })), status === "done" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] }), _jsxs(Text, { dimColor: true, children: [" ", worktreePath] }), muxWindowName && (_jsxs(Text, { dimColor: true, children: [" ", muxKind ?? "tmux", " window: ", muxWindowName] }))] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
 }

package/dist/lib/ai.js

@@ -143,12 +143,7 @@ export function launchAgent(prompt, opts) {
         throw new Error("Claude CLI not found. Install: npm install -g @anthropic-ai/claude-code");
     }
     const args = [];
-    if (process.env.SANTREE_SKIP_PERMISSIONS) {
-        args.push("--dangerously-skip-permissions");
-    }
-    if (opts?.planMode) {
-        args.push("--permission-mode", "plan");
-    }
+    args.push("--permission-mode", opts?.planMode ? "plan" : "auto");
     if (opts?.sessionId) {
         if (opts.resume) {
             args.push("--resume", opts.sessionId);
@@ -170,9 +165,17 @@ export function runAgent(prompt, opts) {
     if (!bin) {
         throw new Error("Claude CLI not found. Install: npm install -g @anthropic-ai/claude-code");
     }
-    const skipPerms = process.env.SANTREE_SKIP_PERMISSIONS ? ["--dangerously-skip-permissions"] : [];
     const toolArgs = opts?.allowedTools?.length ? ["--allowedTools", ...opts.allowedTools] : [];
-    const result = spawnSync(bin, [...skipPerms, ...toolArgs, "-p", "--output-format", "text", "--", promptArg(prompt)], {
+    const result = spawnSync(bin, [
+        "--permission-mode",
+        "auto",
+        ...toolArgs,
+        "-p",
+        "--output-format",
+        "text",
+        "--",
+        promptArg(prompt),
+    ], {
         encoding: "utf-8",
         maxBuffer: 10 * 1024 * 1024,
     });

package/dist/lib/dashboard/MultilineTextArea.js

@@ -1,48 +1,332 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
 import { Box, Text, useInput } from "ink";
+import { spawnSync } from "node:child_process";
+import { openSync, readSync, closeSync, statSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { editExternally } from "./external-editor.js";
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+// macOS clipboard → PNG. Returns the written file path on success, or null if
+// the clipboard holds no image, the platform isn't macOS, or the write produced
+// a file that isn't actually a PNG. The coercion to «class PNGf» errors when
+// the clipboard holds only text — verified against real clipboards.
+function pasteClipboardImageToTmp() {
+    if (process.platform !== "darwin")
+        return null;
+    const filePath = join(tmpdir(), `santree-paste-${Date.now()}.png`);
+    const script = `try
+set pngData to the clipboard as «class PNGf»
+set theFile to POSIX file "${filePath}"
+set fileRef to open for access theFile with write permission
+set eof fileRef to 0
+write pngData to fileRef
+close access fileRef
+return "ok"
+on error
+return "no-image"
+end try`;
+    try {
+        const result = spawnSync("osascript", ["-e", script], { encoding: "utf-8", timeout: 3000 });
+        if (result.status !== 0 || result.stdout.trim() !== "ok")
+            return null;
+        if (statSync(filePath).size === 0) {
+            try {
+                unlinkSync(filePath);
+            }
+            catch { }
+            return null;
+        }
+        const fd = openSync(filePath, "r");
+        const header = Buffer.alloc(8);
+        readSync(fd, header, 0, 8, 0);
+        closeSync(fd);
+        if (!header.equals(PNG_MAGIC)) {
+            try {
+                unlinkSync(filePath);
+            }
+            catch { }
+            return null;
+        }
+        return filePath;
+    }
+    catch {
+        // osascript unavailable or fs error — silent no-op
+    }
+    return null;
+}
+// ── Word boundary helpers (whitespace-delimited) ────────────────────────────
+function prevWordStart(text, pos) {
+    let p = pos;
+    while (p > 0 && /\s/.test(text[p - 1]))
+        p--;
+    while (p > 0 && /\S/.test(text[p - 1]))
+        p--;
+    return p;
+}
+function nextWordEnd(text, pos) {
+    let p = pos;
+    while (p < text.length && /\s/.test(text[p]))
+        p++;
+    while (p < text.length && /\S/.test(text[p]))
+        p++;
+    return p;
+}
+function lineStart(text, pos) {
+    const before = text.lastIndexOf("\n", pos - 1);
+    return before === -1 ? 0 : before + 1;
+}
+function lineEnd(text, pos) {
+    const after = text.indexOf("\n", pos);
+    return after === -1 ? text.length : after;
+}
+function buildVisualRows(value, innerWidth) {
+    const lines = value.length === 0 ? [""] : value.split("\n");
+    const rows = [];
+    const w = Math.max(1, innerWidth);
+    for (let li = 0; li < lines.length; li++) {
+        const line = lines[li];
+        if (line.length === 0) {
+            rows.push({ logicalLine: li, startCol: 0, text: "" });
+            continue;
+        }
+        for (let i = 0; i < line.length; i += w) {
+            rows.push({ logicalLine: li, startCol: i, text: line.slice(i, i + w) });
+        }
+    }
+    return rows;
+}
+function cursorVisualPos(rows, value, cursor, innerWidth) {
+    const lines = value.length === 0 ? [""] : value.split("\n");
+    let logicalLine = 0;
+    let lineStartOffset = 0;
+    for (let li = 0; li < lines.length; li++) {
+        const len = lines[li].length;
+        if (cursor <= lineStartOffset + len) {
+            logicalLine = li;
+            break;
+        }
+        lineStartOffset += len + 1;
+    }
+    const colInLine = cursor - lineStartOffset;
+    const candidates = rows
+        .map((r, i) => ({ r, i }))
+        .filter(({ r }) => r.logicalLine === logicalLine);
+    for (let ci = 0; ci < candidates.length; ci++) {
+        const { r, i } = candidates[ci];
+        if (colInLine >= r.startCol && colInLine < r.startCol + r.text.length) {
+            return { vRow: i, vCol: colInLine - r.startCol };
+        }
+        if (colInLine === r.startCol + r.text.length) {
+            // Cursor sits at the end of this visual row. If the row is exactly width-full
+            // AND there's another visual row in the same logical line, the next typed char
+            // belongs at the start of that next row — defer.
+            if (r.text.length === innerWidth && ci + 1 < candidates.length) {
+                continue;
+            }
+            // Last row of this logical line and exactly width-full → return a virtual row
+            // past the end so the cursor is rendered at col 0 of a fresh row instead of
+            // overflowing the right edge.
+            if (r.text.length === innerWidth) {
+                return { vRow: i + 1, vCol: 0 };
+            }
+            return { vRow: i, vCol: colInLine - r.startCol };
+        }
+    }
+    const last = candidates[candidates.length - 1];
+    if (last)
+        return { vRow: last.i, vCol: last.r.text.length };
+    return { vRow: 0, vCol: 0 };
+}
 export function MultilineTextArea({ value, onChange, onSubmit, onCancel, placeholder, width, height = 6, focus = true, }) {
+    const [cursor, setCursor] = useState(value.length);
+    useEffect(() => {
+        if (cursor > value.length)
+            setCursor(value.length);
+    }, [value, cursor]);
+    const insertAt = (pos, text) => {
+        onChange(value.slice(0, pos) + text + value.slice(pos));
+        setCursor(pos + text.length);
+    };
+    const deleteRange = (from, to) => {
+        if (from === to)
+            return;
+        const lo = Math.min(from, to);
+        const hi = Math.max(from, to);
+        onChange(value.slice(0, lo) + value.slice(hi));
+        setCursor(lo);
+    };
     useInput((input, key) => {
-        // Ctrl+D submits
+        // Ctrl+D: submit
         if (key.ctrl && input === "d") {
             onSubmit();
             return;
         }
-        // ESC cancels. Parent disables SGR mouse tracking while this overlay is
-        // mounted so clicks can no longer masquerade as ESC.
-        if (key.escape) {
+        // Ctrl+C: cancel (preferred over Esc — vim users rely on Esc muscle memory)
+        if (key.ctrl && input === "c") {
             onCancel();
             return;
         }
+        // Ctrl+O: escalate to $SANTREE_EDITOR / $VISUAL / $EDITOR. On save+close
+        // the buffer is replaced and the form is auto-submitted (matches git commit).
+        if (key.ctrl && input === "o") {
+            const result = editExternally(value, "md");
+            if (!result.ok)
+                return;
+            if (result.cancelled) {
+                onCancel();
+                return;
+            }
+            onChange(result.content);
+            setCursor(result.content.length);
+            onSubmit();
+            return;
+        }
+        // Ctrl+V: paste clipboard image as a temp file reference.
+        if (key.ctrl && input === "v") {
+            const imagePath = pasteClipboardImageToTmp();
+            if (imagePath)
+                insertAt(cursor, `![pasted image](${imagePath})`);
+            return;
+        }
+        // Esc: swallow without cancelling (vim users hit it constantly).
+        if (key.escape)
+            return;
+        // ── Readline-ish line editing ───────────────────────────────────
+        // Ctrl+A: start of line (also what iTerm2 / Ghostty send for Cmd+Left)
+        if (key.ctrl && input === "a") {
+            setCursor(lineStart(value, cursor));
+            return;
+        }
+        // Ctrl+E: end of line (also what iTerm2 / Ghostty send for Cmd+Right)
+        if (key.ctrl && input === "e") {
+            setCursor(lineEnd(value, cursor));
+            return;
+        }
+        // Ctrl+W: delete word backwards
+        if (key.ctrl && input === "w") {
+            deleteRange(prevWordStart(value, cursor), cursor);
+            return;
+        }
+        // Ctrl+U: delete to line start
+        if (key.ctrl && input === "u") {
+            deleteRange(lineStart(value, cursor), cursor);
+            return;
+        }
+        // Ctrl+K: delete to line end
+        if (key.ctrl && input === "k") {
+            deleteRange(cursor, lineEnd(value, cursor));
+            return;
+        }
+        // Option+Backspace (meta+backspace): delete word backwards
+        if (key.meta && (key.backspace || key.delete)) {
+            deleteRange(prevWordStart(value, cursor), cursor);
+            return;
+        }
+        // Option+Left / Option+Right: word jump.
+        // Mac terminals (Ghostty/iTerm2/Terminal.app) typically send the emacs-style
+        // `\x1bb` / `\x1bf` rather than the meta+arrow CSI sequence, so Ink reports
+        // these as `key.meta && input === "b" | "f"`. Cover both forms.
+        if (key.meta && (key.leftArrow || input === "b")) {
+            setCursor(prevWordStart(value, cursor));
+            return;
+        }
+        if (key.meta && (key.rightArrow || input === "f")) {
+            setCursor(nextWordEnd(value, cursor));
+            return;
+        }
+        // Option+Up / Option+Down: doc start/end (used by some Mac terminals)
+        if (key.meta && key.upArrow) {
+            setCursor(0);
+            return;
+        }
+        if (key.meta && key.downArrow) {
+            setCursor(value.length);
+            return;
+        }
         if (key.backspace || key.delete) {
-            onChange(value.slice(0, -1));
+            if (cursor === 0)
+                return;
+            onChange(value.slice(0, cursor - 1) + value.slice(cursor));
+            setCursor(cursor - 1);
+            return;
+        }
+        // Plain arrows: visual-row navigation when possible; left/right by 1 char.
+        if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+            if (key.leftArrow) {
+                setCursor(Math.max(0, cursor - 1));
+                return;
+            }
+            if (key.rightArrow) {
+                setCursor(Math.min(value.length, cursor + 1));
+                return;
+            }
+            const innerW = Math.max(1, (width ?? 80) - 4);
+            const rows = buildVisualRows(value, innerW);
+            const { vRow, vCol } = cursorVisualPos(rows, value, cursor, innerW);
+            const targetVRow = key.upArrow ? vRow - 1 : vRow + 1;
+            if (targetVRow < 0) {
+                setCursor(0);
+                return;
+            }
+            if (targetVRow >= rows.length) {
+                setCursor(value.length);
+                return;
+            }
+            const target = rows[targetVRow];
+            const targetColInLine = target.startCol + Math.min(vCol, target.text.length);
+            let offset = 0;
+            const lines = value.length === 0 ? [""] : value.split("\n");
+            for (let li = 0; li < target.logicalLine; li++)
+                offset += lines[li].length + 1;
+            setCursor(offset + targetColInLine);
             return;
         }
-        // Swallow navigation keys — this is an append-only text area.
-        if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.tab)
+        // Tab: insert a literal tab character.
+        if (key.tab) {
+            insertAt(cursor, "\t");
             return;
-        // Enter inserts a newline. MUST run before the meta/ctrl swallow below so
-        // Option+Enter and Ctrl+Enter also insert newlines. When Ink delivers a
-        // paste as one chunk, `input` may carry embedded content alongside the
-        // \r — normalize and append the whole thing instead of dropping it.
+        }
+        // Enter: insert newline (also handles paste containing \r).
         if (key.return) {
             const chunk = input ? input.replace(/\r\n?/g, "\n") : "\n";
-            onChange(value + chunk);
+            insertAt(cursor, chunk);
             return;
         }
-        // Swallow remaining modifier combos.
         if (key.ctrl || key.meta)
             return;
         if (!input)
             return;
-        // Pasted content may embed \r or \r\n — normalize to \n.
-        const normalized = input.replace(/\r\n?/g, "\n");
-        onChange(value + normalized);
+        insertAt(cursor, input.replace(/\r\n?/g, "\n"));
     }, { isActive: focus });
-    const lines = value.length === 0 ? [""] : value.split("\n");
-    const visibleLines = lines.slice(Math.max(0, lines.length - height));
+    const innerWidth = Math.max(1, (width ?? 80) - 4);
+    const rows = buildVisualRows(value, innerWidth);
+    const { vRow: cursorVRow, vCol: cursorVCol } = cursorVisualPos(rows, value, cursor, innerWidth);
+    const totalRows = Math.max(rows.length, cursorVRow + 1);
+    let scrollStart = 0;
+    if (cursorVRow >= height)
+        scrollStart = cursorVRow - height + 1;
+    const visibleRows = rows.slice(scrollStart, scrollStart + height);
     const isEmpty = value.length === 0;
-    return (_jsx(Box, { flexDirection: "column", width: width, borderStyle: "round", borderColor: "cyan", paddingX: 1, minHeight: height + 2, children: isEmpty && placeholder ? (_jsxs(Box, { minHeight: 1, children: [_jsx(Text, { color: "cyan", children: "\u2588" }), _jsx(Text, { dimColor: true, children: placeholder })] })) : (visibleLines.map((line, i) => {
-            const isLast = i === visibleLines.length - 1;
-            return (_jsxs(Box, { minHeight: 1, children: [_jsx(Text, { children: line }), isLast && focus ? _jsx(Text, { color: "cyan", children: "\u2588" }) : null] }, i));
-        })) }));
+    const hiddenAbove = scrollStart;
+    const hiddenBelow = Math.max(0, totalRows - scrollStart - height);
+    return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsx(Box, { flexDirection: "column", width: width, borderStyle: "round", borderColor: "cyan", paddingX: 1, minHeight: height + 2, children: isEmpty && placeholder ? (_jsxs(Box, { minHeight: 1, children: [_jsx(Text, { inverse: true, children: " " }), _jsx(Text, { dimColor: true, children: placeholder })] })) : (Array.from({ length: height }).map((_, i) => {
+                    const row = visibleRows[i];
+                    const absoluteVRow = scrollStart + i;
+                    const isCursorRow = focus && absoluteVRow === cursorVRow;
+                    if (!row) {
+                        // Phantom row past the end (cursor sits on a fresh line at wrap boundary)
+                        if (isCursorRow) {
+                            return (_jsx(Box, { minHeight: 1, children: _jsx(Text, { inverse: true, children: " " }) }, `phantom-${i}`));
+                        }
+                        return _jsx(Box, { minHeight: 1 }, `pad-${i}`);
+                    }
+                    if (!isCursorRow) {
+                        return (_jsx(Box, { minHeight: 1, children: _jsx(Text, { children: row.text }) }, i));
+                    }
+                    const before = row.text.slice(0, cursorVCol);
+                    const atCursor = cursorVCol < row.text.length ? row.text[cursorVCol] : " ";
+                    const after = cursorVCol < row.text.length ? row.text.slice(cursorVCol + 1) : "";
+                    return (_jsxs(Box, { minHeight: 1, children: [_jsx(Text, { children: before }), _jsx(Text, { inverse: true, children: atCursor }), _jsx(Text, { children: after })] }, i));
+                })) }), (hiddenAbove > 0 || hiddenBelow > 0) && (_jsxs(Box, { justifyContent: "space-between", paddingX: 1, children: [_jsx(Text, { dimColor: true, children: hiddenAbove > 0 ? `↑ ${hiddenAbove} more above` : "" }), _jsx(Text, { dimColor: true, children: hiddenBelow > 0 ? `${hiddenBelow} more below ↓` : "" })] }))] }));
 }

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

@@ -22,7 +22,7 @@ interface PrCreateOverlayProps {
     url: string | null;
     body: string | null;
     title: string | null;
-    scrollOffset: number;
+    dispatch: React.Dispatch<DashboardAction>;
 }
-export declare function PrCreateOverlay({ width, height, branch, ticketId, phase, error, url, body, title, scrollOffset, }: PrCreateOverlayProps): import("react/jsx-runtime").JSX.Element;
+export declare function PrCreateOverlay({ width, height, branch, ticketId, phase, error, url, body, title, dispatch, }: PrCreateOverlayProps): import("react/jsx-runtime").JSX.Element;
 export {};