santree 0.7.4 → 0.7.6

package/dist/commands/pr/context.js

@@ -0,0 +1,36 @@
+import { useEffect, useRef } from "react";
+import { resolveAIContext, fetchAndRenderFixContext } from "../../lib/ai.js";
+import { santreeSelfArgv } from "../../lib/setup/apply.js";
+export const description = "Print the fix-loop iteration brief (state + the exact actions to take)";
+/**
+ * Read-only command the auto-fix `/loop` runs each iteration to refresh state.
+ * No Ink UI — it writes the rendered brief straight to stdout and exits (same
+ * pattern as the statusline helper) so the agent can read it cleanly.
+ */
+export default function PRContext() {
+    const hasRun = useRef(false);
+    useEffect(() => {
+        if (hasRun.current)
+            return;
+        hasRun.current = true;
+        (async () => {
+            const result = await resolveAIContext();
+            if (!result.ok) {
+                process.stderr.write(result.error + "\n");
+                process.exit(1);
+            }
+            // Embed the absolute santree invocation so the brief's own `--signal` /
+            // resolve commands work in a shell that may not have santree on PATH.
+            const self = santreeSelfArgv([]);
+            const santreeCmd = [self.cmd, ...self.args].join(" ");
+            const md = await fetchAndRenderFixContext(result.context.branch, santreeCmd);
+            if (!md) {
+                process.stderr.write(`No pull request found for branch '${result.context.branch}'\n`);
+                process.exit(1);
+            }
+            process.stdout.write(md.trimEnd() + "\n");
+            process.exit(0);
+        })();
+    }, []);
+    return null;
+}

package/dist/commands/pr/fix.d.ts

