santree 0.4.0 → 0.5.0

package/dist/commands/doctor.js

@@ -12,6 +12,8 @@ const { version } = require("../../package.json");
 import { findMainRepoRoot, getSantreeDir, getInitScriptPath } from "../lib/git.js";
 import { getAuthStatus, getValidTokens } from "../lib/linear.js";
 import { getMultiplexer } from "../lib/multiplexer/index.js";
+import { resolveClaudeBinary } from "../lib/ai.js";
+import { CURRENT_VERSION, CLAUDE_CODE_PACKAGE, SANTREE_PACKAGE, getLatestVersionFor, isUpdateAvailable, detectPackageManager, getInstallCommandFor, } from "../lib/version.js";
 const execAsync = promisify(exec);
 export const description = "Check system requirements and integrations";
 /**
@@ -107,9 +109,12 @@ async function checkMultiplexer() {
     }
     const version = await tryExec("cmux --version 2>/dev/null");
     const ping = await tryExec("cmux ping 2>/dev/null");
-    const hint = !ping
-        ? "cmux app not reachable — open cmux.app or set SANTREE_MULTIPLEXER=tmux. NOTE: cmux #1472 — programmatic workspaces may have dead PTYs (https://github.com/manaflow-ai/cmux/issues/1472)."
-        : "NOTE: cmux #1472 — programmatic workspaces may have dead PTYs (https://github.com/manaflow-ai/cmux/issues/1472).";
+    // Note: cmux #1472 (programmatic workspaces with dead PTYs) is a real
+    // limitation but only surfaces when a specific dashboard flow tries to
+    // auto-execute a command in a freshly-created workspace. Showing it on
+    // every doctor run made cmux look broken when it isn't — the limitation
+    // is documented in CLAUDE.md and the README. We only flag a hint here
+    // when cmux is actually unreachable.
     return {
         name: "cmux",
         description,
@@ -117,7 +122,40 @@ async function checkMultiplexer() {
         installed: !!ping,
         version: version || "unknown",
         path,
-        hint,
+        hint: !ping
+            ? "cmux app not reachable — open cmux.app or set SANTREE_MULTIPLEXER=tmux."
+            : undefined,
+    };
+}
+/**
+ * Checks the Claude CLI, preferring cmux's bundled binary when running inside
+ * cmux. The standard `checkTool` uses `which claude` which can't locate the
+ * cmux shim at /Applications/cmux.app/Contents/Resources/bin/claude — that
+ * binary isn't on PATH. See manaflow-ai/cmux#2048.
+ */
+async function checkClaude() {
+    const resolved = resolveClaudeBinary();
+    const inCmux = getMultiplexer().kind === "cmux";
+    const description = inCmux ? "Claude Code CLI (cmux-bundled)" : "Claude Code CLI";
+    if (!resolved) {
+        return {
+            name: "claude",
+            description,
+            required: true,
+            installed: false,
+            hint: inCmux
+                ? "Open cmux.app to install its bundled Claude, or install standalone: npm install -g @anthropic-ai/claude-code"
+                : "Install: npm install -g @anthropic-ai/claude-code",
+        };
+    }
+    const version = await tryExec(`"${resolved}" --version 2>/dev/null | head -1`);
+    return {
+        name: "claude",
+        description,
+        required: true,
+        installed: true,
+        version: version || "unknown",
+        path: resolved,
     };
 }
 /**
@@ -411,7 +449,7 @@ function StatusIcon({ ok, required }) {
     return required ? _jsx(Text, { color: "red", children: "\u2717" }) : _jsx(Text, { color: "yellow", children: "\u25CB" });
 }
 function ToolRow({ tool }) {
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: tool.installed && !tool.hint, required: tool.required }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: tool.name }), _jsxs(Text, { dimColor: true, children: [" - ", tool.description] }), !tool.required && _jsx(Text, { dimColor: true, children: " (optional)" })] }), tool.installed ? (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Version: ", tool.version] }), _jsxs(Text, { dimColor: true, children: ["Path: ", tool.path] }), tool.authStatus && _jsxs(Text, { dimColor: true, children: ["Auth: ", tool.authStatus] }), tool.hint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.hint] })] })) : (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.hint] }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: tool.installed && !tool.hint, required: tool.required }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: tool.name }), _jsxs(Text, { dimColor: true, children: [" - ", tool.description] }), !tool.required && _jsx(Text, { dimColor: true, children: " (optional)" })] }), tool.installed ? (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Version: ", tool.version] }), tool.latestVersion && tool.version && (_jsxs(Text, { color: isUpdateAvailable(tool.version, tool.latestVersion) ? "yellow" : undefined, dimColor: !isUpdateAvailable(tool.version, tool.latestVersion), children: ["Latest: ", tool.latestVersion, isUpdateAvailable(tool.version, tool.latestVersion) ? " ⬆ update available" : ""] })), tool.path && _jsxs(Text, { dimColor: true, children: ["Path: ", tool.path] }), tool.authStatus && _jsxs(Text, { dimColor: true, children: ["Auth: ", tool.authStatus] }), tool.updateHint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.updateHint] }), tool.hint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.hint] })] })) : (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.hint] }) }))] }));
 }
 function LinearRow({ linear }) {
     const isOk = linear.authenticated && linear.tokenValid && linear.repoLinked;
@@ -461,30 +499,78 @@ export default function Doctor() {
     const [loading, setLoading] = useState(true);
     useEffect(() => {
         async function runChecks() {
-            const results = await Promise.all([
-                checkTool("git", "Version control", true, "git --version | head -1", "Install: brew install git"),
-                checkGhAuth(),
-                checkMultiplexer(),
-                checkTool("claude", "Claude Code CLI", true, "claude --version 2>/dev/null | head -1", "Install: npm install -g @anthropic-ai/claude-code"),
+            const pm = detectPackageManager();
+            const [results, latestSantree, latestClaude] = await Promise.all([
+                Promise.all([
+                    checkTool("git", "Version control", true, "git --version | head -1", "Install: brew install git"),
+                    checkGhAuth(),
+                    checkMultiplexer(),
+                    checkClaude(),
+                ]),
+                getLatestVersionFor(SANTREE_PACKAGE),
+                getLatestVersionFor(CLAUDE_CODE_PACKAGE),
             ]);
-            // Check for either code or cursor (only need one)
+            // Synthetic row for santree itself — surfaces update status.
+            const santreeRow = {
+                name: "santree",
+                description: "Santree CLI (this app)",
+                required: true,
+                installed: true,
+                version: CURRENT_VERSION,
+                latestVersion: latestSantree ?? undefined,
+                updateHint: latestSantree && isUpdateAvailable(CURRENT_VERSION, latestSantree)
+                    ? "Run: santree update"
+                    : undefined,
+            };
+            results.unshift(santreeRow);
+            // Augment the claude row with latest-version info from npm registry.
+            // When the resolved binary is the cmux-bundled one, npm install can't
+            // update it — the bundled binary is shipped inside cmux.app. Show a
+            // cmux-aware hint instead of the generic npm command.
+            const claudeRow = results.find((r) => r.name === "claude");
+            if (claudeRow && claudeRow.installed && latestClaude) {
+                claudeRow.latestVersion = latestClaude;
+                if (claudeRow.version && isUpdateAvailable(claudeRow.version, latestClaude)) {
+                    const isCmuxBundled = !!claudeRow.path?.includes("/cmux.app/");
+                    if (isCmuxBundled) {
+                        claudeRow.updateHint = "Bundled with cmux — update cmux.app to get the latest Claude.";
+                    }
+                    else {
+                        const cmd = getInstallCommandFor(pm, `${CLAUDE_CODE_PACKAGE}@latest`);
+                        claudeRow.updateHint = `Run: ${cmd.display}`;
+                    }
+                }
+            }
+            // Optional: a syntax-highlighted diff pager — used by `st worktree diff`
+            // and the dashboard `v` overlay when SANTREE_DIFF_TOOL is set. Any
+            // pager works (delta, diff-so-fancy, …); without one set, git's
+            // default pager runs. Delta is the most popular choice so we check
+            // for it as a convenience, but it is never a hard dependency.
+            const deltaCheck = await checkTool("delta", "Recommended diff pager — any pager works", false, "delta --version | head -1", "Optional — git's default pager works too. Set SANTREE_DIFF_TOOL or `git config core.pager <tool>`. To install delta: brew install git-delta");
+            results.push(deltaCheck);
+            // Optional: a `.code-workspace`-aware editor (VSCode or Cursor).
+            // Santree itself works with any editor via $SANTREE_EDITOR — this
+            // check exists only because the dashboard's `E workspace` shortcut
+            // needs an editor that understands `.code-workspace` files. Missing
+            // here just means the shortcut is hidden; everything else still works.
+            const workspaceEditorDesc = "Workspace editor (`E workspace` shortcut)";
             const [codeCheck, cursorCheck] = await Promise.all([
-                checkTool("code", "VSCode editor", false, "code --version | head -1", ""),
-                checkTool("cursor", "Cursor editor", false, "cursor --version | head -1", ""),
+                checkTool("code", workspaceEditorDesc, false, "code --version | head -1", ""),
+                checkTool("cursor", workspaceEditorDesc, false, "cursor --version | head -1", ""),
             ]);
             if (codeCheck.installed) {
-                results.push({ ...codeCheck, description: "Editor (VSCode)" });
+                results.push(codeCheck);
             }
             else if (cursorCheck.installed) {
-                results.push({ ...cursorCheck, description: "Editor (Cursor)" });
+                results.push(cursorCheck);
             }
             else {
                 results.push({
                     name: "code/cursor",
-                    description: "Editor (VSCode or Cursor)",
+                    description: workspaceEditorDesc,
                     required: false,
                     installed: false,
-                    hint: "Install VSCode (https://code.visualstudio.com) or Cursor (https://cursor.sh)",
+                    hint: "Optional — santree works with any $SANTREE_EDITOR. Only needed for the dashboard's `.code-workspace` shortcut.",
                 });
             }
             const linearResult = await checkLinearAuth();

package/dist/commands/helpers/statusline.js

@@ -132,9 +132,17 @@ function getGitChanges(cwd) {
         untracked: countLines(git(cwd, "ls-files --others --exclude-standard")),
     };
 }
-// Build a progress bar for context usage
+// Build a progress bar for context usage.
+//
+// We deliberately inflate the displayed percentage by 20% (clamped to 100) so
+// the bar fills up faster than the model's actual context window. The point is
+// to nudge toward more-frequent /compact: the color thresholds (60%/80%) trip
+// earlier, so the yellow/red warnings show up while there's still real headroom
+// left to compact gracefully instead of after the model has already started
+// dropping content.
+const CONTEXT_DISPLAY_MULTIPLIER = 1.2;
 function formatContextUsage(usedPercentage) {
-    const used = Math.round(usedPercentage);
+    const used = Math.min(100, Math.round(usedPercentage * CONTEXT_DISPLAY_MULTIPLIER));
     const color = used >= 80 ? c.red : used >= 60 ? c.yellow : c.green;
     const width = 20;
     const filled = Math.round((used * width) / 100);

package/dist/commands/update.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const description = "Update santree to the latest version on npm";
+export declare const options: z.ZodObject<{
+    force: z.ZodOptional<z.ZodBoolean>;
+    pm: z.ZodOptional<z.ZodEnum<{
+        npm: "npm";
+        pnpm: "pnpm";
+        yarn: "yarn";
+    }>>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Update({ options }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box, useApp } from "ink";
+import Spinner from "ink-spinner";
+import { z } from "zod";
+import { CURRENT_VERSION, CLAUDE_CODE_PACKAGE, getLatestVersion, getLatestVersionFor, getInstalledClaudeVersion, isUpdateAvailable, detectPackageManager, getInstallCommand, getInstallCommandFor, } from "../lib/version.js";
+import { spawnAsync } from "../lib/exec.js";
+export const description = "Update santree to the latest version on npm";
+export const options = z.object({
+    force: z.boolean().optional().describe("Reinstall even if already on the latest version"),
+    pm: z
+        .enum(["npm", "pnpm", "yarn"])
+        .optional()
+        .describe("Override package manager auto-detection"),
+});
+const TAIL_LINES = 8;
+function tail(text, n) {
+    return text
+        .split("\n")
+        .filter((l) => l.length > 0)
+        .slice(-n);
+}
+export default function Update({ options }) {
+    const { exit } = useApp();
+    const [status, setStatus] = useState("checking");
+    const [latest, setLatest] = useState(null);
+    const [pm, setPm] = useState("npm");
+    const [installCmd, setInstallCmd] = useState("");
+    const [output, setOutput] = useState("");
+    const [error, setError] = useState(null);
+    const [claude, setClaude] = useState(null);
+    useEffect(() => {
+        (async () => {
+            await new Promise((r) => setTimeout(r, 80));
+            // Check santree + claude versions in parallel.
+            const [latestVersion, latestClaude] = await Promise.all([
+                getLatestVersion({ force: true }),
+                getLatestVersionFor(CLAUDE_CODE_PACKAGE, { force: true }),
+            ]);
+            setLatest(latestVersion);
+            setClaude({ installed: getInstalledClaudeVersion(), latest: latestClaude });
+            const detectedPm = options.pm ?? detectPackageManager();
+            setPm(detectedPm);
+            const cmd = getInstallCommand(detectedPm);
+            setInstallCmd(cmd.display);
+            if (!latestVersion) {
+                setStatus("error");
+                setError("Could not reach the npm registry. Check your connection.");
+                setTimeout(() => exit(), 100);
+                return;
+            }
+            if (!options.force && !isUpdateAvailable(CURRENT_VERSION, latestVersion)) {
+                setStatus("up-to-date");
+                setTimeout(() => exit(), 100);
+                return;
+            }
+            setStatus("installing");
+            const result = await spawnAsync(cmd.cmd, cmd.args, {
+                onOutput: (data) => setOutput(data),
+            });
+            if (result.code === 0) {
+                setStatus("done");
+            }
+            else {
+                setStatus("error");
+                setError(`${cmd.display} exited with code ${result.code}`);
+            }
+            setTimeout(() => exit(), 100);
+        })();
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Santree Update" }) }), _jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "current:" }), _jsxs(Text, { children: ["v", CURRENT_VERSION] })] }), latest && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "latest: " }), _jsxs(Text, { color: isUpdateAvailable(CURRENT_VERSION, latest) ? "yellow" : "green", children: ["v", latest] })] })), installCmd && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "via: " }), _jsxs(Text, { children: [installCmd, " ", _jsxs(Text, { dimColor: true, children: ["(detected: ", pm, ")"] })] })] }))] }), _jsxs(Box, { marginTop: 1, children: [status === "checking" && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: "Checking npm registry..." })] })), status === "installing" && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: ["Running ", installCmd, "..."] })] })), status === "up-to-date" && (_jsx(Text, { color: "green", bold: true, children: "\u2713 Already on the latest version" })), status === "done" && latest && (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 Updated to v", latest] })), status === "error" && error && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }))] }), (status === "installing" || status === "error") && output && (_jsx(Box, { marginTop: 1, flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, children: tail(output, TAIL_LINES).map((line, i) => (_jsx(Text, { dimColor: true, children: line }, i))) })), claude && claude.installed && (_jsx(Box, { marginTop: 1, flexDirection: "column", children: claude.latest && isUpdateAvailable(claude.installed, claude.latest) ? (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "yellow", children: ["\u2B06 Claude Code ", claude.installed, " \u2192 ", claude.latest, " available"] }), _jsxs(Text, { dimColor: true, children: ["Run: ", getInstallCommandFor(pm, `${CLAUDE_CODE_PACKAGE}@latest`).display] })] })) : claude.latest ? (_jsxs(Text, { dimColor: true, children: ["\u2713 Claude Code ", claude.installed, " is up to date"] })) : null }))] }));
+}

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const description = "View worktree diff against its base branch (uses delta if installed)";
+export declare const options: z.ZodObject<{
+    staged: z.ZodOptional<z.ZodBoolean>;
+    unstaged: z.ZodOptional<z.ZodBoolean>;
+    commits: z.ZodOptional<z.ZodBoolean>;
+    base: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Diff({ options: opts }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/commands/worktree/diff.js

@@ -0,0 +1,76 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box, useApp } from "ink";
+import { z } from "zod";
+import { spawn } from "child_process";
+import { findRepoRoot, getCurrentBranch, getBaseBranch, getDiffTool } from "../../lib/git.js";
+import { run } from "../../lib/exec.js";
+export const description = "View worktree diff against its base branch (uses delta if installed)";
+export const options = z.object({
+    staged: z.boolean().optional().describe("Show only staged changes"),
+    unstaged: z.boolean().optional().describe("Show only unstaged changes (working tree vs index)"),
+    commits: z.boolean().optional().describe("Show only committed changes (base...HEAD)"),
+    base: z.string().optional().describe("Override base branch"),
+});
+export default function Diff({ options: opts }) {
+    const [status, setStatus] = useState({ state: "running" });
+    const { exit } = useApp();
+    useEffect(() => {
+        const repoRoot = findRepoRoot();
+        if (!repoRoot) {
+            setStatus({ state: "error", message: "Not inside a git repository" });
+            return;
+        }
+        const branch = getCurrentBranch();
+        if (!branch) {
+            setStatus({ state: "error", message: "Could not determine current branch" });
+            return;
+        }
+        const baseBranch = opts.base ?? getBaseBranch(branch);
+        // Use merge-base (not base tip) so upstream-only changes are excluded —
+        // matches GitHub PR diff semantics. Falls back to baseBranch if merge-base
+        // can't be resolved (e.g. unrelated histories).
+        const mergeBase = run(`git -C "${repoRoot}" merge-base "${baseBranch}" HEAD`) ?? baseBranch;
+        // Resolve diff range based on flags. Defaults to merge-base..working-tree
+        // (everything on this branch including uncommitted work, branch-only).
+        // Honor SANTREE_DIFF_TOOL by overriding core.pager just for this invocation
+        // — `-c` config takes precedence over the user's global git config.
+        const tool = getDiffTool();
+        const args = ["-C", repoRoot];
+        if (tool) {
+            args.push("-c", `core.pager=${tool}`);
+        }
+        args.push("diff");
+        if (opts.staged) {
+            args.push("--staged");
+        }
+        else if (opts.unstaged) {
+            // working tree vs index — no extra arg
+        }
+        else if (opts.commits) {
+            args.push(`${mergeBase}..HEAD`);
+        }
+        else {
+            args.push(mergeBase);
+        }
+        const child = spawn("git", args, { stdio: "inherit" });
+        child.on("error", (err) => {
+            setStatus({ state: "error", message: err.message });
+            exit();
+        });
+        child.on("close", (code) => {
+            setStatus({ state: "done", exitCode: code ?? 0 });
+            exit();
+        });
+        return () => {
+            if (!child.killed)
+                child.kill();
+        };
+    }, []);
+    if (status.state === "error") {
+        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["\u2717 ", status.message] }) }));
+    }
+    // While running: render nothing so git/delta own the terminal.
+    // On done: render nothing — git's output already filled the screen.
+    return null;
+}

package/dist/lib/ai.d.ts

@@ -37,8 +37,18 @@ export declare function fetchAndRenderPR(branch: string): Promise<string | null>
  */
 export declare function fetchAndRenderDiff(branch: string): Promise<string>;
 /**
- * Check if claude CLI is available on PATH.
- * Returns "claude" or null if not installed.
+ * Resolve the path to the Claude CLI binary, preferring cmux's bundled copy
+ * when running inside cmux. Falls back to PATH lookup, then to Anthropic's
+ * standard installer location (`~/.claude/local/claude`). Returns null if
+ * none of those resolve.
+ *
+ * Used by every santree code path that needs to invoke or report the Claude
+ * binary — version display, doctor checks, and interactive launches.
+ */
+export declare function resolveClaudeBinary(): string | null;
+/**
+ * @deprecated Use `resolveClaudeBinary()` directly. Kept as an alias because
+ * existing call sites pass the return value straight to spawn args.
  */
 export declare function resolveAgentBinary(): string | null;
 /**

package/dist/lib/ai.js

@@ -1,7 +1,8 @@
 import { execSync, spawn, spawnSync } from "child_process";
-import { writeFileSync } from "fs";
+import { existsSync, writeFileSync } from "fs";
 import { join } from "path";
-import { tmpdir } from "os";
+import { homedir, tmpdir } from "os";
+import { getMultiplexer } from "./multiplexer/index.js";
 import { getCurrentBranch, extractTicketId, findRepoRoot, findMainRepoRoot, getBaseBranch, } from "./git.js";
 import { renderPrompt, renderTicket, renderDiff, renderPR } from "./prompts.js";
 import { getTicketContent, cleanupImages } from "./linear.js";
@@ -105,17 +106,47 @@ export async function fetchAndRenderDiff(branch) {
     });
 }
 /**
- * Check if claude CLI is available on PATH.
- * Returns "claude" or null if not installed.
+ * cmux ships its own Claude CLI shim wired to the active cmux workspace. When
+ * we run inside cmux, the system `claude` (if any) talks to a different
+ * session — confusing for the user. See manaflow-ai/cmux#2048.
  */
