santree 0.7.0 → 0.7.3

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

@@ -0,0 +1,27 @@
+/**
+ * Triage SLA + snooze formatting for the Triage tab. Linear issues in triage
+ * carry an `slaBreachesAt` ISO timestamp (when the response SLA is breached);
+ * we render a short, urgency-coded countdown badge — the same "2d 23h" / "13h"
+ * shape Linear itself shows — used by both the issue list (right column) and
+ * the detail panel.
+ *
+ * Urgency buckets (by time until breach):
+ *   - breached (≤ 0)        → red,    "breached"
+ *   - imminent (< 24h)      → red,    "5h" / "45m"
+ *   - soon (< 48h)          → yellow, "1d 6h"
+ *   - later (≥ 48h)         → gray,   "3d 2h"
+ *
+ * Returns null when there is no SLA so callers can render nothing.
+ */
+export interface SlaInfo {
+    /** Short badge text, e.g. "2d 23h", "13h", or "breached". */
+    label: string;
+    /** Ink color name keyed to urgency. */
+    color: "red" | "yellow" | "gray";
+    /** True for breached / < 24h — the cases worth a bold warning. */
+    urgent: boolean;
+}
+export declare function formatSla(slaBreachesAt: string | null | undefined, now?: Date): SlaInfo | null;
+/** True when the issue is snoozed past the current moment. A snoozed triage
+ * issue is parked — the UI greys it and sinks it below active work. */
+export declare function isSnoozed(snoozedUntilAt: string | null | undefined, now?: Date): boolean;

package/dist/lib/dashboard/sla.js

@@ -0,0 +1,35 @@
+export function formatSla(slaBreachesAt, now = new Date()) {
+    if (!slaBreachesAt)
+        return null;
+    const breach = Date.parse(slaBreachesAt);
+    if (Number.isNaN(breach))
+        return null;
+    const ms = breach - now.getTime();
+    if (ms <= 0)
+        return { label: "breached", color: "red", urgent: true };
+    const totalMin = Math.floor(ms / 60_000);
+    const days = Math.floor(totalMin / 1440);
+    const hours = Math.floor((totalMin % 1440) / 60);
+    const mins = totalMin % 60;
+    let label;
+    if (days >= 1)
+        label = `${days}d ${hours}h`;
+    else if (hours >= 1)
+        label = `${hours}h`;
+    else
+        label = `${mins}m`;
+    const hoursLeft = ms / 3_600_000;
+    if (hoursLeft < 24)
+        return { label, color: "red", urgent: true };
+    if (hoursLeft < 48)
+        return { label, color: "yellow", urgent: false };
+    return { label, color: "gray", urgent: false };
+}
+/** True when the issue is snoozed past the current moment. A snoozed triage
+ * issue is parked — the UI greys it and sinks it below active work. */
+export function isSnoozed(snoozedUntilAt, now = new Date()) {
+    if (!snoozedUntilAt)
+        return false;
+    const until = Date.parse(snoozedUntilAt);
+    return !Number.isNaN(until) && until > now.getTime();
+}

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

@@ -1,7 +1,7 @@
 import type { PRInfo, PRCheck, PRReview, PRConversationComment, SearchPR } from "../github.js";
 import type { ClaudeTodo } from "../claude-todos.js";
