santree 0.5.5 → 0.6.0

package/dist/commands/worktree/commit.js

@@ -3,12 +3,19 @@ import { useEffect, useState } from "react";
 import { Text, Box, useInput, useApp } from "ink";
 import TextInput from "ink-text-input";
 import Spinner from "ink-spinner";
+import { z } from "zod";
 import { exec } from "child_process";
 import { promisify } from "util";
-import { findRepoRoot, getCurrentBranch, extractTicketId, getGitStatus, getStagedDiffStat, hasStagedChanges, hasUnstagedChanges, } from "../../lib/git.js";
+import { findRepoRoot, findMainRepoRoot, getCurrentBranch, extractTicketId, getGitStatus, getStagedDiffStat, getStagedDiffContent, hasStagedChanges, hasUnstagedChanges, } from "../../lib/git.js";
+import { fillCommitMessage } from "../../lib/ai.js";
+import { getIssueTracker } from "../../lib/trackers/index.js";
+import { renderTicket } from "../../lib/prompts.js";
 export const description = "Stage and commit changes";
+export const options = z.object({
+    fill: z.boolean().optional().describe("Use AI to draft a short commit message"),
+});
 const execAsync = promisify(exec);
-export default function Commit() {
+export default function Commit({ options }) {
     const { exit } = useApp();
     const [status, setStatus] = useState("loading");
     const [message, setMessage] = useState("");
@@ -25,10 +32,9 @@ export default function Commit() {
                 stageAndContinue();
             }
             else if (input === "n" || input === "N" || key.escape) {
-                if (hasStagedChanges()) {
-                    setStatus("awaiting-message");
-                    const prefix = ticketId ? `[${ticketId}] ` : "";
-                    setCommitInput(prefix);
+                if (hasStagedChanges() && repoRoot && branch) {
+                    // Respect --fill even when the user declines to stage more.
+                    void openMessagePhase({ repoRoot, branch, ticketId });
                 }
                 else {
                     setStatus("no-changes");
@@ -39,19 +45,59 @@ export default function Commit() {
         }
     });
     async function stageAndContinue() {
+        if (!repoRoot || !branch)
+            return;
         try {
-            await execAsync("git add -A", { cwd: repoRoot ?? undefined });
+            await execAsync("git add -A", { cwd: repoRoot });
             setGitStatus(getGitStatus());
             setDiffStat(getStagedDiffStat());
-            setStatus("awaiting-message");
-            const prefix = ticketId ? `[${ticketId}] ` : "";
-            setCommitInput(prefix);
+            await openMessagePhase({ repoRoot, branch, ticketId });
         }
         catch (e) {
             setStatus("error");
             setMessage(`Failed to stage changes: ${e}`);
         }
     }
+    // Routes to either the AI-fill phase or straight to the bare input.
+    // Takes context as args so callers in init() (where state isn't yet
+    // propagated from the just-fired setStates) can hand in fresh values.
+    async function openMessagePhase(ctx) {
+        const prefix = ctx.ticketId ? `[${ctx.ticketId}] ` : "";
+        if (options.fill) {
+            setStatus("filling");
+            setMessage("Drafting commit message with Claude...");
+            const drafted = await draftWithAI(ctx);
+            // Whether Claude succeeds or not, fall through to the input —
+            // the user can edit or type from scratch.
+            setCommitInput(drafted ?? prefix);
+            setStatus("awaiting-message");
+            return;
+        }
+        setCommitInput(prefix);
+        setStatus("awaiting-message");
+    }
+    async function draftWithAI(ctx) {
+        const diffContent = getStagedDiffContent(ctx.repoRoot);
+        if (!diffContent.trim())
+            return null;
+        // Pull ticket context if we can — the prompt uses it to ground the
+        // summary in the requested change rather than the literal diff.
+        let ticketContent;
+        const mainRoot = findMainRepoRoot();
+        if (ctx.ticketId && mainRoot) {
+            const tracker = getIssueTracker(mainRoot);
+            const result = await tracker.getIssue(ctx.ticketId, mainRoot);
+            if (result.ok) {
+                ticketContent = renderTicket(result.value, tracker.displayName);
+            }
+        }
+        return fillCommitMessage({
+            branch: ctx.branch,
+            ticketId: ctx.ticketId,
+            ticketContent,
+            diffContent,
+        });
+    }
     async function handleCommitSubmit(value) {
         const trimmed = value.trim();
         if (!trimmed) {
@@ -128,9 +174,7 @@ export default function Commit() {
             }
             else if (staged) {
                 setDiffStat(getStagedDiffStat());
-                setStatus("awaiting-message");
-                const prefix = ticket ? `[${ticket}] ` : "";
-                setCommitInput(prefix);
+                await openMessagePhase({ repoRoot: root, branch: currentBranch, ticketId: ticket });
             }
             else {
                 setStatus("no-changes");
@@ -140,7 +184,7 @@ export default function Commit() {
         }
         init();
     }, []);
-    const isLoading = status === "loading" || status === "committing" || status === "pushing";
+    const isLoading = status === "loading" || status === "filling" || status === "committing" || status === "pushing";
     return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83D\uDCBE Commit" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : status === "done" ? "green" : "blue", paddingX: 1, width: "100%", children: [branch && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branch })] })), ticketId && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "ticket:" }), _jsx(Text, { color: "blue", bold: true, children: ticketId })] }))] }), gitStatus && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "Changes:" }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, width: "100%", children: [gitStatus
                                 .split("\n")
                                 .slice(0, 10)

package/dist/lib/ai.d.ts

@@ -75,7 +75,33 @@ export interface RunAgentResult {
 export declare function runAgent(prompt: string, opts?: {
     allowedTools?: string[];
 }): RunAgentResult;
+/**
+ * Async version of runAgent. Use this from Ink renderers — spawnSync
+ * blocks Node's event loop, freezing the UI (no spinner animation, no
+ * keystroke processing) for the entire duration of Claude's generation.
+ * spawn() lets the loop run during the call.
+ */
+export declare function runAgentAsync(prompt: string, opts?: {
+    allowedTools?: string[];
+}): Promise<RunAgentResult>;
 /**
  * Clean up cached image downloads for an issue identifier on the active tracker.
  */
 export declare function cleanupImages(ticketId: string): void;
+export interface FillCommitOpts {
+    branch: string;
+    ticketId: string | null;
+    ticketContent?: string;
+    diffContent: string;
+}
+/**
+ * Generate a short imperative commit message from a staged diff.
+ * Async so callers (the Ink dashboard, the CLI commit flow) keep the
+ * event loop turning during Claude's ~5–30s generation — using the sync
+ * runAgent here freezes the renderer.
+ *
+ * Returns the trimmed message string (no quotes, no preamble) on success,
+ * or null if Claude failed. Caller is responsible for ensuring the diff
+ * is non-empty.
+ */
+export declare function fillCommitMessage(opts: FillCommitOpts): Promise<string | null>;

package/dist/lib/ai.js

@@ -226,6 +226,36 @@ export function runAgent(prompt, opts) {
         output: result.stdout?.trim() ?? "",
     };
 }
+/**
+ * Async version of runAgent. Use this from Ink renderers — spawnSync
+ * blocks Node's event loop, freezing the UI (no spinner animation, no
+ * keystroke processing) for the entire duration of Claude's generation.
+ * spawn() lets the loop run during the call.
+ */
+export function runAgentAsync(prompt, opts) {
+    const bin = resolveAgentBinary();
+    if (!bin) {
+        return Promise.reject(new Error("Claude CLI not found. Install: npm install -g @anthropic-ai/claude-code"));
+    }
+    const toolArgs = opts?.allowedTools?.length ? ["--allowedTools", ...opts.allowedTools] : [];
+    const args = [
+        "--permission-mode",
+        "auto",
+        ...toolArgs,
+        "-p",
+        "--output-format",
+        "text",
+        "--",
+        promptArg(prompt),
+    ];
+    return new Promise((resolve) => {
+        const child = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        child.stdout?.on("data", (chunk) => (stdout += chunk.toString("utf-8")));
+        child.on("error", () => resolve({ success: false, output: "" }));
+        child.on("close", (code) => resolve({ success: code === 0, output: stdout.trim() }));
+    });
+}
 /**
  * Clean up cached image downloads for an issue identifier on the active tracker.
  */
@@ -233,3 +263,26 @@ export function cleanupImages(ticketId) {
     const repoRoot = findMainRepoRoot();
     getIssueTracker(repoRoot).cleanupCache(ticketId);
 }
+/**
+ * Generate a short imperative commit message from a staged diff.
+ * Async so callers (the Ink dashboard, the CLI commit flow) keep the
+ * event loop turning during Claude's ~5–30s generation — using the sync
+ * runAgent here freezes the renderer.
+ *
+ * Returns the trimmed message string (no quotes, no preamble) on success,
+ * or null if Claude failed. Caller is responsible for ensuring the diff
+ * is non-empty.
+ */
+export async function fillCommitMessage(opts) {
+    const prompt = renderPrompt("fill-commit", {
+        branch_name: opts.branch,
+        ticket_id: opts.ticketId ?? "",
+        ticket_content: opts.ticketContent,
+        diff_content: opts.diffContent,
+    });
+    const result = await runAgentAsync(prompt);
+    if (!result.success)
+        return null;
+    // Trim quotes/whitespace; Claude occasionally wraps despite instructions.
+    return result.output.trim().replace(/^["'`]|["'`]$/g, "");
+}

package/dist/lib/claude-todos.d.ts

@@ -0,0 +1,37 @@
+export type ClaudeTodoStatus = "pending" | "in_progress" | "completed";
+export interface ClaudeTodo {
+    id: string;
+    content: string;
+    status: ClaudeTodoStatus;
+}
+/** Read the main-agent todo list for a Claude Code session.
+ *
+ * Claude Code persists `TodoWrite` state to
+ * `~/.claude/todos/<sessionId>-agent-<agentId>.json`. The file with
+ * `agentId === sessionId` is the user-visible list; sub-agent files
+ * (different agentId) are noise and ignored here.
+ *
+ * Returns null when the file is missing, empty, or unparseable. The
+ * dashboard treats a null/empty result as "hide the section" so a
+ * stray malformed file never blocks rendering. */
+export declare function readMainAgentTodos(sessionId: string): ClaudeTodo[] | null;
+/** Locate the cwd from which a Claude Code session is resumable.
+ *
+ * Claude stores transcripts at
+ * `~/.claude/projects/<encodedCwd>/<sessionId>.jsonl`, where `encodedCwd`
+ * replaces every `/` and `.` with `-`. `claude --resume <id>` is cwd-scoped:
+ * a session created at the worktree root is NOT resumable from a
+ * subdirectory like `backend/canary`, even though the file exists somewhere
+ * under `~/.claude/projects/`. The dashboard's tmux send-keys flow has no
+ * control over where the user's shell init / direnv leaves the window's
+ * cwd, so we resolve the original launch cwd here and prepend a `cd` to
+ * the resume command.
+ *
+ * Returns the real path of the cwd where the session is resumable —
+ * constrained to the worktree subtree so we never recommend `cd`-ing
+ * outside it. Returns null when the file isn't found anywhere matching
+ * the worktree (the file was deleted, or the session was created in a
+ * cwd we can't reconstruct). The encoding is lossy (`-` could come from
+ * `/` or `.`), so we verify candidates against real filesystem paths
+ * under `worktreeRoot` rather than guessing. */
+export declare function findClaudeSessionCwd(worktreeRoot: string, sessionId: string): string | null;

package/dist/lib/claude-todos.js

@@ -0,0 +1,98 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+/** Read the main-agent todo list for a Claude Code session.
+ *
+ * Claude Code persists `TodoWrite` state to
+ * `~/.claude/todos/<sessionId>-agent-<agentId>.json`. The file with
+ * `agentId === sessionId` is the user-visible list; sub-agent files
+ * (different agentId) are noise and ignored here.
+ *
+ * Returns null when the file is missing, empty, or unparseable. The
+ * dashboard treats a null/empty result as "hide the section" so a
+ * stray malformed file never blocks rendering. */
+export function readMainAgentTodos(sessionId) {
+    const file = path.join(os.homedir(), ".claude", "todos", `${sessionId}-agent-${sessionId}.json`);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return null;
+        const out = [];
+        for (const item of parsed) {
+            if (!item || typeof item !== "object")
+                continue;
+            const { id, content, status } = item;
+            if (typeof id !== "string" || typeof content !== "string")
+                continue;
+            if (status !== "pending" && status !== "in_progress" && status !== "completed")
+                continue;
+            out.push({ id, content, status });
+        }
+        return out.length > 0 ? out : null;
+    }
+    catch {
+        return null;
+    }
+}
+function encodeCwd(cwd) {
+    return cwd.replace(/[/.]/g, "-");
+}
+/** Locate the cwd from which a Claude Code session is resumable.
+ *
+ * Claude stores transcripts at
+ * `~/.claude/projects/<encodedCwd>/<sessionId>.jsonl`, where `encodedCwd`
+ * replaces every `/` and `.` with `-`. `claude --resume <id>` is cwd-scoped:
+ * a session created at the worktree root is NOT resumable from a
+ * subdirectory like `backend/canary`, even though the file exists somewhere
+ * under `~/.claude/projects/`. The dashboard's tmux send-keys flow has no
+ * control over where the user's shell init / direnv leaves the window's
+ * cwd, so we resolve the original launch cwd here and prepend a `cd` to
+ * the resume command.
+ *
+ * Returns the real path of the cwd where the session is resumable —
+ * constrained to the worktree subtree so we never recommend `cd`-ing
+ * outside it. Returns null when the file isn't found anywhere matching
+ * the worktree (the file was deleted, or the session was created in a
+ * cwd we can't reconstruct). The encoding is lossy (`-` could come from
+ * `/` or `.`), so we verify candidates against real filesystem paths
+ * under `worktreeRoot` rather than guessing. */
+export function findClaudeSessionCwd(worktreeRoot, sessionId) {
+    const projectsRoot = path.join(os.homedir(), ".claude", "projects");
+    const wtEncoded = encodeCwd(worktreeRoot);
+    // Fast path: session was created at the worktree root itself.
+    if (fs.existsSync(path.join(projectsRoot, wtEncoded, `${sessionId}.jsonl`))) {
+        return worktreeRoot;
+    }
+    // Slow path: session was created in a subdir of the worktree (e.g.
+    // project conventions auto-cd into `backend/canary` via direnv).
+    let dirs;
+    try {
+        dirs = fs.readdirSync(projectsRoot);
+    }
+    catch {
+        return null;
+    }
+    const prefix = `${wtEncoded}-`;
+    for (const dir of dirs) {
+        if (!dir.startsWith(prefix))
+            continue;
+        if (!fs.existsSync(path.join(projectsRoot, dir, `${sessionId}.jsonl`)))
+            continue;
+        // Decode the suffix back to a real path under the worktree. The
+        // encoding is lossy, so we verify candidates against the filesystem
+        // rather than guessing — only return a path that actually exists.
+        const suffix = dir.slice(prefix.length);
+        const candidate = path.join(worktreeRoot, ...suffix.split("-"));
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+    }
+    return null;
+}

package/dist/lib/dashboard/DetailPanel.js

@@ -10,6 +10,8 @@ function stateColor(type) {
             return "gray";
         case "orphaned":
             return "gray";
+        case "main":
+            return "magenta";
         default:
             return "yellow";
     }
@@ -58,6 +60,19 @@ function fileColor(xy) {
 export function buildIssueActions(di, trackerName) {
     const { worktree, pr, issue } = di;
     const items = [];
+    // The synthetic "Main repo" row is special: no PR/Switch/Resume/Remove,
+    // no work-launching (you're already on it). Only commit / diff /
+    // editor — the actions that make sense for "I have changes in main and
+    // want to review or land them".
+    if (issue.state.type === "main") {
+        if (worktree) {
+            items.push({ key: "e", label: "Editor", color: "cyan" });
+            if (worktree.dirty)
+                items.push({ key: "C", label: "Commit", color: "cyan" });
+            items.push({ key: "v", label: "View diff", color: "cyan" });
+        }
+        return items;
+    }
     if (worktree?.sessionId) {
         items.push({ key: "↵", label: "Resume", color: "cyan" });
     }
@@ -164,19 +179,21 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
         lines.push({ text: `  ${worktree.path}`, dim: true });
         // Single metric row: files / +ins / -dels / commits ahead.
         const ds = worktree.diffStats;
-        if (ds && (ds.insertions > 0 || ds.deletions > 0 || ds.filesChanged > 0)) {
+        const behind = worktree.commitsBehind ?? 0;
+        const hasDiff = ds && (ds.insertions > 0 || ds.deletions > 0 || ds.filesChanged > 0);
+        if (hasDiff || worktree.commitsAhead > 0 || behind > 0) {
             const segs = [{ text: "  " }];
-            if (ds.filesChanged > 0) {
+            if (ds && ds.filesChanged > 0) {
                 segs.push({
                     text: `${ds.filesChanged} file${ds.filesChanged === 1 ? "" : "s"}`,
                 });
             }
-            if (ds.insertions > 0) {
+            if (ds && ds.insertions > 0) {
                 if (segs.length > 1)
                     segs.push({ text: "   " });
                 segs.push({ text: `+${ds.insertions}`, color: "green" });
             }
-            if (ds.deletions > 0) {
+            if (ds && ds.deletions > 0) {
                 if (segs.length > 1)
                     segs.push({ text: "   " });
                 segs.push({ text: `−${ds.deletions}`, color: "red" });
@@ -186,6 +203,11 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
                     segs.push({ text: "   " });
                 segs.push({ text: `↑ ${worktree.commitsAhead}`, color: "cyan" });
             }
+            if (behind > 0) {
+                if (segs.length > 1)
+                    segs.push({ text: "   " });
+                segs.push({ text: `↓ ${behind} behind`, color: "yellow" });
+            }
             lines.push({ text: "", segments: segs });
         }
         // Per-status counts only when there's something dirty — when the tree is
@@ -277,10 +299,78 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
         lines.push(sectionHeader("⎇", "Worktree"));
         lines.push({ text: "  no worktree for this ticket", dim: true });
     }
+    // ── Claude tasks ──────────────────────────────────────────────────
+    // Reads `~/.claude/todos/<sessionId>-agent-<sessionId>.json` (main-agent
+    // list only — sub-agent todos are noise). Section is hidden when the
+    // session has no todos or has exited; the header shows done/total at a
+    // glance. Up to 6 rows are rendered before collapsing into "+ N more".
+    const todos = worktree?.claudeTodos ?? null;
+    if (todos && todos.length > 0) {
+        const completed = todos.filter((t) => t.status === "completed").length;
+        const inProgress = todos.filter((t) => t.status === "in_progress").length;
+        lines.push(ruleLine);
+        const headerSegs = [
+            { text: "⎈ ", color: "cyan", bold: true },
+            { text: "Tasks", bold: true },
+            { text: "   " },
+            {
+                text: `${completed}/${todos.length}`,
+                color: completed === todos.length ? "green" : "cyan",
+            },
+        ];
+        if (inProgress > 0) {
+            headerSegs.push({ text: "  ·  ", dim: true });
+            headerSegs.push({ text: `${inProgress} in progress`, color: "yellow" });
+        }
+        lines.push({ text: "", segments: headerSegs });
+        const maxRows = 6;
+        // Surface in-progress first so the active task is always visible even
+        // when the list is long; pending next; completed last (most likely to
+        // be elided when truncating).
+        const ordered = [
+            ...todos.filter((t) => t.status === "in_progress"),
+            ...todos.filter((t) => t.status === "pending"),
+            ...todos.filter((t) => t.status === "completed"),
+        ];
+        for (const t of ordered.slice(0, maxRows)) {
+            if (t.status === "in_progress") {
+                lines.push({
+                    text: "",
+                    segments: [
+                        { text: "  ◐ ", color: "yellow", bold: true },
+                        { text: t.content, color: "yellow" },
+                    ],
+                });
+            }
+            else if (t.status === "completed") {
+                lines.push({
+                    text: "",
+                    segments: [
+                        { text: "  ✓ ", color: "green" },
+                        { text: t.content, dim: true },
+                    ],
+                });
+            }
+            else {
+                lines.push({
+                    text: "",
+                    segments: [{ text: "  ◯ ", dim: true }, { text: t.content }],
+                });
+            }
+        }
+        if (ordered.length > maxRows) {
+            lines.push({ text: `  + ${ordered.length - maxRows} more`, dim: true });
+        }
+    }
     // ── Pull Request ──────────────────────────────────────────────────
+    // Skip PR/Checks/Reviews sections entirely for the synthetic main row
+    // — those concepts don't apply to "the user's main checkout".
+    const isMain = li.state.type === "main";
     const { checks, reviews } = issue;
-    lines.push(ruleLine);
-    if (pr) {
+    if (!isMain) {
+        lines.push(ruleLine);
+    }
+    if (!isMain && pr) {
         const prColor = pr.state === "MERGED" ? "magenta" : pr.state === "OPEN" ? "green" : "red";
         const draft = pr.isDraft ? " · draft" : "";
         lines.push({
@@ -299,12 +389,12 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
             lines.push({ text: `  ${pr.url}`, dim: true });
         }
     }
-    else {
+    else if (!isMain) {
         lines.push(sectionHeader("◉", "Pull Request"));
         lines.push({ text: "  no PR yet", dim: true });
     }
     // ── Checks ────────────────────────────────────────────────────────
-    if (checks && checks.length > 0) {
+    if (!isMain && checks && checks.length > 0) {
         const passing = checks.filter((c) => c.bucket === "pass");
         const failing = checks.filter((c) => c.bucket === "fail");
         const pending = checks.filter((c) => c.bucket !== "pass" && c.bucket !== "fail");
@@ -338,7 +428,7 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
         }
     }
     // ── Reviews ───────────────────────────────────────────────────────
-    if (reviews && reviews.length > 0) {
+    if (!isMain && reviews && reviews.length > 0) {
         lines.push(ruleLine);
         lines.push(sectionHeader("★", "Reviews"));
         for (const review of reviews) {

package/dist/lib/dashboard/IssueList.js

@@ -17,6 +17,8 @@ function stateColor(type, name) {
             return "gray";
         case "orphaned":
             return "gray";
+        case "main":
+            return "magenta";
         default:
             return "yellow";
     }

package/dist/lib/dashboard/MultilineTextArea.js

@@ -162,24 +162,17 @@ export function MultilineTextArea({ value, onChange, onSubmit, onCancel, placeho
             onSubmit();
             return;
         }
-        // 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).
+        // the buffer is replaced and control returns to the textbox so the
+        // user can keep editing or submit with Ctrl+D.
         if (key.ctrl && input === "o") {
             const result = editExternally(value, "md");
             if (!result.ok)
                 return;
-            if (result.cancelled) {
-                onCancel();
+            if (result.cancelled)
                 return;
-            }
             onChange(result.content);
             setCursor(result.content.length);
-            onSubmit();
             return;
         }
         // Ctrl+V: paste clipboard image as a temp file reference.
@@ -189,6 +182,13 @@ export function MultilineTextArea({ value, onChange, onSubmit, onCancel, placeho
                 insertAt(cursor, `![pasted image](${imagePath})`);
             return;
         }
+        // Ctrl+G: cancel (Emacs abort). Ctrl+C can't be used because Ink's
+        // exitOnCtrlC fires at the app level before useInput sees it, exiting
+        // the dashboard. Esc is reserved for vim muscle memory (swallowed).
+        if (key.ctrl && input === "g") {
+            onCancel();
+            return;
+        }
         // Esc: swallow without cancelling (vim users hit it constantly).
         if (key.escape)
             return;
@@ -297,7 +297,20 @@ export function MultilineTextArea({ value, onChange, onSubmit, onCancel, placeho
             return;
         if (!input)
             return;
-        insertAt(cursor, input.replace(/\r\n?/g, "\n"));
+        // Strip OSC sequences (terminal-side responses to OSC 11/52 etc.
+        // queries) — they leak into stdin while a refresh is querying
+        // the background color and would otherwise type themselves into
+        // the buffer. Pattern: anything starting with `]` followed by a
+        // number, semicolon, payload, then BEL or ST. We strip both the
+        // fully-formed OSC `\x1b]…\x07` and the bracket-only fragment
+        // that arrives when Ink consumed the leading ESC as a separate
+        // keypress (which it does for almost all OSC responses).
+        let cleaned = input
+            .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+            .replace(/^\][0-9]+;[^\x07]*\x07?/, "");
+        if (!cleaned)
+            return;
+        insertAt(cursor, cleaned.replace(/\r\n?/g, "\n"));
     }, { isActive: focus });
     const innerWidth = Math.max(1, (width ?? 80) - 4);
     const rows = buildVisualRows(value, innerWidth);

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

@@ -25,4 +25,9 @@ interface PrCreateOverlayProps {
     dispatch: React.Dispatch<DashboardAction>;
 }
 export declare function PrCreateOverlay({ width, height, branch, ticketId, phase, error, url, body, title, dispatch, }: PrCreateOverlayProps): import("react/jsx-runtime").JSX.Element;
+interface HelpOverlayProps {
+    width: number;
+    height: number;
+}
+export declare function HelpOverlay({ width, height }: HelpOverlayProps): import("react/jsx-runtime").JSX.Element;
 export {};