santree 0.7.5 → 0.7.6

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

@@ -56,7 +56,12 @@ export default function Create({ options, args }) {
             if (options.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");

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/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/claude-config.d.ts

@@ -4,9 +4,23 @@ 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;
-export declare const SESSION_SIGNAL_EVENTS: string[];
-/** Returns the session-signal events that are NOT yet wired in settings.json. */
-export declare function missingSessionSignalHooks(): string[];
-export declare function isSessionSignalConfigured(): boolean;
+/** 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

@@ -6,8 +6,9 @@ import * as path from "path";
  *   - ~/.claude/settings.json   (statusline + hooks)
  *   - ~/.claude.json            (remote control)
  *
- * Both `santree doctor` (detect) and `santree setup` (configure) go through
- * here so the two commands can never disagree about what "configured" means.
+ * `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() {
@@ -48,6 +49,19 @@ export function configureStatusline() {
     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;
@@ -59,28 +73,49 @@ export function enableRemoteControl() {
     writeJson(configPath, config);
     return configPath;
 }
-// ── Session-signal hooks ──────────────────────────────────────────────────────
-export const SESSION_SIGNAL_EVENTS = ["Notification", "Stop", "UserPromptSubmit", "SessionEnd"];
-/** Returns the session-signal events that are NOT yet wired in settings.json. */
-export function missingSessionSignalHooks() {
-    const settings = readJsonSafe(claudeSettingsPath());
-    const hooks = settings.hooks || {};
-    const missing = [];
-    for (const event of SESSION_SIGNAL_EVENTS) {
-        const eventHooks = hooks[event];
-        if (!Array.isArray(eventHooks)) {
-            missing.push(event);
+/** 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 found = eventHooks.some((entry) => {
-            const inner = entry.hooks || [];
-            return inner.some((h) => typeof h.command === "string" && h.command.includes("session-signal"));
+        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 (!found)
-            missing.push(event);
+        if (kept.length === 0)
+            delete hooks[event];
+        else
+            hooks[event] = kept;
     }
-    return missing;
-}
-export function isSessionSignalConfigured() {
-    return missingSessionSignalHooks().length === 0;
+    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 {};

package/dist/lib/config/TrackerPicker.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Text, Box, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { setRepoTracker, getIssueTracker } from "../trackers/index.js";
+import { setRepoLinearOrg, startOAuthFlow } from "../trackers/linear/index.js";
+import { readLinearAuthStore } from "../trackers/auth-store.js";
+import { getAuthenticatedUser, getCurrentRepoNwo } from "../trackers/github/auth.js";
+const AUTH_NEW = "__auth_new__";
+const TRACKERS = [
+    { kind: "local", label: "Local", hint: "built-in, file-based — no account needed" },
+    { kind: "linear", label: "Linear", hint: "OAuth workspace" },
+    { kind: "github", label: "GitHub", hint: "GitHub Issues via gh CLI" },
+];
+export default function TrackerPicker({ repoRoot, activeKind, activeOrg, onApplied, onCancel, }) {
+    const [phase, setPhase] = useState("pick-tracker");
+    const [error, setError] = useState(null);
+    const startIdx = Math.max(0, TRACKERS.findIndex((t) => t.kind === activeKind));
+    const [trackerIdx, setTrackerIdx] = useState(startIdx);
+    const [orgs, setOrgs] = useState([]);
+    const [orgIdx, setOrgIdx] = useState(0);
+    function authenticateNewLinear() {
+        setPhase("authenticating");
+        startOAuthFlow().then((result) => {
+            if (!result) {
+                setError("Authentication failed or timed out. Please try again.");
+                setPhase("error");
+                return;
+            }
+            setRepoLinearOrg(repoRoot, result.orgSlug);
+            setRepoTracker(repoRoot, "linear");
+            onApplied(`Authenticated as ${result.orgName} (${result.orgSlug})`);
+        });
+    }
+    async function chooseTracker(kind) {
+        if (kind === "local") {
+            setRepoTracker(repoRoot, "local");
+            onApplied(`Active tracker: ${getIssueTracker(repoRoot).displayName}`);
+            return;
+        }
+        if (kind === "linear") {
+            const store = readLinearAuthStore();
+            const list = Object.entries(store).map(([slug, tokens]) => ({
+                slug,
+                name: tokens.org_name,
+            }));
+            if (list.length === 0) {
+                authenticateNewLinear();
+                return;
+            }
+            setOrgs(list);
+            const cur = list.findIndex((o) => o.slug === activeOrg);
+            setOrgIdx(cur >= 0 ? cur : 0);
+            setPhase("pick-org");
+            return;
+        }
+        // github
+        setPhase("checking");
+        const user = await getAuthenticatedUser();
+        if (!user) {
+            setError("GitHub CLI not authenticated. Run: gh auth login");
+            setPhase("error");
+            return;
+        }
+        setRepoTracker(repoRoot, "github");
+        const nwo = await getCurrentRepoNwo(repoRoot);
+        onApplied(`Active tracker: GitHub (@${user.login}${nwo ? ` · ${nwo}` : ""})`);
+    }
+    useInput((_input, key) => {
+        if (phase === "error") {
+            // Any key returns to the tracker menu.
+            setError(null);
+            setPhase("pick-tracker");
+            return;
+        }
+        if (phase === "pick-tracker") {
+            if (key.escape || key.leftArrow)
+                onCancel();
+            else if (key.upArrow)
+                setTrackerIdx((i) => Math.max(0, i - 1));
+            else if (key.downArrow)
+                setTrackerIdx((i) => Math.min(TRACKERS.length - 1, i + 1));
+            else if (key.return)
+                void chooseTracker(TRACKERS[trackerIdx].kind);
+        }
+        else if (phase === "pick-org") {
+            const max = orgs.length; // index === orgs.length selects AUTH_NEW
+            if (key.leftArrow || key.escape)
+                setPhase("pick-tracker");
+            else if (key.upArrow)
+                setOrgIdx((i) => Math.max(0, i - 1));
+            else if (key.downArrow)
+                setOrgIdx((i) => Math.min(max, i + 1));
+            else if (key.return) {
+                if (orgIdx === orgs.length) {
+                    authenticateNewLinear();
+                    return;
+                }
+                const org = orgs[orgIdx];
+                setRepoLinearOrg(repoRoot, org.slug);
+                setRepoTracker(repoRoot, "linear");
+                onApplied(`Linked to ${org.name} (${org.slug})`);
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [phase === "checking" && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Checking\u2026" })] })), phase === "authenticating" && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Authenticating with Linear \u2014 follow the browser prompt\u2026" })] })), phase === "pick-tracker" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Select the issue tracker for this repo:" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: TRACKERS.map((t, i) => {
+                            const active = t.kind === activeKind;
+                            return (_jsxs(Text, { children: [i === trackerIdx ? (_jsx(Text, { color: "cyan", bold: true, children: "> " })) : (_jsx(Text, { children: "  " })), t.label, active ? _jsx(Text, { color: "green", children: " \u25CF in use" }) : null, " ", _jsxs(Text, { dimColor: true, children: ["\u2014 ", t.hint] })] }, t.kind));
+                        }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191/\u2193 select \u00B7 Enter confirm \u00B7 \u2190 / Esc back" }) })] })), phase === "pick-org" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Select a Linear workspace to link:" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [orgs.map((org, i) => {
+                                const active = org.slug === activeOrg && activeKind === "linear";
+                                return (_jsxs(Text, { children: [i === orgIdx ? (_jsx(Text, { color: "cyan", bold: true, children: "> " })) : (_jsx(Text, { children: "  " })), org.name, " (", org.slug, ")", active ? _jsx(Text, { color: "green", children: " \u25CF in use" }) : null] }, org.slug));
+                            }), _jsxs(Text, { children: [orgIdx === orgs.length ? (_jsx(Text, { color: "cyan", bold: true, children: "> " })) : (_jsx(Text, { children: "  " })), _jsx(Text, { dimColor: true, children: "+ Authenticate a new workspace\u2026" })] }, AUTH_NEW)] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191/\u2193 select \u00B7 \u2190 back \u00B7 Enter confirm" }) })] })), phase === "error" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }), _jsx(Text, { dimColor: true, children: "Press any key to go back." })] }))] }));
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Read-only diagnostics for `santree config`. These are the facts santree can
+ * *report* but not change from the panel (tool versions, update availability,
+ * auth state). The panel renders them as non-selectable info rows; `--check`
+ * prints them flat. Configurable settings live in `lib/setup/steps.ts` instead.
+ */
+/** A read-only status row — santree reports it, you can't toggle it here. */
+export interface InfoRow {
+    id: string;
+    title: string;
+    description: string;
+    scope: "system" | "global" | "repo";
+    required: boolean;
+    ok: boolean;
+    /** Dim sub-lines (version, path, account, …). */
+    lines: string[];
+    /** Yellow call-to-action when not ok. */
+    hint?: string;
+}
+/**
+ * Extra detail attached to a configurable step row by id (version / auth / a
+ * yellow update hint). Lets an already-configured step render doctor-style
+ * without the step catalog itself doing network I/O.
+ */
+export interface StepDetail {
+    lines: string[];
+    hint?: string;
+}
+export interface DiagnosticsData {
+    infoRows: InfoRow[];
+    /** Keyed by SetupStep id (gh, claude, tracker). */
+    stepDetail: Map<string, StepDetail>;
+    /** True when an active multiplexer was detected (tmux/cmux). */
+    muxActive: boolean;
+}
+/** Run every read-only check. Network calls (npm registry, gh, tracker) run in parallel. */
+export declare function loadDiagnostics(): Promise<DiagnosticsData>;