santree 0.7.0 → 0.7.2

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 { formatDueDate } from "./due.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,6 +186,27 @@ 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);
@@ -171,6 +221,19 @@ export default function DetailPanel({ issue, scrollOffset, height, width, creati
         heroSegs.push({ text: li.labels.join(", "), dim: true });
     }
     lines.push({ text: "", segments: heroSegs });
+    // ── Due date ──────────────────────────────────────────────────────
+    // Urgency-coded; shown whenever the issue carries one (most relevant on the
+    // Triage tab, harmless elsewhere).
+    const due = formatDueDate(li.dueDate);
+    if (due) {
+        lines.push({
+            text: "",
+            segments: [
+                { text: "◷ ", color: due.color, bold: due.urgent },
+                { text: due.label, color: due.color, bold: due.urgent },
+            ],
+        });
+    }
     // ── Description ───────────────────────────────────────────────────
     if (li.description) {
         lines.push({ text: "" });
@@ -178,6 +241,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 +606,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 due-date 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 { formatDueDate } from "./due.js";
+import { issueReadiness } from "../trackers/types.js";
 function stateColor(type, name) {
     const n = name?.toLowerCase();
     if (n === "blocked")
@@ -85,11 +87,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 due-date column. Widest badge is
+// "⚠ overdue 99d" (13 chars); pad/clamp everything to this so titles align.
+const DUE_COL_WIDTH = 13;
+// 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 ? DUE_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 +121,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 ? "DUE" : isIssues ? "RDY" : "WT CI";
                     const labelPad = row.isFirst
                         ? Math.max(2, width - namePart.length - labelText.length)
                         : 0;
@@ -115,7 +135,8 @@ export default function IssueList({ groups, flatIssues, selectedIndex, scrollOff
                 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);
+                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 +144,15 @@ 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 due-date badge in place
+                // of the WT/CI columns.
+                const due = isTriage ? formatDueDate(di.issue.dueDate) : null;
+                const dueText = (due?.label ?? "").padStart(DUE_COL_WIDTH).slice(-DUE_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, children: [" ", title] }), _jsx(Text, { backgroundColor: bg, children: " ".repeat(trailingPad) }), isTriage ? (_jsx(Text, { backgroundColor: bg, color: due?.color, bold: due?.urgent, children: dueText })) : 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 — due dates + 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,14 @@ 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: "DUE column (Triage): overdue / due today" },
+            { glyph: "◷", color: "yellow", meaning: "DUE column (Triage): due within 2 days" },
+            { 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

@@ -254,15 +254,37 @@ 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);
+    // Surface the most pressing triage items first: by due date ascending
+    // (overdue/soonest first), undated last. `dueDate` is `YYYY-MM-DD` so a
+    // plain string compare is chronological. buildProjectGroups preserves this
+    // order within each status group.
+    triageIssues.sort((a, b) => {
+        const da = a.issue.dueDate ?? null;
+        const db = b.issue.dueDate ?? null;
+        if (da && db)
+            return da < db ? -1 : da > db ? 1 : 0;
+        if (da)
+            return -1;
+        if (db)
+            return 1;
+        return 0;
+    });
     const groups = buildProjectGroups(backlogIssues);
     const flatIssues = flatten(groups);
+    const triageGroups = buildProjectGroups(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 +308,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.

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

@@ -0,0 +1,24 @@
+/**
+ * Due-date formatting for the Triage tab. Turns Linear's `YYYY-MM-DD`
+ * `dueDate` string into a short, urgency-coded badge used by both the issue
+ * list (right column) and the detail panel.
+ *
+ * Urgency buckets (by whole calendar days from today, local time):
+ *   - overdue (< 0)        → red,    "⚠ overdue Nd"
+ *   - due today (0)        → red,    "⚠ due today"
+ *   - soon (1–2 days)      → yellow, "due in Nd"
+ *   - later (≥ 3 days)     → gray,   "due Mon D"
+ *
+ * Returns null when there is no due date so callers can render nothing.
+ */
+export interface DueInfo {
+    /** Short badge text, e.g. "⚠ overdue 3d" or "due Jun 12". */
+    label: string;
+    /** Ink color name keyed to urgency. */
+    color: "red" | "yellow" | "gray";
+    /** True for overdue/today — the cases worth a warning glyph. */
+    urgent: boolean;
+    /** Whole days until due (negative when overdue). */
+    days: number;
+}
+export declare function formatDueDate(dueDate: string | null | undefined, now?: Date): DueInfo | null;

package/dist/lib/dashboard/due.js

@@ -0,0 +1,32 @@
+/** Whole-day difference between two dates, ignoring time-of-day. */
+function dayDiff(from, to) {
+    const a = Date.UTC(from.getFullYear(), from.getMonth(), from.getDate());
+    const b = Date.UTC(to.getFullYear(), to.getMonth(), to.getDate());
+    return Math.round((b - a) / 86_400_000);
+}
+export function formatDueDate(dueDate, now = new Date()) {
+    if (!dueDate)
+        return null;
+    // Parse `YYYY-MM-DD` as a local date (not UTC) so "today" matches the user's
+    // wall clock. `new Date("2026-06-12")` would parse as UTC midnight; build the
+    // date from parts instead.
+    const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(dueDate);
+    if (!m)
+        return null;
+    const due = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+    if (Number.isNaN(due.getTime()))
+        return null;
+    const days = dayDiff(now, due);
+    const monthDay = due.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    if (days < 0) {
+        const n = Math.abs(days);
+        return { label: `⚠ overdue ${n}d`, color: "red", urgent: true, days };
+    }
+    if (days === 0) {
+        return { label: "⚠ due today", color: "red", urgent: true, days };
+    }
+    if (days <= 2) {
+        return { label: `due in ${days}d`, color: "yellow", urgent: false, days };
+    }
+    return { label: `due ${monthDay}`, color: "gray", urgent: false, days };
+}