@@ -1,2 +1,11 @@
-export declare const description = "Fix PR review comments";
-export default function Fix(): import("react/jsx-runtime").JSX.Element;
+import { z } from "zod";
+export declare const description = "Run the self-driving fix loop: merge conflicts, fixable CI, and \uD83D\uDC4D-approved review comments";
+export declare const options: z.ZodObject<{
+    loop: z.ZodDefault<z.ZodBoolean>;
+    signal: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Fix({ options: opts }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/pr/fix.js

@@ -1,15 +1,53 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import { Text, Box } from "ink";
 import Spinner from "ink-spinner";
-import { resolveAIContext, renderAIPrompt, launchAgent, cleanupImages, fetchAndRenderPR, fetchAndRenderDiff, } from "../../lib/ai.js";
-export const description = "Fix PR review comments";
-export default function Fix() {
-    const [status, setStatus] = useState("loading");
+import { z } from "zod";
+import { resolveAIContext, renderAIPrompt, launchAgent, cleanupImages } from "../../lib/ai.js";
+import { findMainRepoRoot, getCurrentBranch, extractTicketId } from "../../lib/git.js";
+import { getPRInfoAsync } from "../../lib/github.js";
+import { santreeSelfArgv } from "../../lib/setup/apply.js";
+import { startFixLoop, signalFixLoop } from "../../lib/fix-loop.js";
+export const description = "Run the self-driving fix loop: merge conflicts, fixable CI, and 👍-approved review comments";
+export const options = z.object({
+    // Accepted for backward compatibility (the dashboard passes it). The fix loop
+    // is now the only flow, so this is always on.
+    loop: z.boolean().default(true).describe("Deprecated: the fix loop is always on"),
+    signal: z
+        .string()
+        .optional()
+        .describe("Internal: update this ticket's fix-loop dashboard marker, then exit"),
+});
+const KNOWN_STATUSES = new Set([
+    "running",
+    "merging",
+    "fixing",
+    "waiting-ci",
+    "stopped:clean",
+    "stopped:stuck",
+]);
+export default function Fix({ options: opts }) {
+    // --signal is a quiet internal marker update — start in its own phase so the
+    // full "Fix PR" UI never flashes before the process exits.
+    const [status, setStatus] = useState(opts.signal !== undefined ? "signaled" : "loading");
     const [branch, setBranch] = useState(null);
     const [ticketId, setTicketId] = useState(null);
     const [error, setError] = useState(null);
     useEffect(() => {
+        // --signal: lightweight marker update invoked by the loop body. Resolve
+        // repo/ticket offline (no tracker fetch) and exit fast.
+        if (opts.signal !== undefined) {
+            const mainRoot = findMainRepoRoot();
+            const br = getCurrentBranch();
+            const tid = br ? extractTicketId(br) : null;
+            if (mainRoot && tid) {
+                const s = (KNOWN_STATUSES.has(opts.signal) ? opts.signal : "running");
+                signalFixLoop(mainRoot, tid, s);
+            }
+            setStatus("signaled");
+            setTimeout(() => process.exit(0), 20);
+            return;
+        }
         async function init() {
             await new Promise((r) => setTimeout(r, 100));
             setStatus("fetching");
@@ -22,18 +60,29 @@ export default function Fix() {
             const ctx = result.context;
             setBranch(ctx.branch);
             setTicketId(ctx.ticketId);
-            const prFeedback = await fetchAndRenderPR(ctx.branch);
-            if (!prFeedback) {
+            const prInfo = await getPRInfoAsync(ctx.branch);
+            if (!prInfo) {
                 setStatus("error");
                 setError(`No pull request found for branch '${ctx.branch}'`);
                 return;
             }
-            const diffContent = await fetchAndRenderDiff(ctx.branch);
             setStatus("launching");
-            const prompt = renderAIPrompt("fix-pr", ctx, {
-                pr_feedback: prFeedback,
-                diff_content: diffContent,
+            // The loop refreshes its own context each iteration via `pr context`,
+            // so we only build the standing instructions here. Use an absolute
+            // santree invocation (the new window's shell may not have it on PATH).
+            const self = santreeSelfArgv([]);
+            const santreeCmd = [self.cmd, ...self.args].join(" ");
+            const body = renderAIPrompt("fix-loop", ctx, {
+                branch: ctx.branch,
+                santree_cmd: santreeCmd,
             });
+            // No interval → `/loop` self-paces via ScheduleWakeup (keeps context
+            // across iterations and can genuinely stop on our conditions). Passing
+            // an interval (`/loop 5m …`) instead picks cron mode — fresh context
+            // each firing, can't self-terminate — which is wrong for a fix loop.
+            const prompt = `/loop ${body}`;
+            if (ctx.ticketId)
+                startFixLoop(ctx.mainRoot, ctx.ticketId, 5);
             try {
                 const child = launchAgent(prompt);
                 child.on("error", (err) => {
@@ -54,5 +103,8 @@ export default function Fix() {
         }
         init();
     }, []);
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Fix PR" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : "magenta", 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 })] })), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "mode:" }), _jsx(Text, { backgroundColor: "magenta", color: "white", bold: true, children: " fix PR " })] })] }), _jsxs(Box, { marginTop: 1, children: [(status === "loading" || status === "fetching") && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", status === "loading" ? "Loading..." : "Fetching ticket and PR feedback..."] })] })), status === "launching" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", bold: true, children: "\u2713 Launching Claude..." }), _jsxs(Text, { dimColor: true, children: [" claude ", `"<fix-pr prompt for ${ticketId}>"`] })] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }))] })] }));
+    if (status === "signaled") {
+        return _jsxs(Text, { dimColor: true, children: ["fix-loop signal: ", opts.signal] });
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Fix PR \u2014 loop" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : "magenta", 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 })] })), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "mode:" }), _jsx(Text, { backgroundColor: "magenta", color: "white", bold: true, children: " fix loop " })] })] }), _jsxs(Box, { marginTop: 1, children: [(status === "loading" || status === "fetching") && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", status === "loading" ? "Loading..." : "Fetching ticket and PR feedback..."] })] })), status === "launching" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", bold: true, children: "\u2713 Launching Claude (looping every 5 min)..." }), _jsx(Text, { dimColor: true, children: ` claude "/loop <fix-loop for ${ticketId}>"` })] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }))] })] }));
 }

package/dist/commands/worktree/create.js

