santree 0.7.4 → 0.7.6

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>;

package/dist/lib/config/diagnostics.js

@@ -0,0 +1,190 @@
+import { run } from "../exec.js";
+import { which } from "../setup/tools.js";
+import { getMultiplexer } from "../multiplexer/index.js";
+import { resolveClaudeBinary } from "../ai.js";
+import { findMainRepoRoot } from "../git.js";
+import { getIssueTracker } from "../trackers/index.js";
+import { CURRENT_VERSION, CLAUDE_CODE_PACKAGE, SANTREE_PACKAGE, getLatestVersionFor, isUpdateAvailable, detectPackageManager, getInstallCommandFor, } from "../version.js";
+function tryRun(cmd) {
+    return run(`${cmd} 2>/dev/null`);
+}
+function checkGit() {
+    const p = which("git");
+    if (!p) {
+        return {
+            id: "git",
+            title: "git",
+            description: "Version control",
+            scope: "system",
+            required: true,
+            ok: false,
+            lines: [],
+            hint: "Install: brew install git",
+        };
+    }
+    const version = tryRun("git --version | head -1");
+    return {
+        id: "git",
+        title: "git",
+        description: "Version control",
+        scope: "system",
+        required: true,
+        ok: true,
+        lines: [`Version: ${version || "unknown"}`, `Path: ${p}`],
+    };
+}
+function checkNode() {
+    const version = process.versions.node;
+    const major = Number(version.split(".")[0] || "0");
+    const ok = major >= 20;
+    return {
+        id: "node",
+        title: "node",
+        description: "JavaScript runtime (>= 20 required)",
+        scope: "system",
+        required: true,
+        ok,
+        lines: [`Version: v${version}`, `Path: ${process.execPath}`],
+        hint: ok ? undefined : "Santree needs Node.js >= 20. Upgrade: https://nodejs.org",
+    };
+}
+async function checkSantreeSelf() {
+    const latest = await getLatestVersionFor(SANTREE_PACKAGE);
+    const updatable = !!latest && isUpdateAvailable(CURRENT_VERSION, latest);
+    const lines = [`Version: ${CURRENT_VERSION}`];
+    if (latest)
+        lines.push(`Latest: ${latest}${updatable ? " ⬆ update available" : ""}`);
+    return {
+        id: "santree",
+        title: "santree",
+        description: "Santree CLI (this app)",
+        scope: "system",
+        required: true,
+        ok: true,
+        lines,
+        hint: updatable ? "Run: santree update" : undefined,
+    };
+}
+function checkMultiplexer() {
+    const mux = getMultiplexer();
+    if (mux.kind === "tmux") {
+        const version = tryRun("tmux -V");
+        return {
+            id: "multiplexer",
+            title: "tmux",
+            description: "Active multiplexer — new-window flows enabled",
+            scope: "system",
+            required: false,
+            ok: true,
+            lines: [`Version: ${version || "unknown"}`, `Path: ${which("tmux") || "unknown"}`],
+        };
+    }
+    // cmux
+    const version = tryRun("cmux --version");
+    const ping = tryRun("cmux ping");
+    return {
+        id: "multiplexer",
+        title: "cmux",
+        description: "Active multiplexer — new-window flows enabled",
+        scope: "system",
+        required: false,
+        ok: !!ping,
+        lines: [`Version: ${version || "unknown"}`, `Path: ${which("cmux") || "unknown"}`],
+        hint: ping ? undefined : "cmux app not reachable — open cmux.app.",
+    };
+}
+function checkWorkspaceEditor() {
+    const code = which("code");
+    const cursor = which("cursor");
+    const found = code ? "code" : cursor ? "cursor" : null;
+    if (found) {
+        const version = tryRun(`${found} --version | head -1`);
+        return {
+            id: "workspace-editor",
+            title: "Workspace editor",
+            description: "code/cursor — powers the dashboard's `E workspace` shortcut",
+            scope: "system",
+            required: false,
+            ok: true,
+            lines: [`Editor: ${found}`, `Version: ${version || "unknown"}`],
+        };
+    }
+    return {
+        id: "workspace-editor",
+        title: "Workspace editor",
+        description: "code/cursor — powers the dashboard's `E workspace` shortcut",
+        scope: "system",
+        required: false,
+        ok: false,
+        lines: [],
+        hint: "Optional — only the `.code-workspace` shortcut needs code/cursor. Everything else uses your configured editor.",
+    };
+}
+/** Version + auth detail for the gh and claude step rows. */
+async function loadStepDetail() {
+    const detail = new Map();
+    const pm = detectPackageManager();
+    // claude — version + latest + cmux-aware update hint
+    const resolved = resolveClaudeBinary();
+    if (resolved) {
+        const version = tryRun(`"${resolved}" --version | head -1`);
+        const latest = await getLatestVersionFor(CLAUDE_CODE_PACKAGE);
+        const lines = [`Version: ${version || "unknown"}`, `Path: ${resolved}`];
+        let hint;
+        if (latest && version && isUpdateAvailable(version, latest)) {
+            lines.push(`Latest: ${latest} ⬆ update available`);
+            if (resolved.includes("/cmux.app/")) {
+                hint = "Bundled with cmux — update cmux.app to get the latest Claude.";
+            }
+            else {
+                hint = `Run: ${getInstallCommandFor(pm, `${CLAUDE_CODE_PACKAGE}@latest`).display}`;
+            }
+        }
+        detail.set("claude", { lines, hint });
+    }
+    // gh — version + authenticated login
+    if (which("gh")) {
+        const version = tryRun("gh --version | head -1");
+        const login = tryRun("gh api user --jq .login");
+        const lines = [`Version: ${version || "unknown"}`];
+        if (login)
+            lines.push(`Auth: authenticated as ${login}`);
+        detail.set("gh", { lines, hint: login ? undefined : "Run: gh auth login" });
+    }
+    return detail;
+}
+/** Active issue tracker auth detail for the tracker row. */
+async function loadTrackerDetail() {
+    const repoRoot = findMainRepoRoot();
+    if (!repoRoot)
+        return null;
+    try {
+        const tracker = getIssueTracker(repoRoot);
+        const status = await tracker.getAuthStatus(repoRoot);
+        const lines = [`Tracker: ${tracker.displayName}`];
+        if (status.accountLabel)
+            lines.push(`Account: ${status.accountLabel}`);
+        if (status.repoLinked !== undefined)
+            lines.push(`Repo linked: ${status.repoLinked ? "yes" : "no"}`);
+        return { lines, hint: status.authenticated ? undefined : status.hint };
+    }
+    catch {
+        return null;
+    }
+}
+/** Run every read-only check. Network calls (npm registry, gh, tracker) run in parallel. */
+export async function loadDiagnostics() {
+    const muxActive = getMultiplexer().kind !== "none";
+    const [santree, stepDetail, trackerDetail] = await Promise.all([
+        checkSantreeSelf(),
+        loadStepDetail(),
+        loadTrackerDetail(),
+    ]);
+    if (trackerDetail)
+        stepDetail.set("tracker", trackerDetail);
+    const infoRows = [santree, checkNode(), checkGit()];
+    if (muxActive)
+        infoRows.push(checkMultiplexer());
+    infoRows.push(checkWorkspaceEditor());
+    return { infoRows, stepDetail, muxActive };
+}

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

