santree 0.7.0 → 0.7.3

package/dist/lib/ai.d.ts

@@ -88,6 +88,19 @@ export declare function runAgentAsync(prompt: string, opts?: {
  * Clean up cached image downloads for an issue identifier on the active tracker.
  */
 export declare function cleanupImages(ticketId: string): void;
+/**
+ * Ask Claude a clarifying question about a triage issue. The full issue —
+ * description plus every comment — is rendered via the shared `ticket.njk`
+ * template and injected into `ask.njk`. Read-only codebase tools are granted
+ * (Read for downloaded issue images, Grep/Glob so Claude can judge whether the
+ * issue is fixable against the real code). Runs non-interactively and returns
+ * the captured answer text. Async so the Ink dashboard keeps animating.
+ */
+export declare function askTicketQuestion(opts: {
+    ticket: Issue;
+    trackerName: string;
+    question: string;
+}): Promise<RunAgentResult>;
 export interface FillCommitOpts {
     branch: string;
     ticketId: string | null;

package/dist/lib/ai.js

@@ -267,6 +267,22 @@ export function cleanupImages(ticketId) {
     const repoRoot = findMainRepoRoot();
     getIssueTracker(repoRoot).cleanupCache(ticketId);
 }
+/**
+ * Ask Claude a clarifying question about a triage issue. The full issue —
+ * description plus every comment — is rendered via the shared `ticket.njk`
+ * template and injected into `ask.njk`. Read-only codebase tools are granted
+ * (Read for downloaded issue images, Grep/Glob so Claude can judge whether the
+ * issue is fixable against the real code). Runs non-interactively and returns
+ * the captured answer text. Async so the Ink dashboard keeps animating.
+ */
+export async function askTicketQuestion(opts) {
+    const prompt = renderPrompt("ask", {
+        ticket_id: opts.ticket.identifier,
+        ticket_content: renderTicket(opts.ticket, opts.trackerName),
+        user_question: opts.question,
+    });
+    return runAgentAsync(prompt, { allowedTools: ["Read", "Grep", "Glob"] });
+}
 /**
  * Generate a short imperative commit message from a staged diff.
  * Async so callers (the Ink dashboard, the CLI commit flow) keep the

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

@@ -1,4 +1,4 @@
-import type { DashboardIssue, DashboardTab } from "./types.js";
+import type { Comment, DashboardIssue, DashboardTab, DeleteStatus } from "./types.js";
 interface Props {
     issue: DashboardIssue | null;
     scrollOffset: number;
@@ -6,6 +6,22 @@ interface Props {
     width: number;
     creatingForTicket: string | null;
     creationLogs: string;
+    /** Deletion progress for the selected worktree, when one is being removed. */
+    deleteStatus?: DeleteStatus;
+    /** Triage mode: hide worktree/PR/checks sections (they never apply to an
+     * inbox issue) and show the discussion instead. */
+    triage?: boolean;
+    /** Comments for the selected triage issue. `undefined` = not yet loaded
+     * (shows "loading…"); an array (possibly empty) = loaded. Only consulted in
+     * triage mode. */
+    comments?: Comment[];
+    /** Compact triage on-call summary, shown as the first line in triage mode. */
+    onCall?: {
+        currentName: string | null;
+        currentIsMe: boolean;
+        /** Formatted start of the viewer's next shift (e.g. "Jun 5"), if any. */
+        myNext: string | null;
+    };
 }
 export type IssueActionItem = {
     key: string;
@@ -22,5 +38,5 @@ export declare function buildIssueActions(di: DashboardIssue, trackerName: strin
     tab?: DashboardTab;
     canMutate?: boolean;
 }): IssueActionItem[];
-export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, deleteStatus, triage, comments, onCall, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/lib/dashboard/DetailPanel.js

@@ -1,5 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+import { formatSla, isSnoozed } from "./sla.js";
+import { issueReadiness } from "../trackers/types.js";
 function stateColor(type) {
     switch (type) {
         case "started":
@@ -77,6 +79,18 @@ export function buildIssueActions(di, trackerName, opts) {
         }
         return items;
     }
+    // Triage tab = the incoming inbox. Read the discussion, ask Claude a
+    // clarifying question, and — once it looks fixable — send it to a tree
+    // (`w`, same worktree-creation flow as the Issues tab).
+    if (opts?.tab === "triage") {
+        items.push({ key: "w", label: "Send to tree", color: "cyan" });
+        items.push({ key: "a", label: "Ask", color: "cyan" });
+        items.push({ key: "s", label: "Schedule", color: "cyan" });
+        if (issue.url) {
+            items.push({ key: "o", label: trackerName, color: "gray" });
+        }
+        return items;
+    }
     // The synthetic "Main repo" row is special: no PR/Switch/Resume/Remove,
     // no work-launching (you're already on it). Only commit / diff /
     // editor — the actions that make sense for "I have changes in main and
@@ -137,7 +151,22 @@ function sectionHeader(icon, label, iconColor = "cyan") {
         ],
     };
 }
-export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, }) {
+export default function DetailPanel({ issue, scrollOffset, height, width, creatingForTicket, creationLogs, deleteStatus, triage = false, comments, onCall, }) {
+    // Show deletion progress when the selected worktree is being removed.
+    if (issue && deleteStatus) {
+        const logLines = deleteStatus.logs.split("\n");
+        const contentRows = height - 1;
+        const startIdx = Math.max(0, logLines.length - contentRows);
+        const visible = logLines.slice(startIdx, startIdx + contentRows);
+        const clampLine = (s) => s.length > width ? s.slice(0, Math.max(0, width - 1)) + "…" : s;
+        const headerColor = deleteStatus.phase === "error" ? "red" : "yellow";
+        const header = deleteStatus.phase === "error"
+            ? `Failed to remove ${issue.issue.identifier}`
+            : deleteStatus.phase === "done"
+                ? `Removed ${issue.issue.identifier}`
+                : `Removing worktree for ${issue.issue.identifier}…`;
+        return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(Text, { color: deleteStatus.phase === "done" ? "green" : headerColor, bold: true, children: clampLine(header) }), visible.map((line, i) => (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: clampLine(line) }) }, i))), deleteStatus.phase === "error" && deleteStatus.error ? (_jsx(Text, { color: "red", children: clampLine(deleteStatus.error) })) : null] }));
+    }
     // Show creation logs when selected issue is being created
     if (issue && issue.issue.identifier === creatingForTicket) {
         const logLines = creationLogs.split("\n");
@@ -157,20 +186,62 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
     const lines = [];
     const rule = "─".repeat(width);
     const ruleLine = { text: rule, dim: true };
+    // ── Triage on-call (compact) ───────────────────────────────────────
+    // First line in triage mode: who's on call now + when the viewer is next up.
+    // The full rotation lives behind the [s] schedule overlay.
+    if (triage && onCall && onCall.currentName) {
+        const segs = [
+            { text: "◷ ", color: onCall.currentIsMe ? "cyan" : "green", bold: true },
+            { text: "on call: ", dim: true },
+            {
+                text: onCall.currentName,
+                color: onCall.currentIsMe ? "cyan" : "green",
+                bold: true,
+            },
+        ];
+        if (onCall.myNext) {
+            segs.push({ text: "   ·   you're up ", dim: true });
+            segs.push({ text: onCall.myNext, color: "cyan" });
+        }
+        segs.push({ text: "   ·   [s] schedule", dim: true });
+        lines.push({ text: "", segments: segs });
+        lines.push(ruleLine);
+    }
     // ── Hero: identifier + title, then a status pill row ───────────────
     lines.push({ text: `${li.identifier}  ${li.title}`, bold: true });
     const sc = stateColor(li.state.type);
-    const heroSegs = [
-        { text: "● ", color: sc },
-        { text: li.state.name, color: sc },
-        { text: "  ·  ", dim: true },
-        { text: li.priorityLabel },
-    ];
+    const heroSegs = [];
+    // On the Triage tab every issue is in the "Triage" state by definition, so the
+    // status pill is noise — lead with priority instead.
+    if (!triage) {
+        heroSegs.push({ text: "● ", color: sc }, { text: li.state.name, color: sc }, { text: "  ·  ", dim: true });
+    }
+    heroSegs.push({ text: li.priorityLabel });
     if (li.labels.length > 0) {
         heroSegs.push({ text: "  ·  ", dim: true });
         heroSegs.push({ text: li.labels.join(", "), dim: true });
     }
     lines.push({ text: "", segments: heroSegs });
+    // ── SLA countdown ─────────────────────────────────────────────────
+    // Urgency-coded time-to-breach; shown whenever the issue carries an SLA
+    // (Triage tab). Snoozed issues are parked, so render greyed with a marker.
+    const sla = formatSla(li.slaBreachesAt);
+    const snoozed = isSnoozed(li.snoozedUntilAt);
+    if (sla) {
+        const col = snoozed ? "gray" : sla.color;
+        const bold = !snoozed && sla.urgent;
+        lines.push({
+            text: "",
+            segments: [
+                { text: "◷ ", color: col, bold },
+                { text: sla.label, color: col, bold },
+                ...(snoozed ? [{ text: "  ·  snoozed", color: "gray" }] : []),
+            ],
+        });
+    }
+    else if (snoozed) {
+        lines.push({ text: "", segments: [{ text: "◷ snoozed", color: "gray" }] });
+    }
     // ── Description ───────────────────────────────────────────────────
     if (li.description) {
         lines.push({ text: "" });
@@ -178,6 +249,81 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
             lines.push({ text: dLine });
         }
     }