@@ -6,6 +6,7 @@ import { z } from "zod";
 import * as fs from "fs";
 import { createWorktree, findMainRepoRoot, getDefaultBranch, pullLatest, hasInitScript, getInitScriptPath, extractTicketId, } from "../../lib/git.js";
 import { spawnAsync } from "../../lib/exec.js";
+import { formatCdCommand } from "../../lib/cd-hint.js";
 import { getMultiplexer } from "../../lib/multiplexer/index.js";
 export const description = "Create a new worktree from a branch";
 export const options = z.object({
@@ -36,6 +37,7 @@ export default function Create({ options, args }) {
     const [worktreePath, setWorktreePath] = useState("");
     const [baseBranch, setBaseBranch] = useState(null);
     const [muxWindowName, setMuxWindowName] = useState(null);
+    const [cdHint, setCdHint] = useState(null);
     async function finalize(path, branch) {
         const wantsWindow = options.window || options.tmux;
         if (wantsWindow) {
@@ -43,7 +45,7 @@ export default function Create({ options, args }) {
             if (!mux.isActive()) {
                 setMessage("Worktree created, but no active multiplexer");
                 setStatus("done");
-                console.log(`SANTREE_CD:${path}`);
+                setCdHint(formatCdCommand({ path }));
                 return;
             }
             setStatus("spawning-window");
@@ -52,28 +54,32 @@ export default function Create({ options, args }) {
             setMuxWindowName(windowName);
             let runCommand;
             if (options.work) {
-                runCommand = options.plan ? "st worktree work --plan" : "st worktree work";
+                runCommand = options.plan ? "santree worktree work --plan" : "santree worktree work";
             }
-            const result = await mux.createWindow({ name: windowName, cwd: path, command: runCommand });
+            const result = await mux.createWindow({
+                name: windowName,
+                cwd: path,
+                command: runCommand,
+                tabName: runCommand ? "work" : undefined,
+            });
             if (!result.ok) {
                 setMessage(`Worktree created, but failed to create window${result.message ? `: ${result.message}` : ""}`);
                 setStatus("done");
-                console.log(`SANTREE_CD:${path}`);
+                setCdHint(formatCdCommand({ path }));
                 return;
             }
             setStatus("done");
             const workInfo = options.work ? (options.plan ? " + Claude (plan)" : " + Claude") : "";
             setMessage(`Worktree and window created!${workInfo}`);
-            // Don't output SANTREE_CD when a window is created — user is already in the new window
+            // No cd hint when a window is created — the user is already in the new window
             return;
         }
         setStatus("done");
         setMessage("Worktree created successfully!");
-        console.log(`SANTREE_CD:${path}`);
-        if (options.work) {
-            const mode = options.plan ? "plan" : "implement";
-            console.log(`SANTREE_WORK:${mode}`);
-        }
+        setCdHint(formatCdCommand({
+            path,
+            work: options.work ? { mode: options.plan ? "plan" : "implement" } : undefined,
+        }));
     }
     useEffect(() => {
         async function run() {
@@ -159,5 +165,5 @@ export default function Create({ options, args }) {
         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: [" window: ", muxWindowName] })] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
+    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: [" window: ", muxWindowName] }), cdHint && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "\u2192 Run this to enter the worktree:" }), _jsxs(Text, { color: "cyan", children: [" ", cdHint] })] }))] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
 }

package/dist/commands/worktree/open.js

@@ -3,6 +3,7 @@ import { useEffect, useState } from "react";
 import { Text, Box } from "ink";
 import { z } from "zod";
 import { findMainRepoRoot } from "../../lib/git.js";
+import { getConfiguredEditor } from "../../lib/config-store.js";
 import { execSync, spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
@@ -38,8 +39,8 @@ export default function Open({ options: opts }) {
             });
             return;
         }