@@ -0,0 +1,23 @@
+export interface SantreeConfig {
+    /** Editor launched by the dashboard's [e] action and Ctrl+O in text areas. */
+    editor?: string;
+    /** Unified-diff pager for `worktree diff` and the dashboard [v] overlay. */
+    diffTool?: string;
+}
+export declare function configStorePath(): string;
+export declare function readConfigStore(): SantreeConfig;
+export declare function setConfigValue<K extends keyof SantreeConfig>(key: K, value: SantreeConfig[K]): void;
+export declare function unsetConfigValue(key: keyof SantreeConfig): void;
+/**
+ * Resolved editor command: `SANTREE_EDITOR` env override → config file → none.
+ * Call sites keep their own final fallback (e.g. `"code"` for GUI-open flows,
+ * the `VISUAL`/`EDITOR`/`vim` chain for in-terminal editing).
+ */
+export declare function getConfiguredEditor(): string | undefined;
+/**
+ * Resolved diff pager: `SANTREE_DIFF_TOOL` env override → config file → none.
+ * Restricted to a safe shell-token character set since it ends up in spawn()
+ * arguments — even though we never use shell:true, a tight surface defends
+ * against accidental misconfigurations.
+ */
+export declare function getConfiguredDiffTool(): string | undefined;

package/dist/lib/config-store.js

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+/**
+ * Santree's global config file — `$XDG_CONFIG_HOME/santree/config.json`
+ * (defaults to `~/.config/santree/config.json`), sitting next to `auth.json`.
+ *
+ * This is where preferences santree owns live (editor, diff tool) instead of
+ * exporting them into the user's shell rc. Writing here takes effect on the
+ * next santree run with no shell restart. The matching `SANTREE_EDITOR` /
+ * `SANTREE_DIFF_TOOL` env vars still work as a one-off override that wins over
+ * the file, so existing shell exports and CI overrides keep behaving.
+ */
+const CONFIG_DIR = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+const CONFIG_PATH = path.join(CONFIG_DIR, "santree", "config.json");
+export function configStorePath() {
+    return CONFIG_PATH;
+}
+export function readConfigStore() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeConfigStore(cfg) {
+    fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+}
+export function setConfigValue(key, value) {
+    const cfg = readConfigStore();
+    cfg[key] = value;
+    writeConfigStore(cfg);
+}
+export function unsetConfigValue(key) {
+    const cfg = readConfigStore();
+    if (!(key in cfg))
+        return;
+    delete cfg[key];
+    writeConfigStore(cfg);
+}
+/**
+ * Resolved editor command: `SANTREE_EDITOR` env override → config file → none.
+ * Call sites keep their own final fallback (e.g. `"code"` for GUI-open flows,
+ * the `VISUAL`/`EDITOR`/`vim` chain for in-terminal editing).
+ */
+export function getConfiguredEditor() {
+    const env = process.env.SANTREE_EDITOR;
+    if (env && env.trim())
+        return env.trim();
+    const stored = readConfigStore().editor;
+    return stored && stored.trim() ? stored.trim() : undefined;
+}
+/**
+ * Resolved diff pager: `SANTREE_DIFF_TOOL` env override → config file → none.
+ * Restricted to a safe shell-token character set since it ends up in spawn()
+ * arguments — even though we never use shell:true, a tight surface defends
+ * against accidental misconfigurations.
+ */
+export function getConfiguredDiffTool() {
+    const raw = process.env.SANTREE_DIFF_TOOL ?? readConfigStore().diffTool;
+    if (!raw || !raw.trim())
+        return undefined;
+    const tool = raw.trim();
+    return /^[a-zA-Z0-9_\-/.+]+$/.test(tool) ? tool : undefined;
+}

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