-import type { AssignedIssue, Issue } from "../trackers/types.js";
-export type { AssignedIssue, Issue } from "../trackers/types.js";
+import type { AssignedIssue, Comment, Issue, TriageSchedule } from "../trackers/types.js";
+export type { AssignedIssue, Comment, Issue, TriageSchedule } from "../trackers/types.js";
 export interface WorktreeInfo {
     path: string;
     branch: string;
@@ -72,8 +72,11 @@ export interface EnrichedReviewPR {
      * Null when the user hasn't set one or the lookup failed. */
     authorName: string | null;
 }
-export type DashboardTab = "issues" | "trees" | "reviews";
-export type ActionOverlay = "mode-select" | "context-input" | "base-select" | "confirm-delete" | "confirm-setup" | "commit" | "pr-create" | "diff" | "help" | "tracker-select" | "issue-form" | "confirm-delete-issue" | null;
+export type DashboardTab = "triage" | "issues" | "trees" | "reviews";
+export type ActionOverlay = "mode-select" | "context-input" | "base-select" | "confirm-delete" | "confirm-setup" | "commit" | "pr-create" | "diff" | "help" | "tracker-select" | "issue-form" | "confirm-delete-issue" | "triage-ask" | "triage-schedule" | null;
+/** Triage "ask Claude" flow sub-phase. "input" is owned by MultilineTextArea
+ * (Ctrl+D submit / Ctrl+G cancel); the rest are driven by the outer handler. */
+export type TriageAskPhase = "input" | "running" | "answer" | "error";
 /** Tracker-selection overlay sub-phase: pick a tracker, then (for Linear with
  * multiple authenticated workspaces) pick the org. */
 export type TrackerSelectPhase = "root" | "linear-org";
@@ -96,6 +99,15 @@ export interface DiffFile {
 }
 export type CommitPhase = "idle" | "confirm-stage" | "choose-mode" | "filling" | "awaiting-message" | "committing" | "pushing" | "done" | "error";
 export type PrCreatePhase = "idle" | "choose-mode" | "pushing" | "filling" | "review" | "confirm" | "creating" | "done" | "error";
+/** Per-worktree deletion progress. Deletions run concurrently (fire `d`, move
+ * on, fire `d` again) so each tracks its own staged log + phase; the detail
+ * pane renders the entry for the selected worktree. Entries are pruned on the
+ * next data refresh once the worktree is gone (see SET_DATA). */
+export interface DeleteStatus {
+    logs: string;
+    phase: "removing" | "done" | "error";
+    error: string | null;
+}
 export interface DashboardState {
     activeTab: DashboardTab;
     groups: ProjectGroup[];
@@ -112,6 +124,25 @@ export interface DashboardState {
     treeSelectedIndex: number;
     treeListScrollOffset: number;
     treeDetailScrollOffset: number;
+    triageGroups: ProjectGroup[];
+    flatTriage: DashboardIssue[];
+    triageSelectedIndex: number;
+    triageListScrollOffset: number;
+    triageDetailScrollOffset: number;
+    /** Lazily-fetched comments per triage issue identifier. Absent = not yet
+     * loaded (detail panel shows "loading…"); present (possibly empty) = loaded. */
+    triageCommentsById: Record<string, Comment[]>;
+    /** Triage on-call rotations for the viewer's teams (Linear). Loaded on
+     * refresh; shown via the `triage-schedule` overlay and a compact line in the
+     * triage detail pane. */
+    triageSchedules: TriageSchedule[];
+    triageScheduleScrollOffset: number;
+    triageAskTicketId: string | null;
+    triageAskPhase: TriageAskPhase;
+    triageAskQuestion: string;
+    triageAskAnswer: string | null;
+    triageAskError: string | null;
+    triageAskScrollOffset: number;
     trackerSelectPhase: TrackerSelectPhase;
     trackerSelectIndex: number;
     trackerSelectOrgs: TrackerOrgOption[];
@@ -130,7 +161,8 @@ export interface DashboardState {
     creatingForTicket: string | null;
     creationLogs: string;
     creationError: string | null;
-    deletingForTicket: string | null;
+    /** In-flight (and just-finished) worktree deletions, keyed by ticket id. */
+    deletingTickets: Record<string, DeleteStatus>;
     commitPhase: CommitPhase;
     commitMessage: string;
     commitError: string | null;
@@ -183,6 +215,8 @@ export type DashboardAction = {
     flatIssues: DashboardIssue[];
     treeGroups: ProjectGroup[];
     flatTrees: DashboardIssue[];
+    triageGroups: ProjectGroup[];
+    flatTriage: DashboardIssue[];
 } | {
     type: "SELECT";
     index: number;
@@ -195,6 +229,48 @@ export type DashboardAction = {
 } | {
     type: "TREE_SCROLL_DETAIL";
     offset: number;
+} | {
+    type: "TRIAGE_SELECT";
+    index: number;
+} | {
+    type: "TRIAGE_SCROLL_LIST";
+    offset: number;
+} | {
+    type: "TRIAGE_SCROLL_DETAIL";
+    offset: number;
+} | {
+    type: "TRIAGE_COMMENTS_LOADED";
+    id: string;
+    comments: Comment[];
+} | {
+    type: "SET_TRIAGE_SCHEDULES";
+    schedules: TriageSchedule[];
+} | {
+    type: "TRIAGE_SCHEDULE_OPEN";
+} | {
+    type: "TRIAGE_SCHEDULE_SCROLL";
+    offset: number;
+} | {
+    type: "TRIAGE_SCHEDULE_CLOSE";
+} | {
+    type: "TRIAGE_ASK_OPEN";
+    ticketId: string;
+} | {
+    type: "TRIAGE_ASK_CHANGE";
+    value: string;
+} | {
+    type: "TRIAGE_ASK_RUN";
+} | {
+    type: "TRIAGE_ASK_ANSWER";
+    answer: string;
+} | {
+    type: "TRIAGE_ASK_ERROR";
+    error: string;
+} | {
+    type: "TRIAGE_ASK_SCROLL";
+    offset: number;
+} | {
+    type: "TRIAGE_ASK_CLOSE";
 } | {
     type: "TRACKER_SELECT_OPEN";
 } | {
@@ -268,8 +344,17 @@ export type DashboardAction = {
 } | {
     type: "DELETE_START";
     ticketId: string;
+} | {
+    type: "DELETE_LOG";
+    ticketId: string;
+    logs: string;
 } | {
     type: "DELETE_DONE";
+    ticketId: string;
+} | {
+    type: "DELETE_ERROR";
+    ticketId: string;
+    error: string;
 } | {
     type: "COMMIT_START";
     /** Null when committing on a non-ticket branch (e.g. the main

package/dist/lib/dashboard/types.js

@@ -15,6 +15,20 @@ export const initialState = {
     treeSelectedIndex: 0,
     treeListScrollOffset: 0,
     treeDetailScrollOffset: 0,
+    triageGroups: [],
+    flatTriage: [],
+    triageSelectedIndex: 0,
+    triageListScrollOffset: 0,
+    triageDetailScrollOffset: 0,
+    triageCommentsById: {},
+    triageSchedules: [],
+    triageScheduleScrollOffset: 0,
+    triageAskTicketId: null,
+    triageAskPhase: "input",
+    triageAskQuestion: "",
+    triageAskAnswer: null,
+    triageAskError: null,
+    triageAskScrollOffset: 0,
     trackerSelectPhase: "root",
     trackerSelectIndex: 0,
     trackerSelectOrgs: [],
@@ -33,7 +47,7 @@ export const initialState = {
     creatingForTicket: null,
     creationLogs: "",
     creationError: null,
-    deletingForTicket: null,
+    deletingTickets: {},
     commitPhase: "idle",
     commitMessage: "",
     commitError: null,
@@ -91,19 +105,36 @@ export function reducer(state, action) {
                 if (found >= 0)
                     newTreeIndex = found;
             }
+            const prevTriageId = state.flatTriage[state.triageSelectedIndex]?.issue.identifier;
+            let newTriageIndex = 0;
+            if (prevTriageId) {
+                const found = action.flatTriage.findIndex((d) => d.issue.identifier === prevTriageId);
+                if (found >= 0)
+                    newTriageIndex = found;
+            }
+            // Prune delete-progress entries whose worktree is gone (a successful
+            // removal). In-progress ("removing") and failed ("error") deletions
+            // keep their row, so their entries survive and stay visible.
+            const presentTreeIds = new Set(action.flatTrees.map((d) => d.issue.identifier));
+            const deletingTickets = Object.fromEntries(Object.entries(state.deletingTickets).filter(([id]) => presentTreeIds.has(id)));
             return {
                 ...state,
                 groups: action.groups,
                 flatIssues: action.flatIssues,
                 treeGroups: action.treeGroups,
                 flatTrees: action.flatTrees,
+                triageGroups: action.triageGroups,
+                flatTriage: action.flatTriage,
+                deletingTickets,
                 selectedIndex: newIndex,
                 treeSelectedIndex: newTreeIndex,
+                triageSelectedIndex: newTriageIndex,
                 loading: false,
                 refreshing: false,
                 error: null,
                 detailScrollOffset: 0,
                 treeDetailScrollOffset: 0,
+                triageDetailScrollOffset: 0,
             };
         }
         case "TREE_SELECT":
@@ -112,6 +143,62 @@ export function reducer(state, action) {
             return { ...state, treeListScrollOffset: action.offset };
         case "TREE_SCROLL_DETAIL":
             return { ...state, treeDetailScrollOffset: action.offset };
+        case "TRIAGE_SELECT":
+            return { ...state, triageSelectedIndex: action.index, triageDetailScrollOffset: 0 };
+        case "TRIAGE_SCROLL_LIST":
+            return { ...state, triageListScrollOffset: action.offset };
+        case "TRIAGE_SCROLL_DETAIL":
+            return { ...state, triageDetailScrollOffset: action.offset };
+        case "TRIAGE_COMMENTS_LOADED":
+            return {
+                ...state,
+                triageCommentsById: { ...state.triageCommentsById, [action.id]: action.comments },
+            };
+        case "SET_TRIAGE_SCHEDULES":
+            return { ...state, triageSchedules: action.schedules };
+        case "TRIAGE_SCHEDULE_OPEN":
+            return { ...state, overlay: "triage-schedule", triageScheduleScrollOffset: 0 };
+        case "TRIAGE_SCHEDULE_SCROLL":
+            return { ...state, triageScheduleScrollOffset: action.offset };
+        case "TRIAGE_SCHEDULE_CLOSE":
+            return { ...state, overlay: null };
+        case "TRIAGE_ASK_OPEN":
+            return {
+                ...state,
+                overlay: "triage-ask",
+                triageAskTicketId: action.ticketId,
+                triageAskPhase: "input",
+                triageAskQuestion: "",
+                triageAskAnswer: null,
+                triageAskError: null,
+                triageAskScrollOffset: 0,
+            };
+        case "TRIAGE_ASK_CHANGE":
+            return { ...state, triageAskQuestion: action.value };
+        case "TRIAGE_ASK_RUN":
+            return { ...state, triageAskPhase: "running", triageAskError: null };
+        case "TRIAGE_ASK_ANSWER":
+            return {
+                ...state,
+                triageAskPhase: "answer",
+                triageAskAnswer: action.answer,
+                triageAskScrollOffset: 0,
+            };
+        case "TRIAGE_ASK_ERROR":
+            return { ...state, triageAskPhase: "error", triageAskError: action.error };
+        case "TRIAGE_ASK_SCROLL":
+            return { ...state, triageAskScrollOffset: action.offset };
+        case "TRIAGE_ASK_CLOSE":
+            return {
+                ...state,
+                overlay: null,
+                triageAskTicketId: null,
+                triageAskPhase: "input",
+                triageAskQuestion: "",
+                triageAskAnswer: null,
+                triageAskError: null,
+                triageAskScrollOffset: 0,
+            };
         case "TRACKER_SELECT_OPEN":
             return {
                 ...state,
@@ -216,9 +303,47 @@ export function reducer(state, action) {
                 baseSelectChosen: null,
             };
         case "DELETE_START":
-            return { ...state, deletingForTicket: action.ticketId };
-        case "DELETE_DONE":
-            return { ...state, deletingForTicket: null };
+            return {
+                ...state,
+                deletingTickets: {
+                    ...state.deletingTickets,
+                    [action.ticketId]: { logs: "", phase: "removing", error: null },
+                },
+            };
+        case "DELETE_LOG": {
+            const prev = state.deletingTickets[action.ticketId];
+            if (!prev)
+                return state;
+            return {
+                ...state,
+                deletingTickets: {
+                    ...state.deletingTickets,
+                    [action.ticketId]: { ...prev, logs: prev.logs + action.logs },
+                },
+            };
+        }
+        case "DELETE_DONE": {
+            const prev = state.deletingTickets[action.ticketId];
+            if (!prev)
+                return state;
+            return {
+                ...state,
+                deletingTickets: {
+                    ...state.deletingTickets,
+                    [action.ticketId]: { ...prev, phase: "done" },
+                },
+            };
+        }
+        case "DELETE_ERROR": {
+            const prev = state.deletingTickets[action.ticketId] ?? { logs: "" };
+            return {
+                ...state,
+                deletingTickets: {
+                    ...state.deletingTickets,
+                    [action.ticketId]: { logs: prev.logs, phase: "error", error: action.error },
+                },
+            };
+        }
         case "COMMIT_START":
             return {
                 ...state,

package/dist/lib/git.d.ts

@@ -74,7 +74,7 @@ export declare function createWorktree(branchName: string, baseBranch: string, r
  * Runs: `git worktree remove [--force] <path>` then `git branch -d|-D <branchName>`
  * Returns { success: false, error } if worktree not found or git fails.
  */
-export declare function removeWorktree(branchName: string, repoRoot: string, force?: boolean): Promise<{
+export declare function removeWorktree(branchName: string, repoRoot: string, force?: boolean, onProgress?: (message: string) => void): Promise<{
     success: boolean;
     error?: string;
 }>;

package/dist/lib/git.js

@@ -191,13 +191,15 @@ export async function createWorktree(branchName, baseBranch, repoRoot) {
  * Runs: `git worktree remove [--force] <path>` then `git branch -d|-D <branchName>`
  * Returns { success: false, error } if worktree not found or git fails.
  */
-export async function removeWorktree(branchName, repoRoot, force = false) {
+export async function removeWorktree(branchName, repoRoot, force = false, onProgress) {
+    const report = onProgress ?? (() => { });
     // Find the worktree by branch name using git's worktree tracking
     const worktreePath = getWorktreePath(branchName);
     if (!worktreePath) {
         return { success: false, error: `Worktree not found: ${branchName}` };
     }
     try {
+        report("Removing worktree…");
         const forceFlag = force ? "--force" : "";
         await execAsync(`git worktree remove ${forceFlag} "${worktreePath}"`, {
             cwd: repoRoot,
@@ -205,6 +207,7 @@ export async function removeWorktree(branchName, repoRoot, force = false) {
         // Clean up any remaining files (untracked files, node_modules, etc.)
         // git worktree remove doesn't delete untracked files
         if (fs.existsSync(worktreePath)) {
+            report("Cleaning up leftover files…");
             // Fix permissions first (node_modules often has restricted perms)
             try {
                 execSync(`chmod -R u+w "${worktreePath}"`, { stdio: "ignore" });
@@ -225,6 +228,7 @@ export async function removeWorktree(branchName, repoRoot, force = false) {
             clearSessionState(repoRoot, ticketId);
         }
         // Also delete the branch
+        report("Deleting branch…");
         const deleteFlag = force ? "-D" : "-d";
         try {
             await execAsync(`git branch ${deleteFlag} "${branchName}"`, {
@@ -233,7 +237,9 @@ export async function removeWorktree(branchName, repoRoot, force = false) {
         }
         catch {
             // Branch deletion failed, but worktree was removed
+            report("Worktree removed (branch delete skipped)");
         }
+        report("Done");
         return { success: true };
     }
     catch (e) {

package/dist/lib/trackers/linear/api.d.ts

@@ -1,4 +1,5 @@
-import type { AssignedIssue, Issue } from "../types.js";
+import type { AssignedIssue, Issue, TriageSchedule } from "../types.js";
 export declare const PRIORITY_MAP: Record<number, string>;
 export declare function fetchIssue(ticketId: string, accessToken: string): Promise<Issue | null>;
+export declare function fetchTriageSchedules(accessToken: string): Promise<TriageSchedule[]>;
 export declare function fetchAssignedIssues(accessToken: string): Promise<AssignedIssue[] | null>;

package/dist/lib/trackers/linear/api.js

@@ -6,6 +6,13 @@ export const PRIORITY_MAP = {
     3: "Medium",
     4: "Low",
 };
+// Workflow states whose issues should never appear in the assigned-work list,
+// matched by name (case-insensitive) regardless of their configured `type`.
+// Linear ships a default "Duplicate" state, but workspaces sometimes type it
+// as non-terminal (backlog/unstarted) rather than `canceled`, so it slips past
+// the query's `type: { nin: ["completed", "canceled"] }` filter and clutters
+// the backlog. These are resolution states — hide them everywhere.
+const HIDDEN_STATE_NAMES = new Set(["duplicate"]);
 async function graphqlQuery(query, variables, accessToken) {
     const res = await fetch(LINEAR_GRAPHQL_URL, {
         method: "POST",
@@ -30,6 +37,8 @@ query GetIssue($id: String!) {
     title
     description
     url
+    slaBreachesAt
+    snoozedUntilAt
     state { name type }
     priority
     labels { nodes { name } }
@@ -65,21 +74,33 @@ query AssignedIssues {
         title
         description
         url
+        slaBreachesAt
+        snoozedUntilAt
         priority
         state { name type }
         labels { nodes { name } }
         project { id name }
+        relations(first: 10) { nodes { type relatedIssue { identifier state { type } } } }
+        inverseRelations(first: 10) { nodes { type issue { identifier state { type } } } }
       }
     }
   }
 }
 `;
+const TERMINAL_STATE_TYPES = new Set(["completed", "canceled"]);
+function refOf(issue) {
+    if (!issue?.identifier)
+        return null;
+    return { identifier: issue.identifier, done: TERMINAL_STATE_TYPES.has(issue.state?.type ?? "") };
+}
 function mapAssigned(issue) {
     return {
         identifier: issue.identifier,
         title: issue.title,
         description: issue.description ?? null,
         url: issue.url,
+        slaBreachesAt: issue.slaBreachesAt ?? null,
+        snoozedUntilAt: issue.snoozedUntilAt ?? null,
         priority: issue.priority,
         priorityLabel: PRIORITY_MAP[issue.priority] ?? "No priority",
         state: {
@@ -89,6 +110,23 @@ function mapAssigned(issue) {
         labels: (issue.labels?.nodes ?? []).map((l) => l.name),
         projectId: issue.project?.id ?? null,
         projectName: issue.project?.name ?? null,
+        // Dependency relations. `inverseRelations` of type "blocks" point at this
+        // issue → those are its blockers; `relations` of type "blocks" point away
+        // → those are what it blocks. Left undefined when the query didn't fetch
+        // relations (e.g. the single-issue ISSUE_QUERY) so callers can tell
+        // "no blockers" from "unknown".
+        blockedBy: issue.inverseRelations
+            ? (issue.inverseRelations.nodes ?? [])
+                .filter((r) => r.type === "blocks")
+                .map((r) => refOf(r.issue))
+                .filter((r) => r !== null)
+            : undefined,
+        blocking: issue.relations
+            ? (issue.relations.nodes ?? [])
+                .filter((r) => r.type === "blocks")
+                .map((r) => refOf(r.relatedIssue))
+                .filter((r) => r !== null)
+            : undefined,
     };
 }
 function mapComments(nodes) {
@@ -119,10 +157,111 @@ export async function fetchIssue(ticketId, accessToken) {
         comments: mapComments(data.issue.comments?.nodes ?? []),
     };
 }
+// ── Triage on-call schedules ──────────────────────────────────────────
+// Linear's "Triage responsibility" can be backed by a time schedule (a weekly
+// on-call rotation). We surface the schedules for the teams the viewer belongs
+// to. Schedule entries reference users by id only, so a follow-up `users`
+// lookup resolves display names.
+const TRIAGE_SCHEDULES_QUERY = `
+query TriageSchedules {
+  viewer {
+    id
+    teamMemberships(first: 100) {
+      nodes {
+        team {
+          key
+          name
+          triageResponsibility {
+            currentUser { id }
+            timeSchedule {
+              name
+              entries { startsAt endsAt userId userEmail }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`;
+/** Resolve user ids → display names via a single `users` query. */
+async function resolveUserNames(ids, accessToken) {
+    if (ids.length === 0)
+        return {};
+    const query = `query ResolveUsers($ids: [ID!]!) {
+		users(filter: { id: { in: $ids } }, first: 250) { nodes { id displayName } }
+	}`;
+    const data = (await graphqlQuery(query, { ids }, accessToken));
+    const map = {};
+    for (const u of data?.users?.nodes ?? [])
+        map[u.id] = u.displayName;
+    return map;
+}
+export async function fetchTriageSchedules(accessToken) {
+    const data = (await graphqlQuery(TRIAGE_SCHEDULES_QUERY, {}, accessToken));
+    const viewerId = data?.viewer?.id ?? null;
+    const memberships = data?.viewer?.teamMemberships?.nodes ?? [];
+    // Keep only teams whose triage responsibility is backed by a time schedule
+    // with at least one entry.
+    const teams = memberships
+        .map((m) => m.team)
+        .filter((t) => !!t && (t.triageResponsibility?.timeSchedule?.entries?.length ?? 0) > 0);
+    if (teams.length === 0)
+        return [];
+    // Resolve every referenced user id in one batch.
+    const ids = new Set();
+    for (const t of teams) {
+        const tr = t.triageResponsibility;
+        if (tr.currentUser?.id)
+            ids.add(tr.currentUser.id);
+        for (const e of tr.timeSchedule?.entries ?? [])
+            if (e.userId)
+                ids.add(e.userId);
+    }
+    const names = await resolveUserNames([...ids], accessToken);
+    const now = Date.now();
+    const schedules = teams.map((t) => {
+        const tr = t.triageResponsibility;
+        const shifts = (tr.timeSchedule?.entries ?? [])
+            .map((e) => {
+            const start = Date.parse(e.startsAt);
+            const end = Date.parse(e.endsAt);
+            return {
+                startsAt: e.startsAt,
+                endsAt: e.endsAt,
+                name: (e.userId && names[e.userId]) || e.userEmail || "Unknown",
+                isCurrent: now >= start && now < end,
+                isMe: !!viewerId && e.userId === viewerId,
+            };
+        })
+            .sort((a, b) => Date.parse(a.startsAt) - Date.parse(b.startsAt));
+        const currentShift = shifts.find((s) => s.isCurrent) ?? null;
+        const currentUserId = tr.currentUser?.id ?? null;
+        const currentName = currentShift?.name ?? (currentUserId ? (names[currentUserId] ?? null) : null);
+        const currentIsMe = currentShift?.isMe ?? (!!viewerId && currentUserId === viewerId);
+        return {
+            teamKey: t.key,
+            teamName: t.name,
+            scheduleName: tr.timeSchedule?.name ?? `${t.key} triage`,
+            currentName,
+            currentIsMe,
+            shifts,
+        };
+    });
+    // Surface schedules the viewer actually participates in first.
+    schedules.sort((a, b) => {
+        const am = a.shifts.some((s) => s.isMe) ? 0 : 1;
+        const bm = b.shifts.some((s) => s.isMe) ? 0 : 1;
+        return am - bm;
+    });
+    return schedules;
+}
 export async function fetchAssignedIssues(accessToken) {
     const data = (await graphqlQuery(ASSIGNED_ISSUES_QUERY, {}, accessToken));
     const nodes = data?.viewer?.assignedIssues?.nodes;
     if (!nodes)
         return null;
-    return nodes.map(mapAssigned);
+    return nodes
+        .map(mapAssigned)
+        .filter((i) => !HIDDEN_STATE_NAMES.has(i.state.name.trim().toLowerCase()));
 }