santree 0.7.3 → 0.7.5

package/dist/lib/setup/shell-config.js

@@ -0,0 +1,131 @@
+import * as fs from "fs";
+import * as path from "path";
+const BLOCK_START = "# >>> santree >>>";
+const BLOCK_END = "# <<< santree <<<";
+const BLOCK_HEADER = "# Managed by `santree setup` — safe to re-run; edits here may be overwritten.";
+/**
+ * Resolve the rc file the managed block should live in, honoring ZDOTDIR (zsh)
+ * so users with an XDG-based setup (~/.config/zsh, no ~/.zshrc) get the block in
+ * the right place.
+ */
+export function resolveShellConfig(shellEnv = process.env.SHELL || "") {
+    const home = process.env.HOME || "";
+    const base = path.basename(shellEnv);
+    if (base.includes("zsh")) {
+        const dir = process.env.ZDOTDIR || home;
+        return {
+            shell: "zsh",
+            rcPath: path.join(dir, ".zshrc"),
+            scanPaths: [
+                path.join(dir, ".zshrc"),
+                path.join(dir, ".zshenv"),
+                path.join(home, ".zshenv"),
+                path.join(home, ".zprofile"),
+            ],
+        };
+    }
+    if (base.includes("bash")) {
+        return {
+            shell: "bash",
+            rcPath: path.join(home, ".bashrc"),
+            scanPaths: [
+                path.join(home, ".bashrc"),
+                path.join(home, ".bash_profile"),
+                path.join(home, ".profile"),
+            ],
+        };
+    }
+    // Fall back to zsh conventions (the default macOS shell).
+    const dir = process.env.ZDOTDIR || home;
+    return {
+        shell: "unknown",
+        rcPath: path.join(dir, ".zshrc"),
+        scanPaths: [path.join(dir, ".zshrc"), path.join(dir, ".zshenv"), path.join(home, ".zshenv")],
+    };
+}
+function tagFor(key) {
+    return `# santree:${key}`;
+}
+function readFileSafe(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+function splitBlock(content) {
+    const startIdx = content.indexOf(BLOCK_START);
+    if (startIdx === -1) {
+        return { before: content, body: [], after: "", exists: false };
+    }
+    const endMarkerIdx = content.indexOf(BLOCK_END, startIdx);
+    if (endMarkerIdx === -1) {
+        // Malformed (start without end) — treat everything from start as the block.
+        const before = content.slice(0, startIdx);
+        return { before, body: [], after: "", exists: true };
+    }
+    const before = content.slice(0, startIdx);
+    const after = content.slice(endMarkerIdx + BLOCK_END.length);
+    const inner = content.slice(startIdx + BLOCK_START.length, endMarkerIdx);
+    const body = inner
+        .split("\n")
+        .map((l) => l.trimEnd())
+        .filter((l) => l.length > 0 && l !== BLOCK_HEADER);
+    return { before, body, after, exists: true };
+}
+function renderBlock(body) {
+    return [BLOCK_START, BLOCK_HEADER, ...body, BLOCK_END].join("\n");
+}
+/**
+ * Upsert a single tagged line into the managed block, creating the block (and
+ * the rc file) if needed. The line for `key` is replaced if present, else
+ * appended. `line` is the raw shell statement WITHOUT the trailing tag comment.
+ */
+export function upsertManagedLine(rcPath, key, line) {
+    const content = readFileSafe(rcPath);
+    const { before, body, after, exists } = splitBlock(content);
+    const tag = tagFor(key);
+    const tagged = `${line} ${tag}`;
+    const idx = body.findIndex((l) => l.trimEnd().endsWith(tag));
+    const nextBody = idx === -1 ? [...body, tagged] : body.map((l, i) => (i === idx ? tagged : l));
+    let output;
+    if (exists) {
+        output = before + renderBlock(nextBody) + after;
+    }
+    else {
+        // Append a fresh block, keeping a single trailing newline.
+        const trimmed = content.replace(/\n+$/, "");
+        const prefix = trimmed.length > 0 ? trimmed + "\n\n" : "";
+        output = prefix + renderBlock(nextBody) + "\n";
+    }
+    const dir = path.dirname(rcPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(rcPath, output.endsWith("\n") ? output : output + "\n");
+}
+/**
+ * Detect whether `name` is already exported by the user's shell config (any of
+ * `scanPaths`) or the current environment. Used so setup doesn't clobber an
+ * export the user already maintains by hand (e.g. SANTREE_EDITOR in .zshenv).
+ * Ignores santree's own managed block so a prior setup run isn't mistaken for a
+ * hand-maintained export.
+ */
+export function isEnvVarSet(name, cfg) {
+    if (process.env[name])
+        return true;
+    const re = new RegExp(`^\\s*export\\s+${name}=`, "m");
+    for (const p of cfg.scanPaths) {
+        const content = readFileSafe(p);
+        if (!content)
+            continue;
+        // Strip our own managed block before scanning hand-maintained exports.
+        const { before, after } = splitBlock(content);
+        const userContent = p === cfg.rcPath ? before + after : content;
+        if (re.test(userContent))
+            return true;
+    }
+    return false;
+}
+export function envKey(name) {
+    return `env:${name}`;
+}

package/dist/lib/setup/steps.d.ts

@@ -0,0 +1,35 @@
+import { type ShellConfig } from "./shell-config.js";
+export type DetectState = "ok" | "actionable" | "unavailable";
+export interface StepOption {
+    value: string;
+    label: string;
+}
+export interface StepResult {
+    ok: boolean;
+    message: string;
+}
+export interface SetupStep {
+    id: string;
+    title: string;
+    detail: string;
+    scope: "global" | "repo";
+    /** "spawn" steps take over the terminal (installs/logins); UI flags them. */
+    kind: "file" | "spawn";
+    recommended: boolean;
+    detect: DetectState;
+    /** Pick-one sub-prompt collected before apply; absent = no choice needed. */
+    options?: StepOption[];
+    optionPrompt?: string;
+    apply: (choice: string | undefined) => StepResult | Promise<StepResult>;
+}
+export interface SetupContext {
+    repoRoot: string | null;
+    shell: ShellConfig;
+    dryRun: boolean;
+}
+export declare function buildContext(dryRun: boolean): SetupContext;
+/**
+ * Build the full step catalog with `detect` + `options` resolved against the
+ * current machine. The wizard filters to `actionable` steps for the checklist.
+ */
+export declare function buildSteps(ctx: SetupContext): SetupStep[];

package/dist/lib/setup/steps.js

@@ -0,0 +1,328 @@
+import * as fs from "fs";
+import { run } from "../exec.js";
+import { findMainRepoRoot, getSantreeDir, getInitScriptPath } from "../git.js";
+import { isRepoTrackerConfigured } from "../trackers/index.js";
+import { getMultiplexer } from "../multiplexer/index.js";
+import { resolveClaudeBinary } from "../ai.js";
+import { CLAUDE_CODE_PACKAGE, detectPackageManager, getInstallCommandFor } from "../version.js";
+import { installHooks as installSessionSignalHooks } from "../session-signal.js";
+import { isStatuslineConfigured, configureStatusline, isRemoteControlEnabled, enableRemoteControl, isSessionSignalConfigured, } from "../claude-config.js";
+import { resolveShellConfig, upsertManagedLine, isEnvVarSet, envKey, } from "./shell-config.js";
+import { detectDiffPagers, detectEditors, getInstaller, which } from "./tools.js";
+import { missingIgnoreEntries, addIgnoreEntries, SANTREE_IGNORE_ENTRIES, } from "./gitignore.js";
+import { spawnTTY, santreeSelfArgv } from "./apply.js";
+export function buildContext(dryRun) {
+    return {
+        repoRoot: findMainRepoRoot(),
+        shell: resolveShellConfig(),
+        dryRun,
+    };
+}
+/**
+ * Build the full step catalog with `detect` + `options` resolved against the
+ * current machine. The wizard filters to `actionable` steps for the checklist.
+ */
+export function buildSteps(ctx) {
+    const steps = [];
+    const { shell, repoRoot, dryRun } = ctx;
+    const installer = getInstaller();
+    // ── Editor (SANTREE_EDITOR) ─────────────────────────────────────────────────
+    {
+        const editors = detectEditors();
+        const set = isEnvVarSet("SANTREE_EDITOR", shell);
+        const detect = set ? "ok" : editors.length > 0 ? "actionable" : "unavailable";
+        steps.push({
+            id: "editor",
+            title: "Default editor (SANTREE_EDITOR)",
+            detail: "Editor opened by the dashboard's [e] action",
+            scope: "global",
+            kind: "file",
+            recommended: true,
+            detect,
+            options: editors.map((e) => ({ value: e.command, label: e.command })),
+            optionPrompt: "Pick your editor:",
+            apply: (choice) => {
+                const editor = choice || editors[0]?.command || "vim";
+                if (dryRun)
+                    return { ok: true, message: `Would set SANTREE_EDITOR=${editor}` };
+                upsertManagedLine(shell.rcPath, envKey("SANTREE_EDITOR"), `export SANTREE_EDITOR="${editor}"`);
+                return { ok: true, message: `Set SANTREE_EDITOR=${editor} in ${shell.rcPath}` };
+            },
+        });
+    }
+    // ── Diff tool (SANTREE_DIFF_TOOL) ───────────────────────────────────────────
+    {
+        const pagers = detectDiffPagers();
+        const hasDelta = pagers.some((p) => p.command === "delta");
+        const options = pagers.map((p) => ({ value: p.command, label: p.command }));
+        if (installer && !hasDelta) {
+            options.push({
+                value: "install:delta",
+                label: `git-delta — install via ${installer.name}`,
+            });
+        }
+        const set = isEnvVarSet("SANTREE_DIFF_TOOL", shell);
+        const detect = set ? "ok" : options.length > 0 ? "actionable" : "unavailable";
+        steps.push({
+            id: "diff-tool",
+            title: "Diff tool (SANTREE_DIFF_TOOL)",
+            detail: "Pretty diffs in `worktree diff` and the dashboard [v] overlay",
+            scope: "global",
+            kind: installer && !hasDelta ? "spawn" : "file",
+            recommended: true,
+            detect,
+            options,
+            optionPrompt: "Pick a diff pager:",
+            apply: (choice) => {
+                const pick = choice || options[0]?.value;
+                if (!pick)
+                    return { ok: false, message: "No diff pager available" };
+                let tool = pick;
+                if (pick.startsWith("install:")) {
+                    tool = pick.slice("install:".length);
+                    if (dryRun) {
+                        return {
+                            ok: true,
+                            message: `Would ${installer.installArgv("git-delta").join(" ")} then set SANTREE_DIFF_TOOL=${tool}`,
+                        };
+                    }
+                    const argv = installer.installArgv("git-delta");
+                    const code = spawnTTY(argv[0], argv.slice(1));
+                    if (code !== 0)
+                        return { ok: false, message: "git-delta install failed — SANTREE_DIFF_TOOL not set" };
+                }
+                if (dryRun)
+                    return { ok: true, message: `Would set SANTREE_DIFF_TOOL=${tool}` };
+                upsertManagedLine(shell.rcPath, envKey("SANTREE_DIFF_TOOL"), `export SANTREE_DIFF_TOOL="${tool}"`);
+                return { ok: true, message: `Set SANTREE_DIFF_TOOL=${tool} in ${shell.rcPath}` };
+            },
+        });
+    }
+    // ── Statusline ──────────────────────────────────────────────────────────────
+    steps.push({
+        id: "statusline",
+        title: "Claude Code statusline",
+        detail: "Worktree-aware statusline (branch, context usage, session state)",
+        scope: "global",
+        kind: "file",
+        recommended: true,
+        detect: isStatuslineConfigured() ? "ok" : "actionable",
+        apply: () => {
+            if (dryRun)
+                return { ok: true, message: "Would configure statusLine in ~/.claude/settings.json" };
+            const p = configureStatusline();
+            return { ok: true, message: `Configured statusline in ${p}` };
+        },
+    });
+    // ── Session-signal hooks ────────────────────────────────────────────────────
+    steps.push({
+        id: "session-signal",
+        title: "Session-state signal hooks",
+        detail: "Surface Claude session state (waiting/active/idle) in the dashboard",
+        scope: "global",
+        kind: "file",
+        recommended: true,
+        detect: isSessionSignalConfigured() ? "ok" : "actionable",
+        apply: () => {
+            if (dryRun)
+                return {
+                    ok: true,
+                    message: "Would install session-signal hooks in ~/.claude/settings.json",
+                };
+            const p = installSessionSignalHooks();
+            return { ok: true, message: `Installed session-signal hooks in ${p}` };
+        },
+    });
+    // ── Remote control ──────────────────────────────────────────────────────────
+    steps.push({
+        id: "remote-control",
+        title: "Claude Code remote control",
+        detail: "Enable remote control at startup (drive sessions from the dashboard)",
+        scope: "global",
+        kind: "file",
+        recommended: false,
+        detect: isRemoteControlEnabled() ? "ok" : "actionable",
+        apply: () => {
+            if (dryRun)
+                return { ok: true, message: "Would set remoteControlAtStartup in ~/.claude.json" };
+            const p = enableRemoteControl();
+            return { ok: true, message: `Enabled remote control in ${p}` };
+        },
+    });
+    // ── GitHub CLI install + auth ───────────────────────────────────────────────
+    {
+        const ghInstalled = !!which("gh");
+        // `gh auth status` prints to stderr — redirect so it doesn't leak into the wizard.
+        const ghAuthed = ghInstalled && run("gh auth status >/dev/null 2>&1") !== null;
+        const detect = ghAuthed
+            ? "ok"
+            : ghInstalled || installer
+                ? "actionable"
+                : "unavailable";
+        steps.push({
+            id: "gh",
+            title: "GitHub CLI (gh) auth",
+            detail: "Required for PR create / review / checks",
+            scope: "global",
+            kind: "spawn",
+            recommended: true,
+            detect,
+            apply: () => {
+                if (dryRun) {
+                    const parts = !ghInstalled && installer ? `${installer.installArgv("gh").join(" ")} then ` : "";
+                    return { ok: true, message: `Would ${parts}gh auth login` };
+                }
+                if (!ghInstalled) {
+                    if (!installer)
+                        return { ok: false, message: "Install gh manually: see https://cli.github.com" };
+                    const argv = installer.installArgv("gh");
+                    const code = spawnTTY(argv[0], argv.slice(1));
+                    if (code !== 0)
+                        return { ok: false, message: "gh install failed" };
+                }
+                const code = spawnTTY("gh", ["auth", "login"]);
+                return code === 0
+                    ? { ok: true, message: "gh authenticated" }
+                    : { ok: false, message: "gh auth login did not complete" };
+            },
+        });
+    }
+    // ── Claude Code CLI ─────────────────────────────────────────────────────────
+    {
+        const installed = !!resolveClaudeBinary();
+        steps.push({
+            id: "claude",
+            title: "Claude Code CLI",
+            detail: "Powers `worktree work`, `pr fix`, `pr review`",
+            scope: "global",
+            kind: "spawn",
+            recommended: true,
+            detect: installed ? "ok" : "actionable",
+            apply: () => {
+                const cmd = getInstallCommandFor(detectPackageManager(), CLAUDE_CODE_PACKAGE);
+                if (dryRun)
+                    return { ok: true, message: `Would run: ${cmd.display}` };
+                const code = spawnTTY(cmd.cmd, cmd.args);
+                return code === 0
+                    ? { ok: true, message: "Claude Code CLI installed" }
+                    : { ok: false, message: `Install failed — run manually: ${cmd.display}` };
+            },
+        });
+    }
+    // ── tmux (multiplexer) ──────────────────────────────────────────────────────
+    {
+        const active = getMultiplexer().kind !== "none";
+        const detect = active ? "ok" : installer ? "actionable" : "unavailable";
+        steps.push({
+            id: "tmux",
+            title: "tmux (terminal multiplexer)",
+            detail: "Enables new-window flows: work / fix / review / investigate",
+            scope: "global",
+            kind: "spawn",
+            recommended: false,
+            detect,
+            apply: () => {
+                if (!installer)
+                    return { ok: false, message: "Install tmux manually: brew install tmux" };
+                if (dryRun)
+                    return { ok: true, message: `Would ${installer.installArgv("tmux").join(" ")}` };
+                const argv = installer.installArgv("tmux");
+                const code = spawnTTY(argv[0], argv.slice(1));
+                return code === 0
+                    ? { ok: true, message: "tmux installed (start a tmux session to use new-window flows)" }
+                    : { ok: false, message: "tmux install failed" };
+            },
+        });
+    }
+    // ── Repo-scoped steps ───────────────────────────────────────────────────────
+    if (repoRoot) {
+        const santreeDir = getSantreeDir(repoRoot);
+        const initSh = getInitScriptPath(repoRoot);
+        // .santree scaffold
+        {
+            const folderOk = fs.existsSync(santreeDir);
+            const initOk = fs.existsSync(initSh);
+            let execOk = false;
+            if (initOk) {
+                try {
+                    fs.accessSync(initSh, fs.constants.X_OK);
+                    execOk = true;
+                }
+                catch { }
+            }
+            steps.push({
+                id: "scaffold",
+                title: ".santree scaffold",
+                detail: "Create .santree/ and an executable init.sh (runs on worktree create)",
+                scope: "repo",
+                kind: "file",
+                recommended: true,
+                detect: folderOk && initOk && execOk ? "ok" : "actionable",
+                apply: () => {
+                    if (dryRun)
+                        return { ok: true, message: `Would create ${santreeDir} and an executable init.sh` };
+                    fs.mkdirSync(santreeDir, { recursive: true });
+                    if (!fs.existsSync(initSh)) {
+                        fs.writeFileSync(initSh, "#!/usr/bin/env bash\n# Runs after `santree worktree create`. Add setup steps here.\n");
+                    }
+                    fs.chmodSync(initSh, 0o755);
+                    return { ok: true, message: `Scaffolded ${santreeDir}` };
+                },
+            });
+        }
+        // Ignore santree files
+        {
+            const missing = missingIgnoreEntries(repoRoot);
+            steps.push({
+                id: "gitignore",
+                title: "Ignore santree's machine files",
+                detail: `Ignore ${SANTREE_IGNORE_ENTRIES.join(", ")} (keeps .santree/issues/ tracked)`,
+                scope: "repo",
+                kind: "file",
+                recommended: true,
+                detect: missing.length === 0 ? "ok" : "actionable",
+                options: [
+                    { value: "gitignore", label: ".gitignore — shared with your team" },
+                    { value: "exclude", label: ".git/info/exclude — local to your clone" },
+                ],
+                optionPrompt: "Where should the ignore rules go?",
+                apply: (choice) => {
+                    const target = (choice === "exclude" ? "exclude" : "gitignore");
+                    const where = target === "exclude" ? ".git/info/exclude" : ".gitignore";
+                    if (dryRun)
+                        return {
+                            ok: true,
+                            message: `Would add ${missing.length} entr${missing.length === 1 ? "y" : "ies"} to ${where}`,
+                        };
+                    const added = addIgnoreEntries(repoRoot, target);
+                    return {
+                        ok: true,
+                        message: `Added ${added.length} entr${added.length === 1 ? "y" : "ies"} to ${where}`,
+                    };
+                },
+            });
+        }
+        // Issue tracker
+        {
+            steps.push({
+                id: "tracker",
+                title: "Issue tracker",
+                detail: "Pick + authenticate Linear / GitHub / Local for this repo",
+                scope: "repo",
+                kind: "spawn",
+                recommended: true,
+                detect: isRepoTrackerConfigured(repoRoot) ? "ok" : "actionable",
+                apply: () => {
+                    if (dryRun)
+                        return { ok: true, message: "Would run: santree issue setup" };
+                    const { cmd, args } = santreeSelfArgv(["issue", "setup"]);
+                    const code = spawnTTY(cmd, args, { cwd: repoRoot });
+                    return code === 0
+                        ? { ok: true, message: "Issue tracker configured" }
+                        : { ok: false, message: "Tracker setup did not complete" };
+                },
+            });
+        }
+    }
+    return steps;
+}

package/dist/lib/setup/tools.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Tool detection + installation for `santree setup`.
+ *
+ * macOS (Homebrew) is the only auto-install path today. The `PlatformInstaller`
+ * seam keeps the door open for apt/dnf/etc. without touching call sites — add a
+ * resolver branch in `getInstaller()` and the steps keep working.
+ */
+export declare function isMacOS(): boolean;
+/** Resolve a command on PATH, or null if absent. */
+export declare function which(cmd: string): string | null;
+export interface DetectedTool {
+    command: string;
+    path: string;
+}
+export declare function detectDiffPagers(): DetectedTool[];
+export declare function detectEditors(): DetectedTool[];
+export interface PlatformInstaller {
+    /** Human label, e.g. "Homebrew". */
+    name: string;
+    /** argv for installing `pkg` (cmd + args), suitable for a TTY spawn. */
+    installArgv(pkg: string): string[];
+}
+export declare function getInstaller(): PlatformInstaller | null;

package/dist/lib/setup/tools.js

@@ -0,0 +1,47 @@
+import * as os from "os";
+import { run } from "../exec.js";
+/**
+ * Tool detection + installation for `santree setup`.
+ *
+ * macOS (Homebrew) is the only auto-install path today. The `PlatformInstaller`
+ * seam keeps the door open for apt/dnf/etc. without touching call sites — add a
+ * resolver branch in `getInstaller()` and the steps keep working.
+ */
+export function isMacOS() {
+    return os.platform() === "darwin";
+}
+/** Resolve a command on PATH, or null if absent. */
+export function which(cmd) {
+    return run(`which ${cmd}`);
+}
+/** Known unified-diff pagers, best first. The first one on PATH wins. */
+const DIFF_PAGERS = ["delta", "diff-so-fancy", "diff-highlight", "ydiff", "riff"];
+export function detectDiffPagers() {
+    const found = [];
+    for (const cmd of DIFF_PAGERS) {
+        const p = which(cmd);
+        if (p)
+            found.push({ command: cmd, path: p });
+    }
+    return found;
+}
+/** Editors we know how to launch, in rough order of popularity. */
+const KNOWN_EDITORS = ["code", "cursor", "zed", "subl", "windsurf", "nvim", "vim", "nano", "emacs"];
+export function detectEditors() {
+    const found = [];
+    for (const cmd of KNOWN_EDITORS) {
+        const p = which(cmd);
+        if (p)
+            found.push({ command: cmd, path: p });
+    }
+    return found;
+}
+export function getInstaller() {
+    if (isMacOS() && which("brew")) {
+        return {
+            name: "Homebrew",
+            installArgv: (pkg) => ["brew", "install", pkg],
+        };
+    }
+    return null;
+}

package/dist/lib/squirrel-loader.d.ts

@@ -1,9 +1,11 @@
 interface Props {
     text?: string;
+    /** Optional version line (e.g. santree's running version), shown under `text`. */
+    version?: string;
 }
 /** Animated 3D squirrel for loading states. SDF ray-marched at module
  * load with surface-normal lighting, soft shadows, AO, and a rainbow
  * Y-gradient. Body spin + tail wag + breathing/sniff/ear-flick layers
  * combine over independent phases. */
-export default function SquirrelLoader({ text }: Props): import("react/jsx-runtime").JSX.Element;
+export default function SquirrelLoader({ text, version }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/lib/squirrel-loader.js

@@ -292,7 +292,7 @@ function colorForCell(y, lit) {
  * load with surface-normal lighting, soft shadows, AO, and a rainbow
  * Y-gradient. Body spin + tail wag + breathing/sniff/ear-flick layers
  * combine over independent phases. */
-export default function SquirrelLoader({ text }) {
+export default function SquirrelLoader({ text, version }) {
     const [frame, setFrame] = useState(0);
     useEffect(() => {
         const id = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), FRAME_MS);
@@ -318,5 +318,5 @@ export default function SquirrelLoader({ text }) {
             return spans;
         });
     }, [frame]);
-    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [rows.map((spans, i) => (_jsx(Box, { children: _jsx(Text, { children: spans.map((s, j) => (_jsx(Text, { color: s.color, children: s.text }, j))) }) }, i))), text && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: text }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [rows.map((spans, i) => (_jsx(Box, { children: _jsx(Text, { children: spans.map((s, j) => (_jsx(Text, { color: s.color, children: s.text }, j))) }) }, i))), text && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: text }) })), version && (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["v", version] }) }))] }));
 }