-        // Resolve editor: --editor flag > SANTREE_EDITOR env > "code" default
-        const editor = opts.editor || process.env.SANTREE_EDITOR || "code";
+        // Resolve editor: --editor flag > santree config editor (or SANTREE_EDITOR) > "code"
+        const editor = opts.editor || getConfiguredEditor() || "code";
         // Validate editor exists in PATH
         try {
             execSync(`which ${editor}`, { stdio: "ignore" });

package/dist/commands/worktree/switch.js

@@ -1,23 +1,15 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useRef } from "react";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Text, Box } from "ink";
 import { z } from "zod";
 import { getWorktreePath } from "../../lib/git.js";
+import { formatCdCommand } from "../../lib/cd-hint.js";
 export const description = "Switch to another worktree";
 export const args = z.tuple([z.string().describe("Branch name to switch to")]);
 export default function Switch({ args }) {
     const [branchName] = args;
-    const hasOutputRef = useRef(false);
     // Find worktree path synchronously
     const worktreePath = getWorktreePath(branchName);
-    // Output SANTREE_CD once (before Ink fully renders)
-    useEffect(() => {
-        if (worktreePath && !hasOutputRef.current) {
-            hasOutputRef.current = true;
-            process.stdout.write(`SANTREE_CD:${worktreePath}\n`);
-        }
-    }, [worktreePath]);
     const status = worktreePath ? "done" : "error";
     const error = worktreePath ? null : `Worktree not found for branch: ${branchName}`;
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83D\uDD00 Switch" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : "green", paddingX: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branchName })] }), worktreePath && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "path:" }), _jsx(Text, { dimColor: true, children: worktreePath })] }))] }), _jsxs(Box, { marginTop: 1, children: [status === "done" && (_jsx(Text, { color: "green", bold: true, children: "\u2713 Switching to worktree" })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }))] })] }));
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83D\uDD00 Switch" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : "green", paddingX: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branchName })] }), worktreePath && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "path:" }), _jsx(Text, { dimColor: true, children: worktreePath })] }))] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [status === "done" && worktreePath && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "\u2192 Run this to enter the worktree:" }), _jsxs(Text, { color: "cyan", children: [" ", formatCdCommand({ path: worktreePath })] })] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }))] })] }));
 }

package/dist/lib/ai.d.ts