-export function resolveAgentBinary() {
+const CMUX_CLAUDE_PATH = "/Applications/cmux.app/Contents/Resources/bin/claude";
+/**
+ * Resolve the path to the Claude CLI binary, preferring cmux's bundled copy
+ * when running inside cmux. Falls back to PATH lookup, then to Anthropic's
+ * standard installer location (`~/.claude/local/claude`). Returns null if
+ * none of those resolve.
+ *
+ * Used by every santree code path that needs to invoke or report the Claude
+ * binary — version display, doctor checks, and interactive launches.
+ */
+export function resolveClaudeBinary() {
+    // Inside cmux, the bundled binary is the only one wired to the active
+    // workspace. Always prefer it when present.
+    if (getMultiplexer().kind === "cmux" && existsSync(CMUX_CLAUDE_PATH)) {
+        return CMUX_CLAUDE_PATH;
+    }
+    // PATH lookup
     try {
         execSync("which claude", { stdio: "ignore" });
         return "claude";
     }
     catch {
-        return null;
+        // fall through
     }
+    // Anthropic installer location — Ink renders may not inherit the user's
+    // shell PATH, so check this explicitly.
+    const localClaude = join(homedir(), ".claude", "local", "claude");
+    if (existsSync(localClaude))
+        return localClaude;
+    return null;
+}
+/**
+ * @deprecated Use `resolveClaudeBinary()` directly. Kept as an alias because
+ * existing call sites pass the return value straight to spawn args.
+ */
+export function resolveAgentBinary() {
+    return resolveClaudeBinary();
 }
 // Conservative limit: 200KB leaves room for env vars within macOS 256KB ARG_MAX
 const ARG_MAX_SAFE = 200 * 1024;

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

@@ -7,5 +7,14 @@ interface Props {
     creatingForTicket: string | null;
     creationLogs: string;
 }
+export type IssueActionItem = {
+    key: string;
+    label: string;
+    color: string;
+};
+/** Returns the context-sensitive action key list for the selected issue.
+ * Lifted out of the panel so the dashboard can render it on the same row as
+ * the global command bar (so left- and right-pane key hints align). */
+export declare function buildIssueActions(di: DashboardIssue): IssueActionItem[];
 export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};