santree 0.7.5 → 0.7.6

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;
@@ -11,6 +11,8 @@ interface Props {
     /** 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;
@@ -42,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, prSyncing, 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, prSyncing = false, 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: [
@@ -577,18 +546,51 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
         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 });
@@ -598,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 {};

package/dist/lib/dashboard/IssueList.js

@@ -45,11 +45,30 @@ function workIndicator(wt) {
 function ciIndicator(checks) {
     if (!checks || checks.length === 0)
         return { glyph: "·", color: "gray" };
+    // `gh` buckets: pass | fail | pending | skipping | cancel. Only `fail` blocks
+    // (red) and only `pending` is genuinely still running (yellow). `skipping` /
+    // `cancel` don't run under the current conditions and don't block — GitHub
+    // reports them as "skipped" and still shows "all checks passed", so they must
+    // not turn the glyph yellow.
     if (checks.some((c) => c.bucket === "fail"))
         return { glyph: "✗", color: "red" };
-    if (checks.every((c) => c.bucket === "pass"))
-        return { glyph: "✓", color: "green" };
-    return { glyph: "●", color: "yellow" };
+    if (checks.some((c) => c.bucket === "pending"))
+        return { glyph: "●", color: "yellow" };
+    return { glyph: "✓", color: "green" };
+}
+/**
+ * While a fix loop is actively running (or stalled), it owns the CI column — a ⟳
+ * conveys "being auto-fixed" better than the underlying check state. Stopped loops
+ * fall back to the real CI glyph (CI green ≈ stopped clean, CI red ≈ stopped stuck).
+ */
+function fixLoopOverride(loop) {
+    if (!loop)
+        return null;
+    if (loop.phase === "running")
+        return { glyph: "⟳", color: "cyan" };
+    if (loop.phase === "stalled")
+        return { glyph: "⟳", color: "yellow" };
+    return null;
 }
 export function buildIssueListRows(groups, flatIssues) {
     const rows = [];
@@ -109,7 +128,7 @@ function readinessGlyph(di) {
             return { glyph: "·", color: "gray" };
     }
 }
-export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, selectionBg = "#1e3a5f", variant = "default", deletingIds, }) {
+export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, selectionBg = "#1e3a5f", variant = "default", deletingIds, fixLoops, }) {
     const isTriage = variant === "triage";
     const isIssues = variant === "issues";
     const rightFixed = isTriage ? SLA_COL_WIDTH : isIssues ? READY_COL_WIDTH : RIGHT_FIXED;
@@ -146,7 +165,7 @@ export default function IssueList({ groups, flatIssues, selectedIndex, scrollOff
                 const prio = snoozed ? { glyph: " ", color: "gray" } : priorityMarker(di.issue.priority);
                 const isDeleting = deletingIds?.has(di.issue.identifier) ?? false;
                 const work = isDeleting ? { glyph: "⌫", color: "yellow" } : workIndicator(di.worktree);
-                const ci = ciIndicator(di.checks);
+                const ci = fixLoopOverride(fixLoops?.[di.issue.identifier]) ?? ciIndicator(di.checks);
                 const nestPrefix = depth > 0 ? "  ".repeat(depth - 1) + "└ " : "";
                 const adjustedTitleWidth = Math.max(titleMaxWidth - nestPrefix.length, 5);
                 const title = di.issue.title.length > adjustedTitleWidth

package/dist/lib/dashboard/MultilineTextArea.js

@@ -162,7 +162,7 @@ export function MultilineTextArea({ value, onChange, onSubmit, onCancel, placeho
             onSubmit();
             return;
         }
-        // Ctrl+O: escalate to $SANTREE_EDITOR / $VISUAL / $EDITOR. On save+close
+        // Ctrl+O: escalate to the configured editor / $VISUAL / $EDITOR. On save+close
         // the buffer is replaced and control returns to the textbox so the
         // user can keep editing or submit with Ctrl+D.
         if (key.ctrl && input === "o") {

package/dist/lib/dashboard/Overlays.js

@@ -68,6 +68,8 @@ const LEGEND = [
             { glyph: "✗", color: "red", meaning: "CI column: a check is failing" },
             { glyph: "●", color: "yellow", meaning: "CI column: checks pending / running" },
             { glyph: "·", color: "gray", meaning: "CI column: no PR or no checks" },
+            { glyph: "⟳", color: "cyan", meaning: "CI column: auto-fix loop running (every 5 min)" },
+            { glyph: "⟳", color: "yellow", meaning: "CI column: fix loop stalled (no recent activity)" },
             { glyph: "◷", color: "red", meaning: "SLA column (Triage): breached / under a day" },
             { glyph: "◷", color: "yellow", meaning: "SLA column (Triage): under two days" },
             { glyph: "●", color: "gray", meaning: "Triage row greyed: snoozed (parked, sunk to bottom)" },
@@ -86,10 +88,7 @@ const LEGEND = [
             { glyph: "✓ clean", color: "green", meaning: "Working tree clean" },
             { glyph: "↑ N", color: "cyan", meaning: "N commits ahead of base" },
             { glyph: "↓ N behind", color: "yellow", meaning: "Main repo: N commits to pull from origin" },
-            { glyph: "◆", color: "red", meaning: "Session needs input (permission prompt)" },
-            { glyph: "◆", color: "green", meaning: "Session active (Claude is working)" },
-            { glyph: "◆", color: "yellow", meaning: "Session idle (waiting for prompt)" },
-            { glyph: "◇", color: "cyan", meaning: "Session id stored, no live signal" },
+            { glyph: "◇", color: "cyan", meaning: "Resumable Claude session id stored" },
             { glyph: "◇", color: "gray", meaning: "No session" },
         ],
     },

package/dist/lib/dashboard/ReviewDetailPanel.js

@@ -223,16 +223,20 @@ export default function ReviewDetailPanel({ item, scrollOffset, height, width })
     }
     // ── Checks ────────────────────────────────────────────────────────
     if (checks && checks.length > 0) {
+        // `skipping`/`cancel` checks don't run under the current conditions and
+        // don't block — 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 });
@@ -242,8 +246,13 @@ export default function ReviewDetailPanel({ item, scrollOffset, height, width })
             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/ReviewList.js

@@ -3,11 +3,14 @@ import { Box, Text } from "ink";
 function checksIndicator(checks) {
     if (!checks || checks.length === 0)
         return { text: "-", color: "gray" };
+    // Only `fail` blocks (red) and only `pending` is genuinely running (yellow);
+    // `skipping`/`cancel` don't run under the current conditions and don't block,
+    // so they must not turn the glyph yellow (matches GitHub's "all checks passed").
     if (checks.some((c) => c.bucket === "fail"))
         return { text: "✗", color: "red" };
-    if (checks.every((c) => c.bucket === "pass"))
-        return { text: "✓", color: "green" };
-    return { text: "●", color: "yellow" };
+    if (checks.some((c) => c.bucket === "pending"))
+        return { text: "●", color: "yellow" };
+    return { text: "✓", color: "green" };
 }
 const HEADER_ROWS = 1;
 export function getReviewListRowCount(flatReviews) {