@@ -33,6 +33,17 @@ export declare function renderAIPrompt(template: string, ctx: AIContext, extra?:
  * Returns rendered markdown or null if no PR exists.
  */
 export declare function fetchAndRenderPR(branch: string): Promise<string | null>;
+/**
+ * Fetch and render the self-contained per-iteration brief the auto-fix loop
+ * consumes — state AND the exact actions to take this iteration. It covers
+ * conflict status vs. the base branch, failing checks tagged fixable/manual
+ * (logs only for the fixable ones, to keep it tight), the 👍-approved review
+ * threads, and a single computed `directive` telling the loop what to do (merge
+ * / work / wait / stop). The loop just runs this and obeys. `santreeCmd` is the
+ * absolute santree invocation embedded in the `--signal` / resolve commands.
+ * Returns null when no PR exists for the branch.
+ */
+export declare function fetchAndRenderFixContext(branch: string, santreeCmd: string): Promise<string | null>;
 /**
  * Fetch and render diff for a branch against its base branch (async, non-blocking).
  * Returns rendered markdown.

package/dist/lib/ai.js

@@ -3,9 +3,9 @@ import { existsSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir, tmpdir } from "os";
 import { getCurrentBranch, findRepoRoot, findMainRepoRoot, getBaseBranch } from "./git.js";
-import { renderPrompt, renderTicket, renderDiff, renderPR } from "./prompts.js";
+import { renderPrompt, renderTicket, renderDiff, renderPR, renderFixContext, } from "./prompts.js";
 import { getIssueTracker } from "./trackers/index.js";
-import { getPRInfoAsync, getPRChecksAsync, getPRReviewsAsync, getPRReviewCommentsAsync, getPRConversationCommentsAsync, getFailedCheckDetailsAsync, } from "./github.js";
+import { getPRInfoAsync, getPRChecksAsync, getPRReviewsAsync, getPRReviewCommentsAsync, getPRReviewThreadsAsync, getApprovedReviewThreads, getViewerLoginAsync, getPRConversationCommentsAsync, getFailedCheckDetailsAsync, getPRMergeStateAsync, classifyCheck, } from "./github.js";
 import { runAsync } from "./exec.js";
 /**
  * Resolves repo, branch, issue identifier, and fetches the issue from the
@@ -96,6 +96,75 @@ export async function fetchAndRenderPR(branch) {
         conversation_comments: conversationComments,
     });
 }
+/**
+ * Fetch and render the self-contained per-iteration brief the auto-fix loop
+ * consumes — state AND the exact actions to take this iteration. It covers
+ * conflict status vs. the base branch, failing checks tagged fixable/manual
+ * (logs only for the fixable ones, to keep it tight), the 👍-approved review
+ * threads, and a single computed `directive` telling the loop what to do (merge
+ * / work / wait / stop). The loop just runs this and obeys. `santreeCmd` is the
+ * absolute santree invocation embedded in the `--signal` / resolve commands.
+ * Returns null when no PR exists for the branch.
+ */
+export async function fetchAndRenderFixContext(branch, santreeCmd) {
+    const prInfo = await getPRInfoAsync(branch);
+    if (!prInfo)
+        return null;
+    const baseBranch = getBaseBranch(branch);
+    const [checks, reviews, threads, mergeState, viewer] = await Promise.all([
+        getPRChecksAsync(prInfo.number),
+        getPRReviewsAsync(prInfo.number),
+        getPRReviewThreadsAsync(prInfo.number),
+        getPRMergeStateAsync(branch),
+        getViewerLoginAsync(),
+    ]);
+    const failing = (checks ?? []).filter((c) => c.bucket === "fail");
+    const failedDetails = await Promise.all(failing.map((c) => getFailedCheckDetailsAsync(c)));
+    const failed_checks = failedDetails.map((d) => ({
+        ...d,
+        fixable: classifyCheck(d) === "fixable",
+    }));
+    const fixable_count = failed_checks.filter((c) => c.fixable).length;
+    const manual_count = failed_checks.filter((c) => !c.fixable).length;
+    // Only genuinely-queued/running checks count as pending — `skipping`/`cancel`
+    // won't run under the current conditions, so the loop must not wait on them.
+    const pending_count = (checks ?? []).filter((c) => c.bucket === "pending").length;
+    // Only surface review comments the viewer has 👍-approved on an unresolved
+    // thread — resolved threads are skipped, and unapproved ones wait for approval.
+    const approved_comments = viewer && threads ? getApprovedReviewThreads(threads, viewer) : [];
+    const conflicts = mergeState?.hasConflicts ?? false;
+    const mergeable = mergeState?.mergeable ?? "UNKNOWN";
+    // The single recommended action, in priority order. Conflicts block CI, so
+    // resolve them first; otherwise do any fixable work; otherwise wait for CI (or
+    // for GitHub to finish computing mergeability) rather than declaring done;
+    // otherwise stop — stuck if only manual failures remain, else clean.
+    const directive = conflicts
+        ? "merge"
+        : fixable_count > 0 || approved_comments.length > 0
+            ? "work"
+            : pending_count > 0 || mergeable === "UNKNOWN"
+                ? "wait"
+                : manual_count > 0
+                    ? "stop-stuck"
+                    : "stop-clean";
+    return renderFixContext({
+        pr_number: prInfo.number,
+        pr_url: prInfo.url ?? "",
+        branch,
+        base_branch: baseBranch,
+        conflicts,
+        mergeable,
+        merge_state: mergeState?.mergeStateStatus ?? "UNKNOWN",
+        failed_checks,
+        fixable_count,
+        manual_count,
+        pending_count,
+        reviews,
+        approved_comments,
+        directive,
+        santree_cmd: santreeCmd,
+    });
+}
 /**
  * Fetch and render diff for a branch against its base branch (async, non-blocking).
  * Returns rendered markdown.

package/dist/lib/cd-hint.d.ts

@@ -0,0 +1,18 @@
+/**
+ * santree is a plain binary — a child process can't change its parent shell's
+ * working directory. So when a command wants you to land in a worktree, it
+ * prints the command for you to run. (Dashboard flows with tmux/cmux open a new
+ * window in the right directory instead and never need this.)
+ */
+export interface CdHint {
+    path: string;
+    /** Append a `worktree work` launch after the cd. */
+    work?: {
+        mode: "plan" | "implement" | string;
+        contextFile?: string;
+    };
+}
+/** The shell command to enter a worktree (and optionally start work). */
+export declare function formatCdCommand(hint: CdHint): string;
+/** Print the cd hint to stdout (for non-Ink contexts, e.g. after the dashboard exits). */
+export declare function printCdHint(hint: CdHint): void;

package/dist/lib/cd-hint.js

@@ -0,0 +1,27 @@
+/**
+ * santree is a plain binary — a child process can't change its parent shell's
+ * working directory. So when a command wants you to land in a worktree, it
+ * prints the command for you to run. (Dashboard flows with tmux/cmux open a new
+ * window in the right directory instead and never need this.)
+ */
+/** Single-quote a value for safe copy-paste into a POSIX shell. */
+function sq(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/** The shell command to enter a worktree (and optionally start work). */
+export function formatCdCommand(hint) {
+    let cmd = `cd ${sq(hint.path)}`;
+    if (hint.work) {
+        let work = "santree worktree work";
+        if (hint.work.mode === "plan")
+            work += " --plan";
+        if (hint.work.contextFile)
+            work += ` --context-file ${sq(hint.work.contextFile)}`;
+        cmd += ` && ${work}`;
+    }
+    return cmd;
+}
+/** Print the cd hint to stdout (for non-Ink contexts, e.g. after the dashboard exits). */
+export function printCdHint(hint) {
+    console.log(`\n→ Run this to enter the worktree:\n  ${formatCdCommand(hint)}`);
+}

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

@@ -0,0 +1,26 @@
+export declare function claudeSettingsPath(): string;
+export declare function claudeConfigPath(): string;
+export declare function readJsonSafe(filePath: string): Record<string, any>;
+export declare function getStatuslineCommand(): string | undefined;
+export declare function isStatuslineConfigured(): boolean;
+export declare function configureStatusline(): string;
+/**
+ * Remove santree's statusline. Only clears `statusLine` when it's actually
+ * pointing at santree — a user's hand-rolled statusline is left untouched.
+ */
+export declare function removeStatusline(): string;
+export declare function isRemoteControlEnabled(): boolean;
+export declare function enableRemoteControl(): string;
+/** Revert remote-control to the default (off) by dropping the opt-in flag. */
+export declare function disableRemoteControl(): string;
+/**
+ * Strip any leftover session-signal hook entries from settings.json. The
+ * session-state feature (and its `santree helpers session-signal` command) was
+ * removed, so these hooks now invoke a command that no longer exists and fire
+ * on every Claude event. Removing them is always safe: we only touch entries
+ * whose command mentions `session-signal`, leaving every other hook on the
+ * shared events untouched. Returns the number of hook entries removed so
+ * callers can report it. Self-healing: running `santree config` once cleans up
+ * an existing install.
+ */
+export declare function pruneSessionSignalHooks(): number;

package/dist/lib/claude-config.js

@@ -0,0 +1,121 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Shared read/detect/configure helpers for the two Claude Code config files
+ * santree touches:
+ *   - ~/.claude/settings.json   (statusline + hooks)
+ *   - ~/.claude.json            (remote control)
+ *
+ * `santree config` (both the `--check` report and the interactive panel) goes
+ * through here so detection and configuration can never disagree about what
+ * "configured" means.
+ */
+const STATUSLINE_COMMAND = "santree helpers statusline";
+export function claudeSettingsPath() {
+    return path.join(process.env.HOME || "", ".claude", "settings.json");
+}
+export function claudeConfigPath() {
+    return path.join(process.env.HOME || "", ".claude.json");
+}
+export function readJsonSafe(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        }
+    }
+    catch {
+        // Invalid/unreadable — caller decides whether to start fresh.
+    }
+    return {};
+}
+function writeJson(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+// ── Statusline ───────────────────────────────────────────────────────────────
+export function getStatuslineCommand() {
+    const settings = readJsonSafe(claudeSettingsPath());
+    const cmd = settings.statusLine?.command;
+    return cmd ? String(cmd) : undefined;
+}
+export function isStatuslineConfigured() {
+    const cmd = getStatuslineCommand();
+    return (!!cmd && (cmd.includes("santree statusline") || cmd.includes("santree helpers statusline")));
+}
+export function configureStatusline() {
+    const settingsPath = claudeSettingsPath();
+    const settings = readJsonSafe(settingsPath);
+    settings.statusLine = { type: "command", command: STATUSLINE_COMMAND };
+    writeJson(settingsPath, settings);
+    return settingsPath;
+}
+/**
+ * Remove santree's statusline. Only clears `statusLine` when it's actually
+ * pointing at santree — a user's hand-rolled statusline is left untouched.
+ */
+export function removeStatusline() {
+    const settingsPath = claudeSettingsPath();
+    if (!isStatuslineConfigured())
+        return settingsPath;
+    const settings = readJsonSafe(settingsPath);
+    delete settings.statusLine;
+    writeJson(settingsPath, settings);
+    return settingsPath;
+}
+// ── Remote control ────────────────────────────────────────────────────────────
+export function isRemoteControlEnabled() {
+    return readJsonSafe(claudeConfigPath()).remoteControlAtStartup === true;
+}
+export function enableRemoteControl() {
+    const configPath = claudeConfigPath();
+    const config = readJsonSafe(configPath);
+    config.remoteControlAtStartup = true;
+    writeJson(configPath, config);
+    return configPath;
+}
+/** Revert remote-control to the default (off) by dropping the opt-in flag. */
+export function disableRemoteControl() {
+    const configPath = claudeConfigPath();
+    const config = readJsonSafe(configPath);
+    delete config.remoteControlAtStartup;
+    writeJson(configPath, config);
+    return configPath;
+}
+// ── Legacy cleanup ────────────────────────────────────────────────────────────
+/**
+ * Strip any leftover session-signal hook entries from settings.json. The
+ * session-state feature (and its `santree helpers session-signal` command) was
+ * removed, so these hooks now invoke a command that no longer exists and fire
+ * on every Claude event. Removing them is always safe: we only touch entries
+ * whose command mentions `session-signal`, leaving every other hook on the
+ * shared events untouched. Returns the number of hook entries removed so
+ * callers can report it. Self-healing: running `santree config` once cleans up
+ * an existing install.
+ */
+export function pruneSessionSignalHooks() {
+    const settingsPath = claudeSettingsPath();
+    const settings = readJsonSafe(settingsPath);
+    const hooks = settings.hooks;
+    if (!hooks || typeof hooks !== "object")
+        return 0;
+    let removed = 0;
+    for (const event of Object.keys(hooks)) {
+        const arr = hooks[event];
+        if (!Array.isArray(arr))
+            continue;
+        const kept = arr.filter((entry) => {
+            const inner = Array.isArray(entry.hooks) ? entry.hooks : [];
+            const isSignal = inner.some((h) => typeof h.command === "string" && h.command.includes("session-signal"));
+            if (isSignal)
+                removed++;
+            return !isSignal;
+        });
+        if (kept.length === 0)
+            delete hooks[event];
+        else
+            hooks[event] = kept;
+    }
+    if (removed > 0)
+        writeJson(settingsPath, settings);
+    return removed;
+}

package/dist/lib/config/TrackerPicker.d.ts

@@ -0,0 +1,10 @@
+import type { IssueTrackerKind } from "../trackers/types.js";
+interface Props {
+    repoRoot: string;
+    activeKind: IssueTrackerKind | null;
+    activeOrg: string | null;
+    onApplied: (message: string) => void;
+    onCancel: () => void;
+}
+export default function TrackerPicker({ repoRoot, activeKind, activeOrg, onApplied, onCancel, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};