package/dist/lib/triage-config.d.ts

@@ -0,0 +1,21 @@
+/** Per-repo "investigate triage ticket" config, read from
+ * `.santree/metadata.json` (`_triage.skill_name` / `_triage.prompt`).
+ * metadata.json is gitignored, so this is per-machine — each dev points it at
+ * their own skill or prompt without committing it. */
+export interface TriageInvestigateConfig {
+    /** A Claude slash-command/skill name. Invoked as `/<skill_name> <ticketId>`. */
+    skillName: string | null;
+    /** A free-form prompt template; `{ticket_id}` is substituted with the ticket. */
+    prompt: string | null;
+}
+export declare function readTriageInvestigateConfig(repoRoot: string): TriageInvestigateConfig;
+export declare function isTriageInvestigateConfigured(cfg: TriageInvestigateConfig): boolean;
+/** Builds the prompt handed to Claude for investigating a ticket. Skill name
+ * wins when both are set: `/<skill> <ticketId>`. Otherwise the free-form
+ * template with every `{ticket_id}` replaced. Returns null when unconfigured. */
+export declare function buildInvestigatePrompt(cfg: TriageInvestigateConfig, ticketId: string): string | null;
+/** Builds the shell command line launched in the new multiplexer window:
+ * `<claudeBin> '<prompt>'`. The multiplexer escapes the whole line again for
+ * its send-keys step; this layer just needs the prompt to survive as a single
+ * argv entry so a slash command (`/skill TEAM-1`) reaches Claude intact. */
+export declare function buildInvestigateCommand(claudeBin: string, prompt: string): string;