+    // ── Dependencies ──────────────────────────────────────────────────
+    // Blocking relations from the tracker. Header carries a readiness badge so
+    // the user can tell at a glance whether the issue is startable.
+    const blockedBy = li.blockedBy ?? [];
+    const blocking = li.blocking ?? [];
+    if (!triage && (blockedBy.length > 0 || blocking.length > 0)) {
+        const readiness = issueReadiness(li.blockedBy);
+        lines.push(ruleLine);
+        const headerSegs = [
+            { text: "⇄ ", color: "cyan", bold: true },
+            { text: "Dependencies", bold: true },
+            { text: "   " },
+            readiness === "ready"
+                ? { text: "✓ ready to start", color: "green", bold: true }
+                : { text: "⊘ blocked", color: "yellow", bold: true },
+        ];
+        lines.push({ text: "", segments: headerSegs });
+        if (blockedBy.length > 0) {
+            lines.push({ text: "  blocked by", dim: true });
+            for (const b of blockedBy) {
+                lines.push({
+                    text: "",
+                    segments: [
+                        { text: `    ${b.done ? "✓" : "○"} `, color: b.done ? "green" : "yellow" },
+                        { text: b.identifier, color: b.done ? undefined : "yellow", dim: b.done },
+                        ...(b.done ? [{ text: "  done", dim: true }] : []),
+                    ],
+                });
+            }
+        }
+        if (blocking.length > 0) {
+            lines.push({ text: "  blocks", dim: true });
+            lines.push({
+                text: "",
+                segments: [{ text: "    " }, { text: blocking.map((b) => b.identifier).join(", ") }],
+            });
+        }
+    }
+    // ── Triage: discussion only ───────────────────────────────────────
+    // Triage issues live in the inbox — no worktree/PR/checks apply yet. Show
+    // the comment thread (lazily fetched by the dashboard) so the user can read
+    // the back-and-forth before deciding to ask a question or send it to a tree.
+    if (triage) {
+        lines.push(ruleLine);
+        lines.push(sectionHeader("≡", "Comments", "cyan"));
+        if (comments === undefined) {
+            lines.push({ text: "  loading…", dim: true });
+        }
+        else if (comments.length === 0) {
+            lines.push({ text: "  no comments", dim: true });
+        }
+        else {
+            const renderComment = (c, depth) => {
+                const indent = "  ".repeat(depth + 1);
+                lines.push({
+                    text: "",
+                    segments: [
+                        { text: indent },
+                        { text: c.author, color: "cyan", bold: true },
+                        { text: `  ${new Date(c.createdAt).toLocaleDateString()}`, dim: true },
+                    ],
+                });
+                for (const bodyLine of c.body.trimEnd().split("\n")) {
+                    lines.push({ text: `${indent}${bodyLine}` });
+                }
+                lines.push({ text: "" });
+                for (const child of c.children)
+                    renderComment(child, depth + 1);
+            };
+            for (const c of comments)
+                renderComment(c, 0);
+        }
+        // Skip the worktree/PR/checks/reviews sections entirely for triage.
+        return renderLines(lines, scrollOffset, height, width);
+    }
     // ── Worktree ──────────────────────────────────────────────────────
     lines.push(ruleLine);
     if (worktree) {
@@ -468,6 +614,11 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
     // Action footer is rendered by the dashboard one row outside the panel,
     // alongside the global command bar, so left- and right-pane key hints sit
     // on the same row. The panel itself uses its full height for content.
+    return renderLines(lines, scrollOffset, height, width);
+}
+/** Scroll-clamp a built line list and render it into the panel box. Shared by
+ * the full detail view and the triage (discussion-only) view. */
+function renderLines(lines, scrollOffset, height, width) {
     const totalLines = lines.length;
     const canScroll = totalLines > height;
     const contentRows = canScroll ? height - 2 : height;

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

@@ -8,6 +8,14 @@ interface Props {
     width: number;
     /** Theme-adapted selection background (light/dark). Falls back to dark navy. */
     selectionBg?: string;
+    /** Right-column variant (row structure — and click→row mapping — is identical):
+     *   "default" — WT + CI status columns (Trees tab)
+     *   "triage"  — a colored SLA-countdown badge
+     *   "issues"  — a readiness glyph (ready / blocked by dependencies) */
+    variant?: "default" | "triage" | "issues";
+    /** 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>;
 }
 export type ListRow = {
     kind: "spacer";
@@ -28,5 +36,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, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, selectionBg, variant, deletingIds, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/lib/dashboard/IssueList.js

@@ -1,5 +1,7 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+import { formatSla, isSnoozed } from "./sla.js";
+import { issueReadiness } from "../trackers/types.js";
 function stateColor(type, name) {
     const n = name?.toLowerCase();
     if (n === "blocked")
@@ -71,7 +73,13 @@ export function buildIssueListRows(groups, flatIssues) {
             rows.push({ kind: "spacer" });
         rows.push({ kind: "header", name: group.name, count: totalIssues, isFirst: gi === 0 });
         for (const sg of group.statusGroups) {
-            rows.push({ kind: "status-header", name: sg.name, type: sg.type, count: sg.issues.length });
+            // A blank status name suppresses the per-status sub-header (used by the
+            // Triage tab, where the single group needs no "Triage" header). Both the
+            // renderer and the click→row mapper call this builder, so skipping a row
+            // here keeps their indices aligned automatically.
+            if (sg.name) {
+                rows.push({ kind: "status-header", name: sg.name, type: sg.type, count: sg.issues.length });
+            }
             for (const di of sg.issues) {
                 pushIssueWithChildren(di, 0);
             }
@@ -85,11 +93,29 @@ export function buildIssueListRows(groups, flatIssues) {
 // Glyphs are 1 char and rendered right-aligned within their column.
 const LEFT_FIXED = 1 + 1 + 1 + 2 + 11; // 16 — left-aligned columns
 const RIGHT_FIXED = 2 + 2 + 2; // 6 — WT + 2 spaces + CI
+// Triage variant: a single right-aligned SLA-countdown column. Widest badge is
+// "breached" (8 chars); pad/clamp everything to this so titles align.
+const SLA_COL_WIDTH = 8;
+// Issues variant: a single readiness glyph under a "RDY" header.
+const READY_COL_WIDTH = 3;
 const TITLE_GAP = 2; // minimum spacing between title and the right columns
-export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, selectionBg = "#1e3a5f", }) {
+function readinessGlyph(di) {
+    switch (issueReadiness(di.issue.blockedBy)) {
+        case "ready":
+            return { glyph: "✓", color: "green" };
+        case "blocked":
+            return { glyph: "⊘", color: "yellow" };
+        default:
+            return { glyph: "·", color: "gray" };
+    }
+}
+export default function IssueList({ groups, flatIssues, selectedIndex, scrollOffset, height, width, selectionBg = "#1e3a5f", variant = "default", deletingIds, }) {
+    const isTriage = variant === "triage";
+    const isIssues = variant === "issues";
+    const rightFixed = isTriage ? SLA_COL_WIDTH : isIssues ? READY_COL_WIDTH : RIGHT_FIXED;
     const rows = buildIssueListRows(groups, flatIssues);
     const visible = rows.slice(scrollOffset, scrollOffset + height);
-    const titleMaxWidth = Math.max(width - LEFT_FIXED - 1 /* leading space */ - RIGHT_FIXED - TITLE_GAP, 10);
+    const titleMaxWidth = Math.max(width - LEFT_FIXED - 1 /* leading space */ - rightFixed - TITLE_GAP, 10);
     return (_jsx(Box, { flexDirection: "column", width: width, height: height, children: _jsx(Box, { flexDirection: "column", height: height, children: visible.map((row, i) => {
                 if (row.kind === "spacer") {
                     return _jsx(Box, { height: 1 }, `sp-${i}`);
@@ -101,7 +127,7 @@ export default function IssueList({ groups, flatIssues, selectedIndex, scrollOff
                     // Label "WT CI" is 5 chars; the "W" lines up with the WT
                     // glyph at column (width - RIGHT_FIXED + 1).
                     const namePart = `${row.name}  ${row.count}`;
-                    const labelText = "WT CI";
+                    const labelText = isTriage ? "SLA" : isIssues ? "RDY" : "WT CI";
                     const labelPad = row.isFirst
                         ? Math.max(2, width - namePart.length - labelText.length)
                         : 0;
@@ -113,9 +139,13 @@ export default function IssueList({ groups, flatIssues, selectedIndex, scrollOff
                 const { issue, flatIndex, depth } = row;
                 const selected = flatIndex === selectedIndex;
                 const di = issue;
-                const sc = stateColor(di.issue.state.type, di.issue.state.name);
-                const prio = priorityMarker(di.issue.priority);
-                const work = workIndicator(di.worktree);
+                // Snoozed triage rows are parked work: grey them out (dot + id +
+                // title + SLA) so the active items the user should pick up stand out.
+                const snoozed = isTriage && isSnoozed(di.issue.snoozedUntilAt);
+                const sc = snoozed ? "gray" : stateColor(di.issue.state.type, di.issue.state.name);
+                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 nestPrefix = depth > 0 ? "  ".repeat(depth - 1) + "└ " : "";
                 const adjustedTitleWidth = Math.max(titleMaxWidth - nestPrefix.length, 5);
@@ -123,9 +153,16 @@ export default function IssueList({ groups, flatIssues, selectedIndex, scrollOff
                     ? di.issue.title.slice(0, adjustedTitleWidth - 1) + "…"
                     : di.issue.title;
                 const bg = selected ? selectionBg : undefined;
-                // Pad between title and the right columns so the W/CI markers stay
+                // Pad between title and the right columns so the markers stay
                 // pinned to the right edge regardless of title length.
-                const trailingPad = Math.max(0, width - LEFT_FIXED - 1 - nestPrefix.length - title.length - RIGHT_FIXED);
-                return (_jsxs(Box, { width: width, children: [_jsx(Text, { backgroundColor: bg, color: prio.color, children: prio.glyph }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: sc, children: "\u25CF" }), _jsx(Text, { backgroundColor: bg, children: "  " }), _jsxs(Text, { backgroundColor: bg, dimColor: true, children: [nestPrefix, di.issue.identifier.padEnd(10)] }), _jsxs(Text, { backgroundColor: bg, bold: selected, children: [" ", title] }), _jsx(Text, { backgroundColor: bg, children: " ".repeat(trailingPad) }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: work.color, children: work.glyph }), _jsx(Text, { backgroundColor: bg, children: "  " }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: ci.color, children: ci.glyph })] }, di.issue.identifier));
+                const trailingPad = Math.max(0, width - LEFT_FIXED - 1 - nestPrefix.length - title.length - rightFixed);
+                // Triage variant: a single right-aligned SLA-countdown badge in
+                // place of the WT/CI columns. Snoozed rows show it greyed.
+                const sla = isTriage ? formatSla(di.issue.slaBreachesAt) : null;
+                const slaColor = snoozed ? "gray" : sla?.color;
+                const slaText = (sla?.label ?? "").padStart(SLA_COL_WIDTH).slice(-SLA_COL_WIDTH);
+                // Issues variant: a single readiness glyph right-aligned under "RDY".
+                const ready = isIssues ? readinessGlyph(di) : null;
+                return (_jsxs(Box, { width: width, children: [_jsx(Text, { backgroundColor: bg, color: prio.color, children: prio.glyph }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: sc, children: "\u25CF" }), _jsx(Text, { backgroundColor: bg, children: "  " }), _jsxs(Text, { backgroundColor: bg, dimColor: true, children: [nestPrefix, di.issue.identifier.padEnd(10)] }), _jsxs(Text, { backgroundColor: bg, bold: selected, color: snoozed ? "gray" : undefined, children: [" ", title] }), _jsx(Text, { backgroundColor: bg, children: " ".repeat(trailingPad) }), isTriage ? (_jsx(Text, { backgroundColor: bg, color: slaColor, bold: !snoozed && sla?.urgent, children: slaText })) : isIssues ? (_jsx(Text, { backgroundColor: bg, color: ready?.color, children: `  ${ready?.glyph ?? " "}` })) : (_jsxs(_Fragment, { children: [_jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: work.color, children: work.glyph }), _jsx(Text, { backgroundColor: bg, children: "  " }), _jsx(Text, { backgroundColor: bg, children: " " }), _jsx(Text, { backgroundColor: bg, color: ci.color, children: ci.glyph })] }))] }, di.issue.identifier));
             }) }) }));
 }

package/dist/lib/dashboard/Overlays.js

@@ -30,15 +30,22 @@ const LEGEND = [
     {
         title: "Tabs & keys",
         rows: [
-            { glyph: "1", color: "cyan", meaning: "Issues tab — backlog / planning" },
-            { glyph: "2", color: "cyan", meaning: "Trees tab — worktrees in progress" },
-            { glyph: "3", color: "cyan", meaning: "Reviews tab — PRs awaiting your review" },
-            { glyph: "Tab", color: "cyan", meaning: "Cycle Issues → Trees → Reviews" },
+            { glyph: "1–4", color: "cyan", meaning: "Switch tab by number (Tab cycles)" },
+            {
+                glyph: "Triage",
+                color: "cyan",
+                meaning: "Incoming inbox — SLA countdown + comments (Linear only)",
+            },
+            { glyph: "Issues", color: "cyan", meaning: "Backlog / planning" },
+            { glyph: "Trees", color: "cyan", meaning: "Worktrees in progress" },
+            { glyph: "Reviews", color: "cyan", meaning: "PRs awaiting your review" },
             { glyph: "t", color: "cyan", meaning: "Switch / set up the issue tracker" },
             { glyph: "n", color: "cyan", meaning: "New issue (built-in tracker, Issues tab)" },
             { glyph: "e", color: "cyan", meaning: "Edit issue (built-in tracker, Issues tab)" },
             { glyph: "d", color: "red", meaning: "Delete issue (built-in) / remove worktree (Trees)" },
-            { glyph: "w", color: "cyan", meaning: "Start work (creates a worktree → Trees tab)" },
+            { glyph: "w", color: "cyan", meaning: "Start work / send to tree (creates a worktree)" },
+            { glyph: "a", color: "cyan", meaning: "Ask Claude about the issue + comments (Triage tab)" },
+            { glyph: "s", color: "cyan", meaning: "Triage on-call schedule (Triage tab)" },
         ],
     },
     {
@@ -56,6 +63,15 @@ 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: "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)" },
+            { glyph: "✓", color: "green", meaning: "RDY column (Issues): ready — no open blockers" },
+            {
+                glyph: "⊘",
+                color: "yellow",
+                meaning: "RDY column (Issues): blocked by an open dependency",
+            },
         ],
     },
     {

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

@@ -0,0 +1,16 @@
+import type { TriageSchedule } from "./types.js";
+type Seg = {
+    text: string;
+    color?: string;
+    bold?: boolean;
+    dim?: boolean;
+};
+/** Flatten the schedules into colored segment-lines. Exported for testing. */
+export declare function buildScheduleLines(schedules: TriageSchedule[]): Seg[][];
+export default function TriageScheduleOverlay({ schedules, scrollOffset, width, height, }: {
+    schedules: TriageSchedule[];
+    scrollOffset: number;
+    width: number;
+    height: number;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/dashboard/TriageScheduleOverlay.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+function fmt(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return iso;
+    return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+/** Flatten the schedules into colored segment-lines. Exported for testing. */
+export function buildScheduleLines(schedules) {
+    const lines = [];
+    if (schedules.length === 0) {
+        lines.push([{ text: "No triage on-call schedule found for your teams.", dim: true }]);
+        return lines;
+    }
+    schedules.forEach((sch, si) => {
+        if (si > 0)
+            lines.push([{ text: "" }]);
+        lines.push([
+            { text: "≡ ", color: "cyan", bold: true },
+            { text: sch.scheduleName, bold: true },
+            { text: `   ${sch.teamName}`, dim: true },
+        ]);
+        if (sch.currentName) {
+            lines.push([
+                { text: "  on call now: ", dim: true },
+                { text: sch.currentName, color: sch.currentIsMe ? "cyan" : "green", bold: true },
+                ...(sch.currentIsMe ? [{ text: "  ← you", color: "cyan" }] : []),
+            ]);
+        }
+        for (const sh of sch.shifts) {
+            const range = `${fmt(sh.startsAt)} – ${fmt(sh.endsAt)}`.padEnd(18);
+            const segs = [
+                { text: `  ${sh.isCurrent ? "●" : "·"} `, color: sh.isCurrent ? "green" : "gray" },
+                { text: range, dim: !sh.isCurrent && !sh.isMe },
+                {
+                    text: sh.name,
+                    color: sh.isCurrent ? "green" : sh.isMe ? "cyan" : undefined,
+                    bold: sh.isCurrent || sh.isMe,
+                },
+            ];
+            if (sh.isCurrent)
+                segs.push({ text: "  now", color: "green", bold: true });
+            else if (sh.isMe)
+                segs.push({ text: "  you", color: "cyan" });
+            lines.push(segs);
+        }
+    });
+    return lines;
+}
+export default function TriageScheduleOverlay({ schedules, scrollOffset, width, height, }) {
+    const all = buildScheduleLines(schedules);
+    // Title (1) + blank (1) leave the rest for the body. The footer/close hint is
+    // owned by the dashboard's global command-bar row, so the panel stays pure
+    // content and lines up with the left pane.
+    const bodyHeight = Math.max(1, height - 2);
+    const maxOffset = Math.max(0, all.length - bodyHeight);
+    const off = Math.min(scrollOffset, maxOffset);
+    const visible = all.slice(off, off + bodyHeight);
+    const clampSegs = (segs) => {
+        let remaining = width - 1;
+        const out = [];
+        for (const s of segs) {
+            if (remaining <= 0)
+                break;
+            if (s.text.length <= remaining) {
+                out.push(s);
+                remaining -= s.text.length;
+            }
+            else {
+                out.push({ ...s, text: s.text.slice(0, Math.max(0, remaining - 1)) + "…" });
+                remaining = 0;
+            }
+        }
+        return out;
+    };
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Triage on-call schedule" }), _jsx(Text, { children: " " }), visible.map((segs, i) => (_jsx(Box, { children: _jsx(Text, { children: clampSegs(segs).map((s, j) => (_jsx(Text, { color: s.color, bold: s.bold, dimColor: s.dim, children: s.text || " " }, j))) }) }, i))), off + bodyHeight < all.length ? _jsx(Text, { dimColor: true, children: "\u2193 more (press s to scroll)" }) : null] }));
+}

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

@@ -4,6 +4,8 @@ export declare function loadDashboardData(repoRoot: string): Promise<{
     flatIssues: DashboardIssue[];
     treeGroups: ProjectGroup[];
     flatTrees: DashboardIssue[];
+    triageGroups: ProjectGroup[];
+    flatTriage: DashboardIssue[];
 }>;
 export declare function loadReviewsData(repoRoot: string): Promise<{
     flatReviews: EnrichedReviewPR[];

package/dist/lib/dashboard/data.js

@@ -3,6 +3,7 @@ import { runAsync } from "../exec.js";
 import { readMainAgentTodos, findClaudeSessionCwd } from "../claude-todos.js";
 import { getPRInfoAsync, getPRChecksAsync, getPRReviewsAsync, getPRConversationCommentsAsync, getPRViewAsync, getReviewRequestedPRsAsync, getRepoNameAsync, getGitHubUserNameAsync, } from "../github.js";
 import { getIssueTracker, getCandidateTrackers } from "../trackers/index.js";
+import { isSnoozed } from "./sla.js";
 export async function loadDashboardData(repoRoot) {
     // Fetch issues and worktrees in parallel
     const tracker = getIssueTracker(repoRoot);
@@ -254,15 +255,49 @@ export async function loadDashboardData(repoRoot) {
     function flatten(g) {
         return g.flatMap((grp) => grp.statusGroups.flatMap((sg) => sg.issues.flatMap(flattenWithChildren)));
     }
-    // ── Partition: Issues tab (backlog/planning) vs Trees tab (work in
-    // progress). A tracker issue with no worktree is backlog; once it gains a
+    // ── Partition: Triage / Issues (backlog) / Trees (work in progress).
+    // A tracker issue with no worktree is backlog — unless the active tracker
+    // has a triage inbox and the issue sits in it (state.type === "triage"), in
+    // which case it goes to the Triage tab instead. Once any issue gains a
     // worktree it moves to the Trees tab. Children always have a worktree, so
     // they only ever appear nested in Trees. Main-repo + orphaned worktrees
     // belong to Trees (they're active checkouts, not backlog).
-    const backlogIssues = enriched.filter((di) => !di.worktree);
+    const triageEnabled = tracker.supportsTriage === true;
+    const isTriage = (di) => triageEnabled && !di.worktree && di.issue.state.type === "triage";
+    const triageIssues = enriched.filter(isTriage);
+    const backlogIssues = enriched.filter((di) => !di.worktree && !isTriage(di));
     const treeIssues = enriched.filter((di) => di.worktree);
+    // Order the triage inbox so the work that needs attention now is on top:
+    // active (non-snoozed) items first, snoozed parked at the bottom; within
+    // each, by SLA breach time ascending (breached/soonest first), SLA-less last.
+    const slaRank = (di) => {
+        const s = di.issue.slaBreachesAt;
+        const t = s ? Date.parse(s) : NaN;
+        return Number.isNaN(t) ? Number.POSITIVE_INFINITY : t;
+    };
+    triageIssues.sort((a, b) => {
+        const sa = isSnoozed(a.issue.snoozedUntilAt) ? 1 : 0;
+        const sb = isSnoozed(b.issue.snoozedUntilAt) ? 1 : 0;
+        if (sa !== sb)
+            return sa - sb;
+        return slaRank(a) - slaRank(b);
+    });
     const groups = buildProjectGroups(backlogIssues);
     const flatIssues = flatten(groups);
+    // Triage is scoped to issues assigned to the viewer, so project grouping and
+    // the redundant "Triage" status header add noise. Render one flat group under
+    // a single "Assigned to me" header (its column label is the SLA badge). The
+    // empty status-group name makes IssueList skip the per-status sub-header.
+    const triageGroups = triageIssues.length
+        ? [
+            {
+                name: "Assigned to me",
+                id: null,
+                statusGroups: [{ name: "", type: "triage", issues: triageIssues }],
+            },
+        ]
+        : [];
+    const flatTriage = flatten(triageGroups);
     const treeGroups = buildProjectGroups(treeIssues);
     const topLevelOrphans = orphans.filter((di) => !childTicketIds.has(di.issue.identifier));
     if (topLevelOrphans.length > 0) {
@@ -286,7 +321,7 @@ export async function loadDashboardData(repoRoot) {
         });
         flatTrees.unshift(mainEntry);
     }
-    return { groups, flatIssues, treeGroups, flatTrees };
+    return { groups, flatIssues, treeGroups, flatTrees, triageGroups, flatTriage };
 }
 /** Build the synthetic dashboard row for the main repo checkout — the
  * non-worktree clone that the user typically commits master/main from.