@@ -1,4 +1,4 @@
-import type { Comment, DashboardIssue, DashboardTab, DeleteStatus } from "./types.js";
+import type { Comment, DashboardIssue, DashboardTab, DeleteStatus, FixLoopRuntime } from "./types.js";
 interface Props {
     issue: DashboardIssue | null;
     scrollOffset: number;
@@ -8,6 +8,11 @@ interface Props {
     creationLogs: string;
     /** Deletion progress for the selected worktree, when one is being removed. */
     deleteStatus?: DeleteStatus;
+    /** True while a just-created PR is shown optimistically, before a refresh
+     * confirms it (renders a "syncing…" hint next to the PR). */
+    prSyncing?: boolean;
+    /** Active/recent auto-fix loop for the selected ticket, shown as a ⟳ line. */
+    fixLoop?: FixLoopRuntime;
     /** Triage mode: hide worktree/PR/checks sections (they never apply to an
      * inbox issue) and show the discussion instead. */
     triage?: boolean;
@@ -39,5 +44,5 @@ export declare function buildIssueActions(di: DashboardIssue, trackerName: strin
     canMutate?: boolean;
     triageInvestigateConfigured?: boolean;
 }): IssueActionItem[];
-export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, deleteStatus, triage, comments, onCall, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, deleteStatus, prSyncing, fixLoop, triage, comments, onCall, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/lib/dashboard/DetailPanel.js

@@ -134,7 +134,7 @@ export function buildIssueActions(di, trackerName, opts) {
         items.push({ key: "c", label: "Create PR", color: "cyan" });
     }
     if (pr) {
-        items.push({ key: "f", label: "Fix PR", color: "cyan" });
+        items.push({ key: "f", label: "Fix loop", color: "cyan" });
         items.push({ key: "r", label: "Review", color: "cyan" });
     }
     if (issue.url) {
@@ -158,7 +158,7 @@ function sectionHeader(icon, label, iconColor = "cyan") {
         ],
     };
 }