package/dist/lib/triage-config.js

@@ -0,0 +1,32 @@
+import { readAllMetadata } from "./metadata.js";
+export function readTriageInvestigateConfig(repoRoot) {
+    const all = readAllMetadata(repoRoot);
+    const t = all["_triage"];
+    const skillName = typeof t?.skill_name === "string" && t.skill_name.trim() ? t.skill_name.trim() : null;
+    const prompt = typeof t?.prompt === "string" && t.prompt.trim() ? t.prompt.trim() : null;
+    return { skillName, prompt };
+}
+export function isTriageInvestigateConfigured(cfg) {
+    return cfg.skillName !== null || cfg.prompt !== null;
+}
+/** Builds the prompt handed to Claude for investigating a ticket. Skill name
+ * wins when both are set: `/<skill> <ticketId>`. Otherwise the free-form
+ * template with every `{ticket_id}` replaced. Returns null when unconfigured. */
+export function buildInvestigatePrompt(cfg, ticketId) {
+    if (cfg.skillName)
+        return `/${cfg.skillName} ${ticketId}`;
+    if (cfg.prompt)
+        return cfg.prompt.replace(/\{ticket_id\}/g, ticketId);
+    return null;
+}
+/** POSIX single-quote a shell argument. */
+function shellSingleQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/** Builds the shell command line launched in the new multiplexer window:
+ * `<claudeBin> '<prompt>'`. The multiplexer escapes the whole line again for
+ * its send-keys step; this layer just needs the prompt to survive as a single
+ * argv entry so a slash command (`/skill TEAM-1`) reaches Claude intact. */
+export function buildInvestigateCommand(claudeBin, prompt) {
+    return `${claudeBin} ${shellSingleQuote(prompt)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "santree",
-	"version": "0.7.3",
+	"version": "0.7.5",
 	"description": "Git worktree manager",
 	"license": "MIT",
 	"author": "Santiago Toscanini",
@@ -40,7 +40,6 @@
 	},
 	"files": [
 		"dist",
-		"shell",
 		"prompts"
 	],
 	"dependencies": {