-export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, deleteStatus, triage = false, comments, onCall, }) {
+export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, deleteStatus, prSyncing = false, fixLoop, triage = false, comments, onCall, }) {
     // Show deletion progress when the selected worktree is being removed.
     if (issue && deleteStatus) {
         const logLines = deleteStatus.logs.split("\n");
@@ -417,39 +417,8 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
                 lines.push({ text: `    +${gs.files.length - maxFiles} more`, dim: true });
             }
         }
-        // Session state — single line, color reflects state.
-        if (worktree.sessionState === "waiting") {
-            const msg = worktree.sessionMessage
-                ? `NEEDS INPUT: ${worktree.sessionMessage}`
-                : "NEEDS INPUT";
-            lines.push({
-                text: "",
-                segments: [
-                    { text: "  ◆ ", color: "red" },
-                    { text: msg, color: "red", bold: true },
-                ],
-            });
-        }
-        else if (worktree.sessionState === "active") {
-            lines.push({
-                text: "",
-                segments: [
-                    { text: "  ◆ ", color: "green" },
-                    { text: "session active", color: "green" },
-                ],
-            });
-        }
-        else if (worktree.sessionState === "idle") {
-            lines.push({
-                text: "",
-                segments: [
-                    { text: "  ◆ ", color: "yellow" },
-                    { text: "session idle", color: "yellow" },
-                    { text: "  (waiting for prompt)", dim: true },
-                ],
-            });
-        }
-        else if (worktree.sessionId) {
+        // Resumable Claude session (the stored session id), or none.
+        if (worktree.sessionId) {
             lines.push({
                 text: "",
                 segments: [
@@ -557,28 +526,71 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
                 { text: "  " },
                 { text: pr.state, color: prColor },
                 { text: draft, dim: true },
+                ...(prSyncing ? [{ text: "  · syncing…", color: "yellow" }] : []),
             ],
         });
         if (pr.url) {
             lines.push({ text: `  ${pr.url}`, dim: true });
         }
+        if (prSyncing) {
+            // Just created from the dashboard — number/url are known, but checks
+            // and reviews aren't fetched yet. Show a clear loading line for this
+            // one PR (other PRs keep their already-loaded data).
+            lines.push({
+                text: "",
+                segments: [{ text: "  ⟳ loading checks & reviews…", color: "yellow" }],
+            });
+        }
     }
     else if (!isMain) {
         lines.push(sectionHeader("◉", "Pull Request"));
         lines.push({ text: "  no PR yet", dim: true });
     }
+    // ── Fix loop ──────────────────────────────────────────────────────
+    if (!isMain && fixLoop) {
+        const { phase } = fixLoop;
+        const color = phase === "running"
+            ? "cyan"
+            : phase === "stalled"
+                ? "yellow"
+                : phase === "stopped-clean"
+                    ? "green"
+                    : "red";
+        const label = phase === "running"
+            ? `fix loop · ${fixLoop.status}`
+            : phase === "stalled"
+                ? "fix loop · stalled (no recent activity)"
+                : phase === "stopped-clean"
+                    ? "fix loop · stopped — all clear"
+                    : "fix loop · stopped — needs a human";
+        const ageMin = Math.max(0, Math.round(fixLoop.ageMs / 60000));
+        lines.push(ruleLine);
+        lines.push({
+            text: "",
+            segments: [
+                { text: "⟳ ", color, bold: true },
+                { text: label, color },
+                { text: `   updated ${ageMin}m ago`, dim: true },
+            ],
+        });
+    }
     // ── Checks ────────────────────────────────────────────────────────
     if (!isMain && checks && checks.length > 0) {
+        // `gh` buckets: pass | fail | pending | skipping | cancel. Skipped/cancelled
+        // checks don't run under the current conditions and don't block the PR —
+        // GitHub counts them as "skipped" while still reporting "all checks passed".
+        // Treat them as a non-blocking aside, never as pending.
         const passing = checks.filter((c) => c.bucket === "pass");
         const failing = checks.filter((c) => c.bucket === "fail");
-        const pending = checks.filter((c) => c.bucket !== "pass" && c.bucket !== "fail");
+        const pending = checks.filter((c) => c.bucket === "pending");
+        const skipped = checks.filter((c) => c.bucket === "skipping" || c.bucket === "cancel");
         const headerColor = failing.length > 0 ? "red" : pending.length > 0 ? "yellow" : "green";
         lines.push(ruleLine);
         const headerSegs = [
             { text: "✓ ", color: "cyan", bold: true },
             { text: "Checks", bold: true },
             { text: "   " },
-            { text: `${passing.length}/${checks.length} passing`, color: headerColor },
+            { text: `${passing.length} passed`, color: headerColor },
         ];
         if (failing.length > 0) {
             headerSegs.push({ text: "  ·  ", dim: true });
@@ -588,8 +600,13 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
             headerSegs.push({ text: "  ·  ", dim: true });
             headerSegs.push({ text: `${pending.length} pending`, color: "yellow" });
         }
+        if (skipped.length > 0) {
+            headerSegs.push({ text: "  ·  ", dim: true });
+            headerSegs.push({ text: `${skipped.length} skipped`, dim: true });
+        }
         lines.push({ text: "", segments: headerSegs });
         // Order: failing first (most important), then pending, then passing.
+        // Skipped checks aren't listed individually — just summarized above.
         for (const check of failing) {
             const desc = check.description ? ` — ${check.description}` : "";
             lines.push({ text: `  ✗ ${check.name}${desc}`, color: "red" });

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

@@ -1,3 +1,4 @@
+import type { FixLoopRuntime } from "../fix-loop.js";
 import type { ProjectGroup, DashboardIssue } from "./types.js";
 interface Props {
     groups: ProjectGroup[];
@@ -16,6 +17,9 @@ interface Props {
     /** Ticket ids whose worktree is currently being removed — shown with a
      * distinct WT-column glyph so concurrent deletions are visible in the list. */
     deletingIds?: Set<string>;
+    /** Active/recent auto-fix loops by ticket id — a running/stalled loop shows a
+     * ⟳ in place of the CI glyph (the loop is the CI story while it runs). */
+    fixLoops?: Record<string, FixLoopRuntime>;
 }
 export type ListRow = {
     kind: "spacer";
@@ -36,5 +40,5 @@ export type ListRow = {
     depth: number;
 };
 export declare function buildIssueListRows(groups: ProjectGroup[], flatIssues: DashboardIssue[]): ListRow[];
-export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, selectionBg, variant, deletingIds, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, selectionBg, variant, deletingIds, fixLoops, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};