diff --git a/README.md b/README.md
index 39919259..c169d597 100644
--- a/README.md
+++ b/README.md
@@ -65,7 +65,7 @@ The app uses a **native file watcher** on the `.beads` directory. When an AI age
 - **Gallery Navigation**: Browse multiple attached files with arrow keys or buttons
 
 ### Filtering & Display
-- **Extended Status Support**: All Beads statuses handled — `deferred`, `pinned`, `hooked`, and `tombstone` (deleted) issues filtered from default view
+- **Extended Status Support**: All active Beads statuses handled — `deferred`, `pinned`, and `hooked`
 - **Advanced Filters**: Multi-select filters by type, status, priority, labels, and assignee
 - **Exclusion Filters**: Hide specific issues by criteria (inverse filtering)
 - **Search**: Find issues by title, ID, or description
diff --git a/app/components/dashboard/DashboardContent.vue b/app/components/dashboard/DashboardContent.vue
index 1ca842f3..d6924a2e 100644
--- a/app/components/dashboard/DashboardContent.vue
+++ b/app/components/dashboard/DashboardContent.vue
@@ -15,21 +15,21 @@ import {
   TooltipTrigger,
 } from '~/components/ui/tooltip'
 
-type KpiFilter = 'total' | 'open' | 'in_progress' | 'blocked'
+type KpiFilter = 'total' | 'open' | 'in_progress' | 'blocked' | 'workflow'
 
 const props = withDefaults(defineProps<{
   stats: DashboardStats | null
   readyIssues: Issue[]
   inProgressIssues: Issue[]
+  blockedIssues: Issue[]
   pinnedIssues: Issue[]
   pinnedSortMode?: PinnedSortMode
-  kpiGridCols?: 2 | 4
+  kpiGridCols?: 2 | 5
   activeKpiFilter: KpiFilter | null
-  statusFilters: string[]
   showOnboarding?: boolean
   hideKpis?: boolean
 }>(), {
-  kpiGridCols: 4,
+  kpiGridCols: 5,
   showOnboarding: false,
   hideKpis: false,
 })
@@ -46,6 +46,7 @@ const emit = defineEmits<{
 // Collapsible state (per-project, singleton)
 const isChartsCollapsed = useProjectStorage('chartsCollapsed', true)
 const isInProgressCollapsed = useProjectStorage('inProgressCollapsed', true)
+const isBlockedCollapsed = useProjectStorage('blockedCollapsed', true)
 const isPinnedCollapsed = useProjectStorage('pinnedCollapsed', false)
 const isReadyCollapsed = useProjectStorage('readyCollapsed', true)
 </script>
@@ -53,11 +54,12 @@ const isReadyCollapsed = useProjectStorage('readyCollapsed', true)
 <template>
   <template v-if="stats">
     <!-- KPI cards (hidden in desktop scrollable section where KPIs are in the fixed section) -->
-    <div v-if="!hideKpis" :class="['grid', kpiGridCols === 4 ? 'grid-cols-4 gap-1.5' : 'grid-cols-2 gap-3']">
-      <KpiCard title="Total" :value="stats.total" :active="activeKpiFilter === null && statusFilters.length === 0" @click="emit('kpi-click', 'total')" />
+    <div v-if="!hideKpis" :class="['flex flex-wrap p-0.5 -m-0.5', kpiGridCols === 5 ? 'gap-1.5' : 'gap-3']">
+      <KpiCard title="Workflow" :value="stats.workflow" color="var(--color-status-deferred)" :active="activeKpiFilter === 'workflow'" @click="emit('kpi-click', 'workflow')" />
       <KpiCard title="Open" :value="stats.open" color="var(--color-status-open)" :active="activeKpiFilter === 'open'" @click="emit('kpi-click', 'open')" />
       <KpiCard title="In Progress" :value="stats.inProgress" color="var(--color-status-in-progress)" :active="activeKpiFilter === 'in_progress'" @click="emit('kpi-click', 'in_progress')" />
       <KpiCard title="Blocked" :value="stats.blocked" color="var(--color-status-blocked)" :active="activeKpiFilter === 'blocked'" @click="emit('kpi-click', 'blocked')" />
+      <KpiCard title="All" :value="stats.total" :active="activeKpiFilter === 'total'" @click="emit('kpi-click', 'total')" />
     </div>
 
     <!-- Collapsible Charts Section -->
@@ -108,6 +110,30 @@ const isReadyCollapsed = useProjectStorage('readyCollapsed', true)
       </div>
     </div>
 
+    <!-- Collapsible Blocked Section -->
+    <div v-if="blockedIssues.length > 0" class="space-y-2">
+      <button
+        class="flex items-center gap-2 text-xs text-muted-foreground hover:text-foreground transition-colors w-full"
+        @click="isBlockedCollapsed = !isBlockedCollapsed"
+      >
+        <svg
+          class="w-3 h-3 transition-transform"
+          :class="{ '-rotate-90': isBlockedCollapsed }"
+          viewBox="0 0 24 24"
+          fill="none"
+          stroke="currentColor"
+          stroke-width="2"
+        >
+          <polyline points="6 9 12 15 18 9" />
+        </svg>
+        <span class="uppercase tracking-wide">Blocked</span>
+        <span class="text-[10px] ml-auto">({{ blockedIssues.length }})</span>
+      </button>
+      <div v-show="!isBlockedCollapsed" class="pl-5">
+        <QuickList :issues="blockedIssues" @select="emit('select-issue', $event)" />
+      </div>
+    </div>
+
     <!-- Collapsible Pinned Section -->
     <div v-if="pinnedIssues.length > 0" class="space-y-2">
       <div class="flex items-center gap-2 text-xs text-muted-foreground w-full">
diff --git a/app/components/dashboard/KpiCard.vue b/app/components/dashboard/KpiCard.vue
index 1951ce1d..27292fb3 100644
--- a/app/components/dashboard/KpiCard.vue
+++ b/app/components/dashboard/KpiCard.vue
@@ -54,9 +54,9 @@ const neonTitleStyle = computed(() => {
 
 <template>
   <button
-    class="p-1.5 rounded-md text-left w-full transition-colors"
+    class="px-2.5 py-1.5 rounded-md text-left transition-colors min-w-[90px]"
     :class="[
-      active ? 'ring-2 ring-primary' : '',
+      active ? 'outline-2 outline-primary' : '',
       isNeon
         ? 'border hover:brightness-125'
         : 'bg-secondary/30 border border-border/50 hover:bg-secondary/50'
@@ -65,7 +65,7 @@ const neonTitleStyle = computed(() => {
     @click="$emit('click')"
   >
     <div
-      class="text-[9px] uppercase tracking-wide mb-0.5 truncate"
+      class="text-[9px] uppercase tracking-wide mb-0.5 whitespace-nowrap"
       :class="isNeon && color ? '' : 'text-muted-foreground'"
       :style="neonTitleStyle"
     >
diff --git a/app/components/dashboard/QuickList.vue b/app/components/dashboard/QuickList.vue
index c940bf3c..dcdd34bc 100644
--- a/app/components/dashboard/QuickList.vue
+++ b/app/components/dashboard/QuickList.vue
@@ -25,6 +25,34 @@ const { focusedId, setFocused, handleKeydown, isFocused } = useKeyboardNavigatio
   },
 })
 
+const copiedIssueId = ref<string | null>(null)
+let copiedResetTimer: ReturnType<typeof setTimeout> | null = null
+
+const copyIssueId = async (issueId: string, event: Event) => {
+  event.stopPropagation()
+
+  try {
+    await navigator.clipboard.writeText(issueId)
+    copiedIssueId.value = issueId
+
+    if (copiedResetTimer) {
+      clearTimeout(copiedResetTimer)
+    }
+
+    copiedResetTimer = setTimeout(() => {
+      copiedIssueId.value = null
+    }, 2000)
+  } catch (err) {
+    console.error('Failed to copy issue ID:', err)
+  }
+}
+
+onBeforeUnmount(() => {
+  if (copiedResetTimer) {
+    clearTimeout(copiedResetTimer)
+  }
+})
+
 const getShortId = (id: string) => {
   const dotIndex = id.indexOf('.')
   const baseId = dotIndex > 0 ? id.slice(0, dotIndex) : id
@@ -45,20 +73,54 @@ const getShortId = (id: string) => {
       </div>
 
       <div v-else class="space-y-1 pr-4 outline-none" tabindex="0" @keydown="handleKeydown">
-        <button
+        <div
           v-for="issue in issues"
           :key="issue.id"
-          class="w-full text-left p-1.5 rounded hover:bg-secondary/50 transition-colors"
+          :data-issue-id="issue.id"
+          class="w-full p-1.5 rounded hover:bg-secondary/50 transition-colors flex items-start gap-1.5"
           :class="isFocused(issue.id) ? 'bg-primary/10 ring-1 ring-inset ring-primary/40' : ''"
-          @click="setFocused(issue.id); $emit('select', issue)"
         >
-          <div class="flex items-center gap-1.5 mb-0.5">
-            <TypeBadge :type="issue.type" size="sm" />
-            <PriorityBadge :priority="issue.priority" size="sm" />
-            <span class="text-[10px] text-muted-foreground font-mono">{{ getShortId(issue.id) }}</span>
-          </div>
-          <p class="text-[11px] leading-tight line-clamp-2">{{ issue.title }}</p>
-        </button>
+          <button
+            class="flex-1 min-w-0 text-left"
+            @click="setFocused(issue.id); $emit('select', issue)"
+          >
+            <div class="flex items-center gap-1.5 mb-0.5">
+              <TypeBadge :type="issue.type" size="sm" />
+              <PriorityBadge :priority="issue.priority" size="sm" />
+              <span class="text-[10px] text-muted-foreground font-mono">{{ getShortId(issue.id) }}</span>
+            </div>
+            <p class="text-[11px] leading-tight line-clamp-2">{{ issue.title }}</p>
+          </button>
+
+          <button
+            class="shrink-0 p-0.5 mt-0.5 rounded text-muted-foreground hover:text-foreground hover:bg-secondary transition-colors"
+            :title="`Copy issue ID ${issue.id}`"
+            :aria-label="`Copy issue ID ${issue.id}`"
+            @click="copyIssueId(issue.id, $event)"
+          >
+            <svg
+              v-if="copiedIssueId !== issue.id"
+              class="w-3 h-3"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+            >
+              <rect x="9" y="9" width="13" height="13" rx="2" ry="2" />
+              <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
+            </svg>
+            <svg
+              v-else
+              class="w-3 h-3 text-green-500"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+            >
+              <polyline points="20 6 9 17 4 12" />
+            </svg>
+          </button>
+        </div>
       </div>
     </ScrollArea>
   </div>
diff --git a/app/components/details/IssueDetailHeader.vue b/app/components/details/IssueDetailHeader.vue
index 476efaa7..48ecb858 100644
--- a/app/components/details/IssueDetailHeader.vue
+++ b/app/components/details/IssueDetailHeader.vue
@@ -4,6 +4,7 @@ import TypeBadge from '~/components/issues/TypeBadge.vue'
 import StatusBadge from '~/components/issues/StatusBadge.vue'
 import PriorityBadge from '~/components/issues/PriorityBadge.vue'
 import { Button } from '~/components/ui/button'
+import { isIssueBlocked } from '~/utils/issue-helpers'
 
 defineProps<{
   selectedIssue: Issue
@@ -25,7 +26,7 @@ defineEmits<{
     <div class="flex items-center gap-1.5 flex-wrap">
       <CopyableId :value="selectedIssue.id" :display-value="selectedIssue.id.includes('-') ? selectedIssue.id.slice(selectedIssue.id.lastIndexOf('-') + 1) : selectedIssue.id" />
       <TypeBadge :type="selectedIssue.type" size="sm" />
-      <StatusBadge :status="selectedIssue.status" size="sm" />
+      <StatusBadge :status="isIssueBlocked(selectedIssue) ? 'blocked' : selectedIssue.status" :blocked-by="selectedIssue.blockedBy" size="sm" />
       <PriorityBadge :priority="selectedIssue.priority" size="sm" />
     </div>
 
diff --git a/app/components/details/IssuePreview.vue b/app/components/details/IssuePreview.vue
index 544f715a..882e0ae2 100644
--- a/app/components/details/IssuePreview.vue
+++ b/app/components/details/IssuePreview.vue
@@ -9,6 +9,7 @@ import StatusBadge from '~/components/issues/StatusBadge.vue'
 import PriorityBadge from '~/components/issues/PriorityBadge.vue'
 import ImageThumbnail from '~/components/ui/image-preview/ImageThumbnail.vue'
 import { extractNonImageRefs, isUrl } from '~/utils/markdown'
+import { isIssueBlocked } from '~/utils/issue-helpers'
 import type { AttachmentFile } from '~/composables/useAttachments'
 
 const { currentTheme } = useTheme()
@@ -490,7 +491,7 @@ const formatEstimate = (minutes: number) => {
             <span class="text-xs truncate">{{ issue.parent.title }}</span>
           </div>
           <div class="flex items-center gap-1 shrink-0">
-            <StatusBadge :status="issue.parent.status" size="sm" />
+            <StatusBadge :status="isIssueBlocked(issue.parent) ? 'blocked' : issue.parent.status" :blocked-by="issue.parent.blockedBy" size="sm" />
             <PriorityBadge :priority="issue.parent.priority" size="sm" />
           </div>
         </div>
@@ -542,7 +543,7 @@ const formatEstimate = (minutes: number) => {
               <span class="text-xs truncate">{{ child.title }}</span>
             </div>
             <div class="flex items-center gap-1 shrink-0">
-              <StatusBadge :status="child.status" size="sm" />
+              <StatusBadge :status="isIssueBlocked(child) ? 'blocked' : child.status" :blocked-by="child.blockedBy" size="sm" />
               <PriorityBadge :priority="child.priority" size="sm" />
             </div>
           </div>
diff --git a/app/components/issues/AssigneeFilterDropdown.vue b/app/components/issues/AssigneeFilterDropdown.vue
index 1b89708a..55dd62f5 100644
--- a/app/components/issues/AssigneeFilterDropdown.vue
+++ b/app/components/issues/AssigneeFilterDropdown.vue
@@ -63,7 +63,7 @@ const isSelected = (assignee: string) => props.selectedAssignees.includes(assign
           <DropdownMenuCheckboxItem
             v-for="assignee in availableAssignees"
             :key="assignee"
-            :checked="isSelected(assignee)"
+            :model-value="isSelected(assignee)"
             class="text-xs cursor-pointer"
             @select.prevent="$emit('toggle', assignee)"
           >
diff --git a/app/components/issues/ColumnConfig.vue b/app/components/issues/ColumnConfig.vue
index 99dd25ed..5e65faab 100644
--- a/app/components/issues/ColumnConfig.vue
+++ b/app/components/issues/ColumnConfig.vue
@@ -1,19 +1,14 @@
 <script setup lang="ts">
 import type { ColumnConfig } from '~/types/issue'
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuLabel,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-  DropdownMenuCheckboxItem,
-} from '~/components/ui/dropdown-menu'
+import { onClickOutside } from '@vueuse/core'
 import {
   Tooltip,
   TooltipContent,
   TooltipTrigger,
 } from '~/components/ui/tooltip'
 import { Button } from '~/components/ui/button'
+import { Checkbox } from '~/components/ui/checkbox'
+import Sortable from 'sortablejs'
 
 const props = defineProps<{
   columns: ColumnConfig[]
@@ -24,56 +19,140 @@ const emit = defineEmits<{
   reset: []
 }>()
 
+const isOpen = ref(false)
+const panelRef = ref<HTMLElement | null>(null)
+const triggerRef = ref<HTMLElement | null>(null)
+const listRef = ref<HTMLElement | null>(null)
+let sortableInstance: Sortable | null = null
+
 const handleToggle = (columnId: string, checked: boolean) => {
   const updatedColumns = props.columns.map((col) =>
     col.id === columnId ? { ...col, visible: checked } : col
   )
   emit('update:columns', updatedColumns)
 }
+
+const initSortable = () => {
+  if (sortableInstance) {
+    sortableInstance.destroy()
+    sortableInstance = null
+  }
+  if (!listRef.value) return
+
+  sortableInstance = Sortable.create(listRef.value, {
+    handle: '.drag-handle',
+    animation: 200,
+    ghostClass: 'opacity-30',
+    forceFallback: true,
+    fallbackClass: 'sortable-fallback',
+    fallbackOnBody: true,
+    onEnd: (evt) => {
+      if (evt.oldIndex == null || evt.newIndex == null || evt.oldIndex === evt.newIndex) return
+      const container = evt.from
+      const newOrder: string[] = []
+      for (const child of container.children) {
+        const id = (child as HTMLElement).dataset.columnId
+        if (id) newOrder.push(id)
+      }
+      // Revert DOM change so Vue handles re-rendering
+      container.removeChild(evt.item)
+      const refNode = container.children[evt.oldIndex] || null
+      container.insertBefore(evt.item, refNode)
+      // Build reordered columns array
+      const reordered = newOrder
+        .map(id => props.columns.find(c => c.id === id))
+        .filter((c): c is ColumnConfig => !!c)
+      if (reordered.length === props.columns.length) {
+        emit('update:columns', reordered)
+      }
+    },
+  })
+}
+
+onClickOutside(panelRef, (event) => {
+  // Don't close if clicking the trigger button
+  if (triggerRef.value && (triggerRef.value === event.target || triggerRef.value.contains(event.target as Node))) return
+  isOpen.value = false
+}, { ignore: [triggerRef] })
+
+watch(isOpen, (open) => {
+  if (open) {
+    nextTick(() => initSortable())
+  } else if (sortableInstance) {
+    sortableInstance.destroy()
+    sortableInstance = null
+  }
+})
+
+onBeforeUnmount(() => {
+  if (sortableInstance) {
+    sortableInstance.destroy()
+    sortableInstance = null
+  }
+})
 </script>
 
 <template>
-  <Tooltip>
-    <DropdownMenu>
+  <div class="relative">
+    <Tooltip>
       <TooltipTrigger as-child>
-        <DropdownMenuTrigger as-child>
-          <Button variant="outline" size="icon" class="h-8 w-8">
-            <svg
-              class="w-3.5 h-3.5"
-              viewBox="0 0 24 24"
-              fill="none"
-              stroke="currentColor"
-              stroke-width="2"
-            >
-              <rect x="3" y="3" width="7" height="7" />
-              <rect x="14" y="3" width="7" height="7" />
-              <rect x="14" y="14" width="7" height="7" />
-              <rect x="3" y="14" width="7" height="7" />
-            </svg>
-            <span class="sr-only">Column settings</span>
-          </Button>
-        </DropdownMenuTrigger>
+        <Button ref="triggerRef" variant="outline" size="icon" class="h-8 w-8" @click="isOpen = !isOpen">
+          <svg
+            class="w-3.5 h-3.5"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="2"
+          >
+            <rect x="3" y="3" width="7" height="7" />
+            <rect x="14" y="3" width="7" height="7" />
+            <rect x="14" y="14" width="7" height="7" />
+            <rect x="3" y="14" width="7" height="7" />
+          </svg>
+          <span class="sr-only">Column settings</span>
+        </Button>
       </TooltipTrigger>
       <TooltipContent>Column settings</TooltipContent>
-    <DropdownMenuContent align="end" class="w-48">
-      <DropdownMenuLabel class="text-xs">Visible Columns</DropdownMenuLabel>
-      <DropdownMenuSeparator />
-      <DropdownMenuCheckboxItem
-        v-for="column in columns"
-        :key="column.id"
-        :model-value="column.visible"
-        class="text-xs [&_svg]:text-green-500"
-        @update:model-value="handleToggle(column.id, $event)"
-      >
-        {{ column.label }}
-      </DropdownMenuCheckboxItem>
-      <DropdownMenuSeparator />
+    </Tooltip>
+
+    <div
+      v-if="isOpen"
+      ref="panelRef"
+      class="absolute right-0 top-full mt-1 z-50 w-52 rounded-md border bg-popover text-popover-foreground shadow-md"
+    >
+      <div class="px-2 py-1.5">
+        <span class="text-xs font-semibold">Visible Columns</span>
+      </div>
+      <div class="h-px bg-border" />
+      <div ref="listRef" class="py-1">
+        <div
+          v-for="column in columns"
+          :key="column.id"
+          :data-column-id="column.id"
+          class="flex items-center gap-2 px-2 py-1 text-xs hover:bg-accent/50 rounded-sm mx-1"
+        >
+          <span class="drag-handle cursor-grab active:cursor-grabbing text-muted-foreground/40 hover:text-muted-foreground flex-shrink-0">
+            <svg class="w-3.5 h-3.5" viewBox="0 0 24 24" fill="currentColor">
+              <circle cx="9" cy="5" r="1.5" /><circle cx="15" cy="5" r="1.5" />
+              <circle cx="9" cy="12" r="1.5" /><circle cx="15" cy="12" r="1.5" />
+              <circle cx="9" cy="19" r="1.5" /><circle cx="15" cy="19" r="1.5" />
+            </svg>
+          </span>
+          <Checkbox
+            :id="`col-${column.id}`"
+            :model-value="column.visible"
+            class="h-3.5 w-3.5"
+            @update:model-value="handleToggle(column.id, !!$event)"
+          />
+          <label :for="`col-${column.id}`" class="flex-1 cursor-pointer select-none">{{ column.label }}</label>
+        </div>
+      </div>
+      <div class="h-px bg-border" />
       <div class="p-1">
         <Button variant="ghost" size="sm" class="w-full text-xs h-7 justify-start" @click="emit('reset')">
           Reset to defaults
         </Button>
       </div>
-    </DropdownMenuContent>
-    </DropdownMenu>
-  </Tooltip>
+    </div>
+  </div>
 </template>
diff --git a/app/components/issues/ExclusionFilterDropdown.vue b/app/components/issues/ExclusionFilterDropdown.vue
index fa219a83..8a094b1f 100644
--- a/app/components/issues/ExclusionFilterDropdown.vue
+++ b/app/components/issues/ExclusionFilterDropdown.vue
@@ -52,7 +52,6 @@ const statusOptions: { value: IssueStatus; label: string }[] = [
   { value: 'blocked', label: 'Blocked' },
   { value: 'closed', label: 'Closed' },
   { value: 'deferred', label: 'Deferred' },
-  { value: 'tombstone', label: 'Deleted' },
   { value: 'pinned', label: 'Pinned' },
   { value: 'hooked', label: 'Hooked' },
 ]
diff --git a/app/components/issues/FilterChips.vue b/app/components/issues/FilterChips.vue
index 269fc5ef..a2008f4f 100644
--- a/app/components/issues/FilterChips.vue
+++ b/app/components/issues/FilterChips.vue
@@ -39,33 +39,6 @@ const hasFilters = computed(
   () => hasInclusionFilters.value || hasActiveExclusions.value
 )
 
-// Labels for status, priority, type exclusions
-const statusLabels: Record<IssueStatus, string> = {
-  open: 'Open',
-  in_progress: 'In Progress',
-  blocked: 'Blocked',
-  closed: 'Closed',
-  deferred: 'Deferred',
-  tombstone: 'Tombstone',
-  pinned: 'Pinned',
-  hooked: 'Hooked',
-}
-
-const priorityLabels: Record<IssuePriority, string> = {
-  p0: 'P0',
-  p1: 'P1',
-  p2: 'P2',
-  p3: 'P3',
-  p4: 'P4',
-}
-
-const typeLabels: Record<IssueType, string> = {
-  bug: 'Bug',
-  feature: 'Feature',
-  task: 'Task',
-  epic: 'Epic',
-  chore: 'Chore',
-}
 </script>
 
 <template>
diff --git a/app/components/issues/IssueListPanel.vue b/app/components/issues/IssueListPanel.vue
index aff17540..d65e2f12 100644
--- a/app/components/issues/IssueListPanel.vue
+++ b/app/components/issues/IssueListPanel.vue
@@ -16,7 +16,6 @@ defineProps<{
   multiSelectMode: boolean
   selectedCount: number
   columns: ColumnConfig[]
-  isSearchActive: boolean
   issues: Issue[]
   groupedIssues: IssueGroup[]
   selectedId?: string
@@ -82,7 +81,6 @@ const handleSort = (field: string | null, direction: 'asc' | 'desc') => {
     />
 
     <FilterChips
-      v-if="!isSearchActive"
       :status-filters="filters.status"
       :type-filters="filters.type"
       :priority-filters="filters.priority"
diff --git a/app/components/issues/IssueTable.vue b/app/components/issues/IssueTable.vue
index 33e9ec5d..9a813882 100644
--- a/app/components/issues/IssueTable.vue
+++ b/app/components/issues/IssueTable.vue
@@ -20,7 +20,7 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from '~/components/ui/tooltip'
-import { Ban } from 'lucide-vue-next'
+import { isIssueBlocked } from '~/utils/issue-helpers'
 import { useKeyboardNavigation } from '~/composables/useKeyboardNavigation'
 
 const props = defineProps<{
@@ -104,7 +104,6 @@ const statusOrder: Record<IssueStatus, number> = {
   deferred: 4,
   pinned: 5,
   hooked: 6,
-  tombstone: 7,
 }
 
 const priorityOrder: Record<IssuePriority, number> = {
@@ -547,17 +546,7 @@ const { focusedId, setFocused, handleKeydown, isFocused } = useKeyboardNavigatio
                   </template>
 
                   <template v-else-if="col.id === 'status'">
-                    <div class="flex items-center gap-1">
-                      <StatusBadge :status="group.epic.status" size="sm" />
-                      <Tooltip v-if="group.epic.blockedBy?.length">
-                        <TooltipTrigger as-child>
-                          <Ban class="w-3 h-3 text-red-400" />
-                        </TooltipTrigger>
-                        <TooltipContent side="top">
-                          <p class="text-xs">Blocked by {{ group.epic.blockedBy.join(', ') }}</p>
-                        </TooltipContent>
-                      </Tooltip>
-                    </div>
+                    <StatusBadge :status="isIssueBlocked(group.epic) ? 'blocked' : group.epic.status" :blocked-by="group.epic.blockedBy" size="sm" />
                   </template>
 
                   <template v-else-if="col.id === 'priority'">
@@ -694,17 +683,7 @@ const { focusedId, setFocused, handleKeydown, isFocused } = useKeyboardNavigatio
                     </template>
 
                     <template v-else-if="col.id === 'status'">
-                      <div class="flex items-center gap-1">
-                        <StatusBadge :status="child.status" size="sm" />
-                        <Tooltip v-if="child.blockedBy?.length">
-                          <TooltipTrigger as-child>
-                            <Ban class="w-3 h-3 text-red-400" />
-                          </TooltipTrigger>
-                          <TooltipContent side="top">
-                            <p class="text-xs">Blocked by {{ child.blockedBy.join(', ') }}</p>
-                          </TooltipContent>
-                        </Tooltip>
-                      </div>
+                      <StatusBadge :status="isIssueBlocked(child) ? 'blocked' : child.status" :blocked-by="child.blockedBy" size="sm" />
                     </template>
 
                     <template v-else-if="col.id === 'priority'">
@@ -812,17 +791,7 @@ const { focusedId, setFocused, handleKeydown, isFocused } = useKeyboardNavigatio
                   </template>
 
                   <template v-else-if="col.id === 'status'">
-                    <div class="flex items-center gap-1">
-                      <StatusBadge :status="issue.status" size="sm" />
-                      <Tooltip v-if="issue.blockedBy?.length">
-                        <TooltipTrigger as-child>
-                          <Ban class="w-3 h-3 text-red-400" />
-                        </TooltipTrigger>
-                        <TooltipContent side="top">
-                          <p class="text-xs">Blocked by {{ issue.blockedBy.join(', ') }}</p>
-                        </TooltipContent>
-                      </Tooltip>
-                    </div>
+                    <StatusBadge :status="isIssueBlocked(issue) ? 'blocked' : issue.status" :blocked-by="issue.blockedBy" size="sm" />
                   </template>
 
                   <template v-else-if="col.id === 'priority'">
@@ -931,17 +900,7 @@ const { focusedId, setFocused, handleKeydown, isFocused } = useKeyboardNavigatio
               </template>
 
               <template v-else-if="col.id === 'status'">
-                <div class="flex items-center gap-1">
-                  <StatusBadge :status="issue.status" size="sm" />
-                  <Tooltip v-if="issue.blockedBy?.length">
-                    <TooltipTrigger as-child>
-                      <Ban class="w-3 h-3 text-red-400" />
-                    </TooltipTrigger>
-                    <TooltipContent side="top">
-                      <p class="text-xs">Blocked by {{ issue.blockedBy.join(', ') }}</p>
-                    </TooltipContent>
-                  </Tooltip>
-                </div>
+                <StatusBadge :status="isIssueBlocked(issue) ? 'blocked' : issue.status" :blocked-by="issue.blockedBy" size="sm" />
               </template>
 
               <template v-else-if="col.id === 'priority'">
diff --git a/app/components/issues/LabelFilterDropdown.vue b/app/components/issues/LabelFilterDropdown.vue
index ecffe291..f722ae2c 100644
--- a/app/components/issues/LabelFilterDropdown.vue
+++ b/app/components/issues/LabelFilterDropdown.vue
@@ -63,7 +63,7 @@ const isSelected = (label: string) => props.selectedLabels.includes(label)
         <DropdownMenuCheckboxItem
           v-for="label in availableLabels"
           :key="label"
-          :checked="isSelected(label)"
+          :model-value="isSelected(label)"
           class="text-xs cursor-pointer"
           @select.prevent="$emit('toggle', label)"
         >
diff --git a/app/components/issues/PriorityFilterDropdown.vue b/app/components/issues/PriorityFilterDropdown.vue
index 10ff0092..e953b043 100644
--- a/app/components/issues/PriorityFilterDropdown.vue
+++ b/app/components/issues/PriorityFilterDropdown.vue
@@ -65,7 +65,7 @@ const isSelected = (priority: IssuePriority) => props.selectedPriorities.include
       <DropdownMenuCheckboxItem
         v-for="opt in priorityOptions"
         :key="opt.value"
-        :checked="isSelected(opt.value)"
+        :model-value="isSelected(opt.value)"
         class="text-xs cursor-pointer"
         @select.prevent="$emit('toggle', opt.value)"
       >
diff --git a/app/components/issues/StatusBadge.vue b/app/components/issues/StatusBadge.vue
index e61d4141..96b7f6ae 100644
--- a/app/components/issues/StatusBadge.vue
+++ b/app/components/issues/StatusBadge.vue
@@ -1,10 +1,16 @@
 <script setup lang="ts">
 import type { IssueStatus } from '~/types/issue'
 import { Badge } from '~/components/ui/badge'
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from '~/components/ui/tooltip'
 
 const props = defineProps<{
   status: IssueStatus
   size?: 'default' | 'sm'
+  blockedBy?: string[]
 }>()
 
 const { showBadgeIcons } = useTheme()
@@ -15,7 +21,6 @@ const statusConfig: Record<IssueStatus, { label: string; class: string }> = {
   blocked: { label: 'BLOCKED', class: 'badge-gradient bg-status-blocked-gradient text-white' },
   closed: { label: 'CLOSED', class: 'badge-gradient bg-status-closed-gradient text-white' },
   deferred: { label: 'DEFERRED', class: 'badge-gradient bg-status-deferred-gradient text-white' },
-  tombstone: { label: 'DELETED', class: 'badge-gradient bg-status-tombstone-gradient text-white' },
   pinned: { label: 'PINNED', class: 'badge-gradient bg-status-pinned-gradient text-white' },
   hooked: { label: 'HOOKED', class: 'badge-gradient bg-status-hooked-gradient text-white' },
 }
@@ -29,10 +34,26 @@ const statusIcons: Partial<Record<IssueStatus, string>> = {
 }
 
 const config = computed(() => statusConfig[props.status] || statusConfig.open)
+const showBlockedTooltip = computed(() => props.blockedBy?.length && props.status === 'blocked')
 </script>
 
 <template>
-  <Badge :class="[config.class, size === 'sm' ? 'text-[10px] px-1.5 py-0' : '']" variant="secondary">
+  <Tooltip v-if="showBlockedTooltip">
+    <TooltipTrigger as-child>
+      <Badge :class="[config.class, size === 'sm' ? 'text-[10px] px-1.5 py-0' : '']" variant="secondary">
+        <span v-if="showBadgeIcons && statusIcons[status]" class="inline-flex items-center mr-1">
+          <svg class="w-3 h-3" viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round">
+            <path :d="statusIcons[status]" />
+          </svg>
+        </span>
+        {{ config.label }}
+      </Badge>
+    </TooltipTrigger>
+    <TooltipContent side="top">
+      <p class="text-xs">Blocked by {{ blockedBy!.join(', ') }}</p>
+    </TooltipContent>
+  </Tooltip>
+  <Badge v-else :class="[config.class, size === 'sm' ? 'text-[10px] px-1.5 py-0' : '']" variant="secondary">
     <span v-if="showBadgeIcons && statusIcons[status]" class="inline-flex items-center mr-1">
       <svg class="w-3 h-3" viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round">
         <path :d="statusIcons[status]" />
diff --git a/app/components/issues/StatusFilterDropdown.vue b/app/components/issues/StatusFilterDropdown.vue
index c6510932..1e9d8fee 100644
--- a/app/components/issues/StatusFilterDropdown.vue
+++ b/app/components/issues/StatusFilterDropdown.vue
@@ -30,7 +30,6 @@ const statusOptions: { value: IssueStatus; label: string }[] = [
   { value: 'blocked', label: 'Blocked' },
   { value: 'closed', label: 'Closed' },
   { value: 'deferred', label: 'Deferred' },
-  { value: 'tombstone', label: 'Deleted' },
   { value: 'pinned', label: 'Pinned' },
   { value: 'hooked', label: 'Hooked' },
 ]
@@ -69,7 +68,7 @@ const isSelected = (status: IssueStatus) => props.selectedStatuses.includes(stat
       <DropdownMenuCheckboxItem
         v-for="opt in statusOptions"
         :key="opt.value"
-        :checked="isSelected(opt.value)"
+        :model-value="isSelected(opt.value)"
         class="text-xs cursor-pointer"
         @select.prevent="$emit('toggle', opt.value)"
       >
diff --git a/app/components/issues/TypeFilterDropdown.vue b/app/components/issues/TypeFilterDropdown.vue
index d2f5c900..32ede83e 100644
--- a/app/components/issues/TypeFilterDropdown.vue
+++ b/app/components/issues/TypeFilterDropdown.vue
@@ -66,7 +66,7 @@ const isSelected = (type: IssueType) => props.selectedTypes.includes(type)
       <DropdownMenuCheckboxItem
         v-for="opt in typeOptions"
         :key="opt.value"
-        :checked="isSelected(opt.value)"
+        :model-value="isSelected(opt.value)"
         class="text-xs cursor-pointer"
         @select.prevent="$emit('toggle', opt.value)"
       >
diff --git a/app/components/layout/DebugPanel.vue b/app/components/layout/DebugPanel.vue
index 44cc0bfa..273e4675 100644
--- a/app/components/layout/DebugPanel.vue
+++ b/app/components/layout/DebugPanel.vue
@@ -5,6 +5,7 @@ import { openUrl } from '~/utils/open-url'
 
 const { isSyncing: isForceSyncing, forceSync, syncMessage, lastSyncSuccess } = useSyncStatus()
 const { beadsPath } = useBeadsPath()
+const { snapshot: diagSnapshot, reset: diagReset } = usePipelineDiagnostics()
 
 const props = defineProps<{
   isOpen: boolean
@@ -24,6 +25,10 @@ const isVerbose = ref(false)
 const bdCliUpdate = ref<BdCliUpdateInfo | null>(null)
 let refreshInterval: ReturnType<typeof setInterval> | null = null
 
+const debugTab = ref<'logs' | 'pipeline'>('logs')
+const pipelineData = ref(diagSnapshot())
+let pipelineRefreshTimer: ReturnType<typeof setInterval> | null = null
+
 const logContainerRef = ref<HTMLDivElement | null>(null)
 const isUserAtBottom = ref(true)
 
@@ -210,13 +215,26 @@ watch(() => props.isOpen, async (isOpen) => {
     }
   } else {
     stopAutoRefresh()
+    if (pipelineRefreshTimer) { clearInterval(pipelineRefreshTimer); pipelineRefreshTimer = null }
     // Disable backend logging to save resources when panel is closed
     await setLoggingEnabled(false)
   }
 }, { immediate: true })
 
+watch(debugTab, (tab) => {
+  if (tab === 'pipeline') {
+    pipelineData.value = diagSnapshot()
+    if (!pipelineRefreshTimer) {
+      pipelineRefreshTimer = setInterval(() => { pipelineData.value = diagSnapshot() }, 2000)
+    }
+  } else {
+    if (pipelineRefreshTimer) { clearInterval(pipelineRefreshTimer); pipelineRefreshTimer = null }
+  }
+})
+
 onUnmounted(() => {
   stopAutoRefresh()
+  if (pipelineRefreshTimer) { clearInterval(pipelineRefreshTimer); pipelineRefreshTimer = null }
 })
 </script>
 
@@ -235,92 +253,120 @@ onUnmounted(() => {
     <!-- Header -->
     <div class="flex items-center justify-between gap-2 px-4 py-2 border-b border-border bg-muted/30">
       <div class="flex items-center gap-2">
-        <span class="text-sm font-medium">Debug Logs</span>
-
-        <Button
-          variant="outline"
-          size="sm"
-          class="h-7 px-2"
-          :class="isAutoRefresh ? 'border-green-500 text-green-500' : ''"
-          @click="toggleAutoRefresh"
-        >
-          <svg
-            class="w-3.5 h-3.5 mr-1"
-            :class="{ 'animate-spin': isAutoRefresh }"
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            stroke-width="2"
+        <!-- Tab toggle -->
+        <div class="flex rounded-md border border-border overflow-hidden">
+          <button
+            class="px-2 py-0.5 text-xs font-medium transition-colors"
+            :class="debugTab === 'logs' ? 'bg-primary text-primary-foreground' : 'hover:bg-muted'"
+            @click="debugTab = 'logs'"
+          >Logs</button>
+          <button
+            class="px-2 py-0.5 text-xs font-medium transition-colors"
+            :class="debugTab === 'pipeline' ? 'bg-primary text-primary-foreground' : 'hover:bg-muted'"
+            @click="debugTab = 'pipeline'"
+          >Pipeline</button>
+        </div>
+
+        <!-- Log tab buttons -->
+        <template v-if="debugTab === 'logs'">
+          <Button
+            variant="outline"
+            size="sm"
+            class="h-7 px-2"
+            :class="isAutoRefresh ? 'border-green-500 text-green-500' : ''"
+            @click="toggleAutoRefresh"
           >
-            <path d="M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8" />
-            <path d="M21 3v5h-5" />
-          </svg>
-          {{ isAutoRefresh ? 'Live' : 'Paused' }}
-        </Button>
-
-        <Button variant="outline" size="sm" class="h-7 px-2" :disabled="isAutoRefresh" @click="fetchLogs">
-          Refresh
-        </Button>
-
-        <Button variant="outline" size="sm" class="h-7 px-2" @click="scrollToBottom">
-          Bottom
-        </Button>
-
-        <Button
-          variant="outline"
-          size="sm"
-          class="h-7 px-2"
-          :class="isVerbose ? 'border-amber-500 text-amber-500' : ''"
-          @click="toggleVerbose"
-        >
-          Verbose {{ isVerbose ? 'ON' : 'OFF' }}
-        </Button>
-
-        <Button
-          variant="outline"
-          size="sm"
-          class="h-7 px-2 text-destructive border-destructive/50 hover:bg-destructive hover:text-destructive-foreground"
-          :disabled="isLoading"
-          @click="handleClearLogs"
-        >
-          Clear
-        </Button>
-
-        <Button
-          v-if="logs"
-          variant="outline"
-          size="sm"
-          class="h-7 px-2"
-          @click="exportLogs"
-        >
-          Export
-        </Button>
-        <span v-if="exportedPath" class="text-xs text-green-500 truncate max-w-[300px]" :title="exportedPath">{{ exportedPath }}</span>
-
-        <div class="w-px h-4 bg-border mx-2" />
-
-        <Button
-          variant="outline"
-          size="sm"
-          class="h-7 px-2"
-          :class="isForceSyncing ? 'border-primary text-primary' : ''"
-          :disabled="isForceSyncing"
-          @click="forceSync"
-        >
-          <svg
-            :class="['w-3.5 h-3.5 mr-1', isForceSyncing ? 'animate-pulse' : '']"
-            viewBox="0 0 24 24"
-            fill="none"
-            stroke="currentColor"
-            stroke-width="2"
+            <svg
+              class="w-3.5 h-3.5 mr-1"
+              :class="{ 'animate-spin': isAutoRefresh }"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+            >
+              <path d="M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8" />
+              <path d="M21 3v5h-5" />
+            </svg>
+            {{ isAutoRefresh ? 'Live' : 'Paused' }}
+          </Button>
+
+          <Button variant="outline" size="sm" class="h-7 px-2" :disabled="isAutoRefresh" @click="fetchLogs">
+            Refresh
+          </Button>
+
+          <Button variant="outline" size="sm" class="h-7 px-2" @click="scrollToBottom">
+            Bottom
+          </Button>
+
+          <Button
+            variant="outline"
+            size="sm"
+            class="h-7 px-2"
+            :class="isVerbose ? 'border-amber-500 text-amber-500' : ''"
+            @click="toggleVerbose"
           >
-            <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
-            <path d="M12 12v9" />
-            <path d="m8 17 4 4 4-4" />
-          </svg>
-          {{ isForceSyncing ? 'Syncing...' : 'Force Sync' }}
-        </Button>
-        <span v-if="syncMessage && lastSyncSuccess" class="text-green-500 text-xs ml-1">{{ syncMessage }}</span>
+            Verbose {{ isVerbose ? 'ON' : 'OFF' }}
+          </Button>
+
+          <Button
+            variant="outline"
+            size="sm"
+            class="h-7 px-2 text-destructive border-destructive/50 hover:bg-destructive hover:text-destructive-foreground"
+            :disabled="isLoading"
+            @click="handleClearLogs"
+          >
+            Clear
+          </Button>
+
+          <Button
+            v-if="logs"
+            variant="outline"
+            size="sm"
+            class="h-7 px-2"
+            @click="exportLogs"
+          >
+            Export
+          </Button>
+          <span v-if="exportedPath" class="text-xs text-green-500 truncate max-w-[300px]" :title="exportedPath">{{ exportedPath }}</span>
+
+          <div class="w-px h-4 bg-border mx-2" />
+
+          <Button
+            variant="outline"
+            size="sm"
+            class="h-7 px-2"
+            :class="isForceSyncing ? 'border-primary text-primary' : ''"
+            :disabled="isForceSyncing"
+            @click="forceSync"
+          >
+            <svg
+              :class="['w-3.5 h-3.5 mr-1', isForceSyncing ? 'animate-pulse' : '']"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+            >
+              <path d="M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242" />
+              <path d="M12 12v9" />
+              <path d="m8 17 4 4 4-4" />
+            </svg>
+            {{ isForceSyncing ? 'Syncing...' : 'Force Sync' }}
+          </Button>
+          <span v-if="syncMessage && lastSyncSuccess" class="text-green-500 text-xs ml-1">{{ syncMessage }}</span>
+        </template>
+
+        <!-- Pipeline tab buttons -->
+        <template v-if="debugTab === 'pipeline'">
+          <Button
+            variant="outline"
+            size="sm"
+            class="h-7 px-2 text-destructive border-destructive/50 hover:bg-destructive hover:text-destructive-foreground"
+            @click="diagReset(); pipelineData = diagSnapshot()"
+          >
+            Reset
+          </Button>
+          <span class="text-xs text-muted-foreground">Uptime {{ pipelineData.uptimeSeconds }}s · Auto-refresh 2s</span>
+        </template>
       </div>
 
       <div class="flex items-center gap-2">
@@ -369,9 +415,52 @@ onUnmounted(() => {
     </div>
 
     <!-- Log content -->
-    <div ref="logContainerRef" class="flex-1 overflow-auto bg-muted/10" @scroll="onScroll">
+    <div v-if="debugTab === 'logs'" ref="logContainerRef" class="flex-1 overflow-auto bg-muted/10" @scroll="onScroll">
       <pre v-if="logs" class="p-3 text-[11px] font-mono whitespace-pre-wrap break-all leading-relaxed" v-html="colorizedLogs"></pre>
       <pre v-else class="p-3 text-[11px] font-mono text-muted-foreground">No logs yet...</pre>
     </div>
+
+    <!-- Pipeline diagnostics -->
+    <div v-else class="flex-1 overflow-auto bg-muted/10 p-4">
+      <div class="grid grid-cols-2 md:grid-cols-4 gap-4 text-xs font-mono">
+        <!-- Watcher -->
+        <div class="space-y-1.5">
+          <div class="text-sm font-semibold text-foreground mb-2">Watcher</div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Triggers</span><span>{{ pipelineData.counters.watcherTriggers }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Cooldown skips</span><span>{{ pipelineData.counters.watcherCooldownSkips }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Debounces</span><span>{{ pipelineData.counters.watcherDebounces }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Reruns</span><span>{{ pipelineData.counters.watcherReruns }}</span></div>
+        </div>
+
+        <!-- Scheduler -->
+        <div class="space-y-1.5">
+          <div class="text-sm font-semibold text-foreground mb-2">Scheduler</div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Requests</span><span>{{ pipelineData.counters.pollRequests }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Executed</span><span class="text-green-500">{{ pipelineData.counters.pollExecuted }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Deferred</span><span class="text-amber-500">{{ pipelineData.counters.pollDeferred }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Skipped</span><span class="text-red-400">{{ pipelineData.counters.pollSkipped }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Immediate</span><span>{{ pipelineData.counters.pollImmediateRequests }}</span></div>
+        </div>
+
+        <!-- Poll execution -->
+        <div class="space-y-1.5">
+          <div class="text-sm font-semibold text-foreground mb-2">Poll execution</div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Started</span><span>{{ pipelineData.counters.pollStarted }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Finished</span><span>{{ pipelineData.counters.pollFinished }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Errors</span><span :class="pipelineData.counters.pollErrors > 0 ? 'text-red-500' : ''">{{ pipelineData.counters.pollErrors }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Last ms</span><span>{{ pipelineData.counters.pollLastMs }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Avg ms</span><span>{{ pipelineData.pollAvgMs }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Max ms</span><span :class="pipelineData.counters.pollMaxMs > 2000 ? 'text-red-500' : pipelineData.counters.pollMaxMs > 500 ? 'text-amber-500' : ''">{{ pipelineData.counters.pollMaxMs }}</span></div>
+        </div>
+
+        <!-- Mtime check -->
+        <div class="space-y-1.5">
+          <div class="text-sm font-semibold text-foreground mb-2">Mtime check</div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Checks</span><span>{{ pipelineData.counters.mtimeChecks }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Hits</span><span>{{ pipelineData.counters.mtimeHits }}</span></div>
+          <div class="flex justify-between"><span class="text-muted-foreground">Hit rate</span><span>{{ pipelineData.counters.mtimeChecks > 0 ? Math.round(pipelineData.counters.mtimeHits / pipelineData.counters.mtimeChecks * 100) : 0 }}%</span></div>
+        </div>
+      </div>
+    </div>
   </div>
 </template>
diff --git a/app/composables/useChangeDetection.ts b/app/composables/useChangeDetection.ts
index cb2d16ad..65d5bcc3 100644
--- a/app/composables/useChangeDetection.ts
+++ b/app/composables/useChangeDetection.ts
@@ -1,4 +1,5 @@
 import { getExternalUrl, getProbeProjectName, logFrontend, startWatching, stopWatching } from '~/utils/bd-api'
+import { usePipelineDiagnostics } from './usePipelineDiagnostics'
 
 interface UseChangeDetectionOptions {
   onChanged: () => Promise<void>
@@ -9,6 +10,87 @@ interface UseChangeDetectionOptions {
 // ============================================================================
 const SELF_TRIGGER_COOLDOWN_MS = 3_000
 const DEBOUNCE_MS = 300
+const MAX_CONSECUTIVE_RERUNS = 5
+
+/**
+ * Queue-based handler: at most one `onChanged()` in flight with at most one
+ * pending rerun. Events arriving during processing set a rerun flag instead
+ * of spawning extra timers. Bounded by MAX_CONSECUTIVE_RERUNS to prevent
+ * unbounded loops under sustained churn.
+ */
+export function createQueuedHandler(
+  onChanged: () => Promise<void>,
+  getSelfWriteCooldownActive: () => boolean,
+  onProcessed: () => void,
+) {
+  const { recordWatcherTrigger, recordWatcherDebounce, recordWatcherRerun } = usePipelineDiagnostics()
+
+  let inflight = false
+  let pendingRerun = false
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null
+  let consecutiveReruns = 0
+
+  function schedule() {
+    if (debounceTimer) clearTimeout(debounceTimer)
+    recordWatcherDebounce()
+    debounceTimer = setTimeout(() => run(), DEBOUNCE_MS)
+  }
+
+  async function run() {
+    debounceTimer = null
+
+    if (inflight) {
+      pendingRerun = true
+      return
+    }
+
+    inflight = true
+    consecutiveReruns = 0
+
+    try {
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        pendingRerun = false
+        try {
+          await onChanged()
+        } catch {
+          // Ignore — polling will catch up
+        }
+        onProcessed()
+        consecutiveReruns++
+
+        if (!pendingRerun || consecutiveReruns >= MAX_CONSECUTIVE_RERUNS) break
+        recordWatcherRerun()
+      }
+    } finally {
+      inflight = false
+      consecutiveReruns = 0
+    }
+  }
+
+  function trigger() {
+    if (getSelfWriteCooldownActive()) {
+      recordWatcherTrigger(false)
+      return
+    }
+    recordWatcherTrigger(true)
+    if (inflight) {
+      pendingRerun = true
+      return
+    }
+    schedule()
+  }
+
+  function cancel() {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer)
+      debounceTimer = null
+    }
+    pendingRerun = false
+  }
+
+  return { trigger, cancel }
+}
 
 // ============================================================================
 // Native file watcher backend (direct mode)
@@ -16,30 +98,20 @@ const DEBOUNCE_MS = 300
 
 function createWatcherBackend(options: UseChangeDetectionOptions) {
   const active = ref(false)
-  const isProcessing = ref(false)
 
   let currentPath: string | null = null
   let unlisten: (() => void) | null = null
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null
   let lastProcessedAt = 0
 
+  const queue = createQueuedHandler(
+    options.onChanged,
+    () => Date.now() - lastProcessedAt < SELF_TRIGGER_COOLDOWN_MS,
+    () => { lastProcessedAt = Date.now() },
+  )
+
   const handleEvent = (payload: { path: string }) => {
     if (currentPath && payload.path !== currentPath) return
-    if (Date.now() - lastProcessedAt < SELF_TRIGGER_COOLDOWN_MS) return
-
-    if (debounceTimer) clearTimeout(debounceTimer)
-    debounceTimer = setTimeout(async () => {
-      if (isProcessing.value) return
-      isProcessing.value = true
-      try {
-        await options.onChanged()
-      } catch {
-        // Ignore errors — polling will catch up
-      } finally {
-        isProcessing.value = false
-        lastProcessedAt = Date.now()
-      }
-    }, DEBOUNCE_MS)
+    queue.trigger()
   }
 
   const start = async (path: string) => {
@@ -68,10 +140,7 @@ function createWatcherBackend(options: UseChangeDetectionOptions) {
   }
 
   const stop = () => {
-    if (debounceTimer) {
-      clearTimeout(debounceTimer)
-      debounceTimer = null
-    }
+    queue.cancel()
     if (unlisten) {
       unlisten()
       unlisten = null
@@ -94,29 +163,15 @@ function createWatcherBackend(options: UseChangeDetectionOptions) {
 
 function createSSEBackend(options: UseChangeDetectionOptions) {
   const active = ref(false)
-  const isProcessing = ref(false)
 
   let eventSource: EventSource | null = null
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null
   let lastProcessedAt = 0
 
-  const handleChange = () => {
-    if (Date.now() - lastProcessedAt < SELF_TRIGGER_COOLDOWN_MS) return
-
-    if (debounceTimer) clearTimeout(debounceTimer)
-    debounceTimer = setTimeout(async () => {
-      if (isProcessing.value) return
-      isProcessing.value = true
-      try {
-        await options.onChanged()
-      } catch {
-        // Ignore errors — polling will catch up
-      } finally {
-        isProcessing.value = false
-        lastProcessedAt = Date.now()
-      }
-    }, DEBOUNCE_MS)
-  }
+  const queue = createQueuedHandler(
+    options.onChanged,
+    () => Date.now() - lastProcessedAt < SELF_TRIGGER_COOLDOWN_MS,
+    () => { lastProcessedAt = Date.now() },
+  )
 
   const start = async (beadsPath: string) => {
     stop()
@@ -131,7 +186,7 @@ function createSSEBackend(options: UseChangeDetectionOptions) {
       const url = `${getExternalUrl()}/events/${encodeURIComponent(projectName)}`
       eventSource = new EventSource(url)
 
-      eventSource.addEventListener('change', () => handleChange())
+      eventSource.addEventListener('change', () => queue.trigger())
       eventSource.onopen = () => { active.value = true }
       eventSource.onerror = () => { active.value = false }
     } catch (e) {
@@ -142,10 +197,7 @@ function createSSEBackend(options: UseChangeDetectionOptions) {
   }
 
   const stop = () => {
-    if (debounceTimer) {
-      clearTimeout(debounceTimer)
-      debounceTimer = null
-    }
+    queue.cancel()
     eventSource?.close()
     eventSource = null
     active.value = false
diff --git a/app/composables/useColumnConfig.ts b/app/composables/useColumnConfig.ts
index 758aeabe..440b627b 100644
--- a/app/composables/useColumnConfig.ts
+++ b/app/composables/useColumnConfig.ts
@@ -61,6 +61,15 @@ export function useColumnConfig() {
     columns.value = newColumns
   }
 
+  const reorderColumns = (fromIndex: number, toIndex: number) => {
+    const reordered = [...columns.value]
+    const [moved] = reordered.splice(fromIndex, 1)
+    if (moved) {
+      reordered.splice(toIndex, 0, moved)
+      columns.value = reordered
+    }
+  }
+
   const resetColumns = () => {
     columns.value = [...defaultColumns]
   }
@@ -71,6 +80,7 @@ export function useColumnConfig() {
     toggleColumn,
     setColumnVisibility,
     setColumns,
+    reorderColumns,
     resetColumns,
   }
 }
diff --git a/app/composables/useExclusionFilters.ts b/app/composables/useExclusionFilters.ts
index 294174dd..e4aec68f 100644
--- a/app/composables/useExclusionFilters.ts
+++ b/app/composables/useExclusionFilters.ts
@@ -17,9 +17,15 @@ const defaultExclusions: ExclusionFilters = {
   assignee: [],
 }
 
+const validStatuses: IssueStatus[] = ['open', 'in_progress', 'blocked', 'closed', 'deferred', 'pinned', 'hooked']
+
 export function useExclusionFilters() {
   const exclusions = useProjectStorage<ExclusionFilters>('exclusionFilters', defaultExclusions)
 
+  if (import.meta.client) {
+    exclusions.value.status = exclusions.value.status.filter(status => validStatuses.includes(status))
+  }
+
   const toggleStatus = (status: IssueStatus) => {
     const index = exclusions.value.status.indexOf(status)
     if (index === -1) {
diff --git a/app/composables/useFilters.ts b/app/composables/useFilters.ts
index 38f8e773..a8da25a8 100644
--- a/app/composables/useFilters.ts
+++ b/app/composables/useFilters.ts
@@ -1,6 +1,8 @@
 import type { FilterState, IssueStatus, IssueType, IssuePriority } from '~/types/issue'
 import { useProjectStorage } from '~/composables/useProjectStorage'
 
+export const workflowStatuses: IssueStatus[] = ['open', 'in_progress', 'deferred', 'pinned', 'hooked']
+
 const defaultFilters: FilterState = {
   status: [],
   type: [],
@@ -13,11 +15,13 @@ const defaultFilters: FilterState = {
 export function useFilters() {
   const filters = useProjectStorage<FilterState>('filters', defaultFilters)
 
-  // Clear search, labels and assignee on init (should not persist across page loads)
+  // Clear transient filters on init and reset status to the default KPI view.
   if (import.meta.client) {
     filters.value.search = ''
     filters.value.labels = []
     filters.value.assignee = []
+    // Always reset to the default WORKFLOW view on load/refresh.
+    filters.value.status = [...workflowStatuses]
   }
 
   const toggleStatus = (status: IssueStatus) => {
@@ -82,6 +86,19 @@ export function useFilters() {
     filters.value.status = [...statuses]
   }
 
+  const allStatuses: IssueStatus[] = ['open', 'in_progress', 'blocked', 'closed', 'deferred', 'pinned', 'hooked']
+  const allTypes: IssueType[] = ['bug', 'task', 'feature', 'epic', 'chore']
+  const allPriorities: IssuePriority[] = ['p0', 'p1', 'p2', 'p3', 'p4']
+
+  const setAllFilters = () => {
+    filters.value.status = [...allStatuses]
+    filters.value.type = []
+    filters.value.priority = []
+    filters.value.assignee = []
+    filters.value.search = ''
+    filters.value.labels = []
+  }
+
   const hasActiveFilters = computed(() => {
     return (
       filters.value.status.length > 0 ||
@@ -103,6 +120,7 @@ export function useFilters() {
     toggleLabelFilter,
     clearFilters,
     setStatusFilter,
+    setAllFilters,
     hasActiveFilters,
   }
 }
diff --git a/app/composables/useIssues.ts b/app/composables/useIssues.ts
index 60760381..dcafc04d 100644
--- a/app/composables/useIssues.ts
+++ b/app/composables/useIssues.ts
@@ -3,6 +3,7 @@ import { bdList, bdCount, bdShow, bdCreate, bdUpdate, bdClose, bdDelete, bdAddCo
 import { useProjectStorage } from '~/composables/useProjectStorage'
 import {
   deduplicateIssues,
+  pruneClosedBlockers,
   naturalCompare,
   getParentIdFromIssue,
   compareChildIssues,
@@ -83,15 +84,13 @@ export function useEpicExpand() {
  */
 function notifyStatusTransitions(oldIssues: Issue[], newIssues: Issue[]) {
   const { success: notifySuccess } = useNotification()
-  const oldStatusMap = new Map(oldIssues.map(i => [i.id, { status: i.status, title: i.title }]))
+  const oldStatusMap = new Map(oldIssues.map(i => [i.id, { status: i.status }]))
 
   for (const issue of newIssues) {
     const old = oldStatusMap.get(issue.id)
     if (old && old.status !== issue.status) {
       if (issue.status === 'closed') {
         notifySuccess(`Issue ${issue.id} closed`, issue.title)
-      } else if (issue.status === 'tombstone') {
-        notifySuccess(`Issue ${issue.id} deleted`, old.title)
       } else if (old.status === 'closed') {
         notifySuccess(`Issue ${issue.id} reopened`, issue.title)
       }
@@ -186,6 +185,8 @@ export function useIssues() {
         }
       }
 
+      pruneClosedBlockers(newIssues)
+
       // Only update if data actually changed (compare by serialization)
       const currentSignature = JSON.stringify(issues.value.map(i => i.id + i.updatedAt))
       const newSignature = JSON.stringify(newIssues.map(i => i.id + i.updatedAt))
@@ -301,23 +302,21 @@ export function useIssues() {
 
       // Preserve blockedBy/blocks from previous enrichments (fetchIssues or fetchIssue)
       // Poll data doesn't return these, but they were populated by earlier bdShow calls.
-      // Filter out blockers that are now closed so lock icons disappear (#7).
       const existingMap = new Map(issues.value.map(i => [i.id, i]))
-      const closedIds = new Set(newIssues.filter(i => i.status === 'closed').map(i => i.id))
       for (const issue of newIssues) {
         const existing = existingMap.get(issue.id)
         if (existing) {
           if (!issue.blockedBy && existing.blockedBy) {
-            const stillOpen = existing.blockedBy.filter(id => !closedIds.has(id))
-            if (stillOpen.length) issue.blockedBy = stillOpen
+            issue.blockedBy = [...existing.blockedBy]
           }
           if (!issue.blocks && existing.blocks) {
-            const stillOpen = existing.blocks.filter(id => !closedIds.has(id))
-            if (stillOpen.length) issue.blocks = stillOpen
+            issue.blocks = [...existing.blocks]
           }
         }
       }
 
+      pruneClosedBlockers(newIssues)
+
       // Only update if data actually changed
       // Signature includes status+priority+title so probe mode (no updatedAt) still detects changes
       const sig = (i: Issue) => `${i.id}|${i.updatedAt}|${i.status}|${i.priority}|${i.title}`
@@ -483,6 +482,8 @@ export function useIssues() {
         }
       }
 
+      pruneClosedBlockers([...issues.value, data])
+
       selectedIssue.value = data
 
       // Also update the issue in the issues array to keep in sync
@@ -532,6 +533,7 @@ export function useIssues() {
         if (selectedIssue.value?.id === id) {
           selectedIssue.value = data
         }
+        pruneClosedBlockers([...issues.value, data])
       }
 
       return data
@@ -579,6 +581,11 @@ export function useIssues() {
         }
       }
 
+      pruneClosedBlockers(issues.value)
+      if (selectedIssue.value) {
+        pruneClosedBlockers([selectedIssue.value, ...issues.value])
+      }
+
       return result
     } catch (e) {
       error.value = e instanceof Error ? e.message : 'Failed to close issue'
diff --git a/app/composables/usePinnedIssues.ts b/app/composables/usePinnedIssues.ts
index 3432a03d..34f662dc 100644
--- a/app/composables/usePinnedIssues.ts
+++ b/app/composables/usePinnedIssues.ts
@@ -35,7 +35,7 @@ export function usePinnedIssues() {
     const issueMap = new Map(allIssues.map(i => [i.id, i]))
     const filtered = pinnedIssueIds.value
       .map(id => issueMap.get(id))
-      .filter((i): i is Issue => !!i && i.status !== 'closed' && i.status !== 'tombstone')
+      .filter((i): i is Issue => !!i && i.status !== 'closed')
 
     if (pinnedSortMode.value === 'added') {
       // Reverse pinned order: most recently pinned first
diff --git a/app/composables/usePipelineDiagnostics.ts b/app/composables/usePipelineDiagnostics.ts
new file mode 100644
index 00000000..2716913f
--- /dev/null
+++ b/app/composables/usePipelineDiagnostics.ts
@@ -0,0 +1,168 @@
+/**
+ * Pipeline diagnostics for watcher → poll pipeline.
+ *
+ * Tracks: watcher batches, emitted/suppressed events, poll start/finish/duration,
+ * deferred runs, and self-write cooldown hits. All counters are plain numbers
+ * (no Vue reactivity) to avoid observer overhead on hot paths.
+ *
+ * Exposes a compact snapshot for DebugPanel and support triage.
+ * Console logging is rate-limited (at most once per LOG_INTERVAL_MS).
+ */
+
+const LOG_INTERVAL_MS = 5_000
+
+interface PipelineCounters {
+  // Watcher / change detection
+  watcherTriggers: number
+  watcherCooldownSkips: number
+  watcherDebounces: number
+  watcherReruns: number
+
+  // Poll scheduler
+  pollRequests: number
+  pollExecuted: number
+  pollSkipped: number
+  pollDeferred: number
+  pollImmediateRequests: number
+
+  // Poll execution
+  pollStarted: number
+  pollFinished: number
+  pollErrors: number
+  pollTotalMs: number
+  pollLastMs: number
+  pollMaxMs: number
+
+  // Mtime fast-check
+  mtimeChecks: number
+  mtimeHits: number
+}
+
+function createCounters(): PipelineCounters {
+  return {
+    watcherTriggers: 0,
+    watcherCooldownSkips: 0,
+    watcherDebounces: 0,
+    watcherReruns: 0,
+    pollRequests: 0,
+    pollExecuted: 0,
+    pollSkipped: 0,
+    pollDeferred: 0,
+    pollImmediateRequests: 0,
+    pollStarted: 0,
+    pollFinished: 0,
+    pollErrors: 0,
+    pollTotalMs: 0,
+    pollLastMs: 0,
+    pollMaxMs: 0,
+    mtimeChecks: 0,
+    mtimeHits: 0,
+  }
+}
+
+// Singleton state
+const counters = createCounters()
+let lastLogAt = 0
+let startedAt = Date.now()
+
+/** Rate-limited console log (at most once per LOG_INTERVAL_MS). */
+function maybeLog(tag: string, detail?: string) {
+  const now = Date.now()
+  if (now - lastLogAt < LOG_INTERVAL_MS) return
+  lastLogAt = now
+  const msg = detail ? `[diag][${tag}] ${detail}` : `[diag][${tag}]`
+  console.debug(msg)
+}
+
+// ── Recording API (called from pipeline composables) ────────────────────
+
+function recordWatcherTrigger(accepted: boolean) {
+  if (accepted) {
+    counters.watcherTriggers++
+  } else {
+    counters.watcherCooldownSkips++
+  }
+  maybeLog('watcher', `trigger accepted=${accepted} total=${counters.watcherTriggers} cooldownSkips=${counters.watcherCooldownSkips}`)
+}
+
+function recordWatcherDebounce() {
+  counters.watcherDebounces++
+}
+
+function recordWatcherRerun() {
+  counters.watcherReruns++
+}
+
+function recordPollRequest(kind: 'normal' | 'immediate') {
+  counters.pollRequests++
+  if (kind === 'immediate') counters.pollImmediateRequests++
+}
+
+function recordPollDecision(decision: 'executed' | 'skipped' | 'deferred') {
+  counters[`poll${decision.charAt(0).toUpperCase() + decision.slice(1)}` as keyof PipelineCounters] =
+    (counters[`poll${decision.charAt(0).toUpperCase() + decision.slice(1)}` as keyof PipelineCounters] as number) + 1
+  maybeLog('scheduler', `decision=${decision} executed=${counters.pollExecuted} skipped=${counters.pollSkipped} deferred=${counters.pollDeferred}`)
+}
+
+function recordPollStart() {
+  counters.pollStarted++
+}
+
+function recordPollFinish(durationMs: number, error: boolean) {
+  counters.pollFinished++
+  counters.pollTotalMs += durationMs
+  counters.pollLastMs = durationMs
+  if (durationMs > counters.pollMaxMs) counters.pollMaxMs = durationMs
+  if (error) counters.pollErrors++
+  maybeLog('poll', `duration=${durationMs}ms avg=${Math.round(counters.pollTotalMs / counters.pollFinished)}ms max=${counters.pollMaxMs}ms errors=${counters.pollErrors}`)
+}
+
+function recordMtimeCheck(hit: boolean) {
+  counters.mtimeChecks++
+  if (hit) counters.mtimeHits++
+}
+
+// ── Snapshot API (for DebugPanel / support triage) ──────────────────────
+
+interface PipelineSnapshot {
+  uptimeSeconds: number
+  counters: PipelineCounters
+  pollAvgMs: number
+}
+
+function snapshot(): PipelineSnapshot {
+  const avgMs = counters.pollFinished > 0
+    ? Math.round(counters.pollTotalMs / counters.pollFinished)
+    : 0
+
+  return {
+    uptimeSeconds: Math.round((Date.now() - startedAt) / 1000),
+    counters: { ...counters },
+    pollAvgMs: avgMs,
+  }
+}
+
+function reset() {
+  Object.assign(counters, createCounters())
+  startedAt = Date.now()
+  lastLogAt = 0
+}
+
+// ── Composable ──────────────────────────────────────────────────────────
+
+export function usePipelineDiagnostics() {
+  return {
+    // Recording
+    recordWatcherTrigger,
+    recordWatcherDebounce,
+    recordWatcherRerun,
+    recordPollRequest,
+    recordPollDecision,
+    recordPollStart,
+    recordPollFinish,
+    recordMtimeCheck,
+    // Snapshot
+    snapshot,
+    reset,
+  }
+}
diff --git a/app/composables/usePollScheduler.ts b/app/composables/usePollScheduler.ts
new file mode 100644
index 00000000..e7417902
--- /dev/null
+++ b/app/composables/usePollScheduler.ts
@@ -0,0 +1,122 @@
+/**
+ * Poll scheduler with backpressure gate.
+ *
+ * Merges all poll triggers (watcher, adaptive timer, manual) through a single
+ * gate that enforces a minimum interval between expensive poll cycles.
+ *
+ * - `requestPoll()` — trigger from watcher or timer. Respects min interval.
+ * - `requestImmediatePoll()` — manual refresh. Bypasses min interval.
+ * - `stats` — lightweight instrumentation (skipped, deferred, executed counts).
+ */
+
+import { usePipelineDiagnostics } from './usePipelineDiagnostics'
+
+const DEFAULT_MIN_INTERVAL_MS = 2_000
+
+interface PollSchedulerOptions {
+  /** Minimum ms between expensive poll cycles (default: 2000). */
+  minInterval?: number
+}
+
+export function usePollScheduler(
+  pollFn: () => Promise<void>,
+  options?: PollSchedulerOptions,
+) {
+  const minInterval = options?.minInterval ?? DEFAULT_MIN_INTERVAL_MS
+  const { recordPollRequest, recordPollDecision } = usePipelineDiagnostics()
+
+  let lastPollEnd = 0
+  let inflight = false
+  let deferredTimer: ReturnType<typeof setTimeout> | null = null
+
+  // Lightweight instrumentation (plain object — no reactivity needed for counters)
+  const stats = {
+    executed: 0,
+    skipped: 0,
+    deferred: 0,
+  }
+
+  const clearDeferred = () => {
+    if (deferredTimer) {
+      clearTimeout(deferredTimer)
+      deferredTimer = null
+    }
+  }
+
+  const runPoll = async () => {
+    if (inflight) {
+      stats.skipped++
+      recordPollDecision('skipped')
+      return
+    }
+    inflight = true
+    try {
+      await pollFn()
+      stats.executed++
+      recordPollDecision('executed')
+    } finally {
+      inflight = false
+      lastPollEnd = Date.now()
+    }
+  }
+
+  /**
+   * Request a poll (from watcher or timer). Enforces min interval:
+   * - If enough time has passed → runs immediately.
+   * - If too soon → schedules a deferred poll at the end of the window.
+   * - If already inflight or a deferred poll is pending → skips.
+   */
+  const requestPoll = () => {
+    recordPollRequest('normal')
+
+    if (inflight) {
+      stats.skipped++
+      recordPollDecision('skipped')
+      return
+    }
+
+    const elapsed = Date.now() - lastPollEnd
+    if (elapsed >= minInterval) {
+      clearDeferred()
+      runPoll()
+      return
+    }
+
+    // Too soon — defer to end of cooldown window (if not already deferred)
+    if (deferredTimer) {
+      stats.skipped++
+      recordPollDecision('skipped')
+      return
+    }
+
+    stats.deferred++
+    recordPollDecision('deferred')
+    const remaining = minInterval - elapsed
+    deferredTimer = setTimeout(() => {
+      deferredTimer = null
+      runPoll()
+    }, remaining)
+  }
+
+  /**
+   * Request an immediate poll (manual refresh). Bypasses min interval.
+   * Still prevents concurrent polls.
+   */
+  const requestImmediatePoll = () => {
+    recordPollRequest('immediate')
+    clearDeferred()
+    runPoll()
+  }
+
+  /** Cancel any pending deferred poll. */
+  const cancel = () => {
+    clearDeferred()
+  }
+
+  return {
+    requestPoll,
+    requestImmediatePoll,
+    cancel,
+    stats,
+  }
+}
diff --git a/app/composables/useTauriWindow.ts b/app/composables/useTauriWindow.ts
index 9fb2f741..29093bc8 100644
--- a/app/composables/useTauriWindow.ts
+++ b/app/composables/useTauriWindow.ts
@@ -1,4 +1,5 @@
 let windowModule: typeof import('@tauri-apps/api/window') | null = null
+let setTitlePermissionDeniedLogged = false
 
 // Pre-load the Tauri window module
 if (import.meta.client) {
@@ -12,13 +13,21 @@ if (import.meta.client) {
 export function useTauriWindow() {
   const startDragging = () => {
     if (windowModule) {
-      windowModule.getCurrentWindow().startDragging()
+      windowModule.getCurrentWindow().startDragging().catch(() => {
+        // Ignore drag failures in unsupported environments.
+      })
     }
   }
 
   const setWindowTitle = (title: string) => {
     if (windowModule) {
-      windowModule.getCurrentWindow().setTitle(title)
+      windowModule.getCurrentWindow().setTitle(title).catch((error) => {
+        // Some capability profiles may deny changing title; do not break app render.
+        if (!setTitlePermissionDeniedLogged) {
+          setTitlePermissionDeniedLogged = true
+          console.warn('Unable to set window title:', error)
+        }
+      })
     }
   }
 
diff --git a/app/pages/index.vue b/app/pages/index.vue
index b4c927b5..c6ac5e10 100644
--- a/app/pages/index.vue
+++ b/app/pages/index.vue
@@ -1,5 +1,6 @@
 <script setup lang="ts">
-import type { Issue, UpdateIssuePayload } from '~/types/issue'
+import type { Issue, IssueStatus, UpdateIssuePayload } from '~/types/issue'
+import { isIssueBlocked } from '~/utils/issue-helpers'
 
 // Layout components
 import AppHeader from '~/components/layout/AppHeader.vue'
@@ -44,7 +45,7 @@ import {
 } from '~/components/ui/tooltip'
 
 // Composables
-const { filters, toggleStatus, toggleType, togglePriority, toggleAssignee, clearFilters, setStatusFilter, setSearch, toggleLabelFilter } = useFilters()
+const { filters, toggleStatus, toggleType, togglePriority, toggleAssignee, clearFilters, setStatusFilter, setAllFilters, setSearch, toggleLabelFilter } = useFilters()
 const { columns, toggleColumn, setColumns, resetColumns } = useColumnConfig()
 const { beadsPath, hasStoredPath } = useBeadsPath()
 const { success: notifySuccess, error: notifyError } = useNotification()
@@ -186,31 +187,16 @@ const checkViewport = () => {
 const { showErrorDialog: showSyncErrorDialog, lastSyncError, closeErrorDialog: closeSyncErrorDialog } = useSyncStatus()
 
 // Change detection: native file watcher via Tauri events
-const { active: changeDetectionActive, startListening, stopListening, notifySelfWrite } = useChangeDetection({
-  onChanged: async () => {
-    await pollForChanges()
-  },
-})
-
-// Polling for external changes — optimized with 5 layers:
+// Polling for external changes — optimized with 6 layers:
 // 1. Native file watcher (0 CPU when idle, instant detection)
-// 2. Sync cooldown (Rust backend skips redundant syncs within 10s)
-// 3. Filesystem mtime check as fallback (zero bd processes if nothing changed)
-// 4. Batched poll command (1 IPC call instead of 3 when changes detected)
-// 5. Adaptive intervals (30s safety net when watcher active, 5s/1s fallback without watcher)
+// 2. Poll scheduler backpressure (min 2s between expensive cycles)
+// 3. Sync cooldown (Rust backend skips redundant syncs within 10s)
+// 4. Filesystem mtime check as fallback (zero bd processes if nothing changed)
+// 5. Batched poll command (1 IPC call instead of 3 when changes detected)
+// 6. Adaptive intervals (30s safety net when watcher active, 5s/1s fallback without watcher)
 const isSyncing = ref(false)
 let skipMtimeCheck = false // Set by watcher/fast check to avoid redundant bdCheckChanged in pollFn
-
-// Fast change detection (cheap mtime stat, ~0ms) — runs every 1s when active
-const checkMtimeChanged = async (): Promise<boolean> => {
-  if (isLoading.value || isUpdating.value || showOnboarding.value || !beadsPath.value || projects.value.length === 0) {
-    return false
-  }
-  const path = beadsPath.value && beadsPath.value !== '.' ? beadsPath.value : undefined
-  const changed = await bdCheckChanged(path)
-  if (changed) skipMtimeCheck = true // pollFn can skip the mtime check — we already consumed it
-  return changed
-}
+const { recordPollStart, recordPollFinish, recordMtimeCheck } = usePipelineDiagnostics()
 
 const pollForChanges = async () => {
   // Don't poll if no active project
@@ -218,14 +204,19 @@ const pollForChanges = async () => {
     return
   }
 
+  const pollT0 = performance.now()
+  let hadError = false
+  recordPollStart()
+
   try {
     isSyncing.value = true
 
     const path = beadsPath.value && beadsPath.value !== '.' ? beadsPath.value : undefined
 
-    // Layer 2: Check filesystem mtime first — skip if fast check already detected change
+    // Layer 4: Check filesystem mtime first — skip if fast check already detected change
     if (!skipMtimeCheck) {
       const changed = await bdCheckChanged(path)
+      recordMtimeCheck(changed)
       if (!changed) {
         // Nothing changed on disk — skip entire poll cycle
         return
@@ -233,7 +224,7 @@ const pollForChanges = async () => {
     }
     skipMtimeCheck = false
 
-    // Layer 3: Changes detected — use batched command (1 IPC instead of 3)
+    // Layer 5: Changes detected — use batched command (1 IPC instead of 3)
     const readyData = await fetchPollData()
 
     // Update dashboard from pre-fetched data (no extra API call)
@@ -248,18 +239,44 @@ const pollForChanges = async () => {
     // Tell change detection backend to ignore self-triggered events
     notifySelfWrite()
   } catch {
-    // Ignore polling errors
+    hadError = true
   } finally {
     isSyncing.value = false
+    recordPollFinish(Math.round(performance.now() - pollT0), hadError)
   }
 }
 
-// Adaptive polling with fast mtime detection (degrades gracefully if watcher unavailable)
-const { start: startPolling, stop: stopPolling } = useAdaptivePolling(pollForChanges, {
-  checkFn: checkMtimeChanged,
-  watcherActive: changeDetectionActive,
+// Layer 2: Backpressure gate — merges watcher + timer triggers, enforces min interval
+const { requestPoll, requestImmediatePoll, cancel: cancelScheduledPoll, stats: pollStats } = usePollScheduler(pollForChanges)
+
+const { active: changeDetectionActive, startListening, stopListening, notifySelfWrite } = useChangeDetection({
+  onChanged: async () => {
+    requestPoll()
+  },
 })
 
+// Fast change detection (cheap mtime stat, ~0ms) — runs every 1s when active
+const checkMtimeChanged = async (): Promise<boolean> => {
+  if (isLoading.value || isUpdating.value || showOnboarding.value || !beadsPath.value || projects.value.length === 0) {
+    return false
+  }
+  const path = beadsPath.value && beadsPath.value !== '.' ? beadsPath.value : undefined
+  const changed = await bdCheckChanged(path)
+  recordMtimeCheck(changed)
+  if (changed) skipMtimeCheck = true // pollFn can skip the mtime check — we already consumed it
+  return changed
+}
+
+// Adaptive polling with fast mtime detection (degrades gracefully if watcher unavailable)
+// Polls go through the scheduler's backpressure gate
+const { start: startPolling, stop: stopPolling } = useAdaptivePolling(
+  () => { requestPoll(); return Promise.resolve() },
+  {
+    checkFn: checkMtimeChanged,
+    watcherActive: changeDetectionActive,
+  },
+)
+
 onMounted(async () => {
   checkViewport()
   if (import.meta.client) {
@@ -322,6 +339,7 @@ onUnmounted(() => {
     window.removeEventListener('resize', checkViewport)
     stopListening()
     stopPolling()
+    cancelScheduledPoll()
     stopPeriodicCheck()
     // Auto-unregister from probe (fire-and-forget)
     probeUnregisterProject(beadsPath.value)
@@ -714,6 +732,11 @@ const inProgressIssues = computed(() => {
   return issues.value.filter(issue => issue.status === 'in_progress')
 })
 
+// Blocked issues for dashboard sidebar (explicit blocked status + dependency-blocked)
+const blockedIssues = computed(() => {
+  return issues.value.filter(issue => isIssueBlocked(issue))
+})
+
 // Pinned issues
 const { pinnedIssueIds, pinnedSortMode, isPinned, togglePin, reorderPinned, toggleSortMode: togglePinnedSort, getPinnedIssues } = usePinnedIssues()
 const pinnedIssuesList = computed(() => getPinnedIssues(issues.value))
@@ -738,10 +761,19 @@ const handleRemoveLabelFilter = (label: string) => {
 }
 
 // KPI filter handlers
-type KpiFilter = 'total' | 'open' | 'in_progress' | 'blocked'
+type KpiFilter = 'total' | 'open' | 'in_progress' | 'blocked' | 'workflow'
+const allStatusFilters: IssueStatus[] = ['open', 'in_progress', 'blocked', 'closed', 'deferred', 'pinned', 'hooked']
+const workflowStatusFilters = workflowStatuses
+
+const matchesStatusFilters = (selected: IssueStatus[], expected: IssueStatus[]) => {
+  if (selected.length !== expected.length) return false
+  return expected.every(status => selected.includes(status))
+}
+
 const activeKpiFilter = computed<KpiFilter | null>(() => {
   const statusFilters = filters.value.status
-  if (statusFilters.length === 0) return null
+  if (statusFilters.length === 0 || matchesStatusFilters(statusFilters, workflowStatusFilters)) return 'workflow'
+  if (matchesStatusFilters(statusFilters, allStatusFilters)) return 'total'
   if (statusFilters.length === 1 && statusFilters[0] === 'open') return 'open'
   if (statusFilters.length === 1 && statusFilters[0] === 'in_progress') return 'in_progress'
   if (statusFilters.length === 1 && statusFilters[0] === 'blocked') return 'blocked'
@@ -749,8 +781,10 @@ const activeKpiFilter = computed<KpiFilter | null>(() => {
 })
 
 const handleKpiClick = (kpi: KpiFilter) => {
-  if (kpi === 'total') {
-    clearFilters()
+  if (kpi === 'workflow') {
+    setStatusFilter([...workflowStatusFilters])
+  } else if (kpi === 'total') {
+    setAllFilters()
   } else if (kpi === 'open') {
     setStatusFilter(['open'])
   } else if (kpi === 'in_progress') {
@@ -836,12 +870,13 @@ watch(
             <PathSelector v-if="!showOnboarding" ref="pathSelectorRef" :is-loading="isLoading" @change="handlePathChange" @reset="handleReset" />
 
             <div v-if="stats" class="space-y-4 mt-6">
-              <div class="grid grid-cols-4 gap-1.5">
-                <KpiCard title="Total" :value="stats.total" :active="activeKpiFilter === null && filters.status.length === 0" @click="handleKpiClick('total')" />
+              <div class="flex flex-wrap gap-1.5 p-0.5 -m-0.5">
+                <KpiCard title="Workflow" :value="stats.workflow" color="var(--color-status-deferred)" :active="activeKpiFilter === 'workflow'" @click="handleKpiClick('workflow')" />
                 <KpiCard title="Open" :value="stats.open" color="var(--color-status-open)" :active="activeKpiFilter === 'open'" @click="handleKpiClick('open')" />
                 <KpiCard title="In Progress" :value="stats.inProgress" color="var(--color-status-in-progress)" :active="activeKpiFilter === 'in_progress'" @click="handleKpiClick('in_progress')" />
                 <KpiCard title="Blocked" :value="stats.blocked" color="var(--color-status-blocked)" :active="activeKpiFilter === 'blocked'" @click="handleKpiClick('blocked')" />
-              </div>
+                <KpiCard title="All" :value="stats.total" :active="activeKpiFilter === 'total'" @click="handleKpiClick('total')" />
+            </div>
             </div>
 
             <div v-if="!stats" class="flex items-center justify-center py-8">
@@ -857,10 +892,10 @@ watch(
               :stats="stats"
               :ready-issues="readyIssues"
               :in-progress-issues="inProgressIssues"
+              :blocked-issues="blockedIssues"
               :pinned-issues="pinnedIssuesList"
               :pinned-sort-mode="pinnedSortMode"
               :active-kpi-filter="activeKpiFilter"
-              :status-filters="filters.status"
               @select-issue="handleSelectIssue"
               @kpi-click="handleKpiClick"
               @reorder-pinned="reorderPinned"
@@ -1091,11 +1126,11 @@ watch(
             :stats="stats"
             :ready-issues="readyIssues"
             :in-progress-issues="inProgressIssues"
+            :blocked-issues="blockedIssues"
             :pinned-issues="pinnedIssuesList"
             :pinned-sort-mode="pinnedSortMode"
             :kpi-grid-cols="2"
             :active-kpi-filter="activeKpiFilter"
-            :status-filters="filters.status"
             :show-onboarding="showOnboarding"
             @select-issue="handleSelectIssue"
             @kpi-click="handleKpiClick"
@@ -1385,7 +1420,7 @@ watch(
             <ul class="list-disc list-inside text-sm space-y-1 ml-2">
               <li>A new Dolt database will be created (<code class="text-xs">bd init</code>)</li>
               <li>Your issues will be imported from the JSONL backup file (<code class="text-xs">bd import</code>)</li>
-              <li>None of your issues will be lost — only previously deleted issues (tombstones) are skipped</li>
+              <li>None of your active issues will be lost during migration</li>
             </ul>
             <p v-if="migrateError" class="text-destructive text-sm">
               Error: {{ migrateError }}
diff --git a/app/types/issue.ts b/app/types/issue.ts
index bdf90511..adb37f75 100644
--- a/app/types/issue.ts
+++ b/app/types/issue.ts
@@ -1,5 +1,5 @@
 export type IssueType = 'bug' | 'task' | 'feature' | 'epic' | 'chore'
-export type IssueStatus = 'open' | 'in_progress' | 'blocked' | 'closed' | 'deferred' | 'tombstone' | 'pinned' | 'hooked'
+export type IssueStatus = 'open' | 'in_progress' | 'blocked' | 'closed' | 'deferred' | 'pinned' | 'hooked'
 export type IssuePriority = 'p0' | 'p1' | 'p2' | 'p3' | 'p4'
 
 export interface Comment {
@@ -84,6 +84,7 @@ export interface DashboardStats {
   inProgress: number
   blocked: number
   closed: number
+  workflow: number
   ready: number
   byType: Record<IssueType, number>
   byPriority: Record<IssuePriority, number>
diff --git a/app/utils/issue-helpers.ts b/app/utils/issue-helpers.ts
index 7e742948..11d4745b 100644
--- a/app/utils/issue-helpers.ts
+++ b/app/utils/issue-helpers.ts
@@ -29,6 +29,57 @@ export function deduplicateIssues(issues: Issue[]): Issue[] {
   return Array.from(issueMap.values())
 }
 
+/**
+ * Remove closed issue IDs from dependency references.
+ *
+ * `bd list/show` can return stale `blockedBy`/`blocks` links after a blocker is
+ * closed. Pruning them here keeps status-column blocker indicators accurate.
+ */
+export function pruneClosedBlockers(issues: Issue[]): void {
+  const closedIds = new Set(
+    issues
+      .filter(issue => issue.status === 'closed')
+      .map(issue => issue.id),
+  )
+
+  if (closedIds.size === 0) return
+
+  for (const issue of issues) {
+    if (issue.blockedBy?.length) {
+      const activeBlockers = issue.blockedBy.filter(id => !closedIds.has(id))
+      issue.blockedBy = activeBlockers.length ? activeBlockers : undefined
+    }
+
+    if (issue.blocks?.length) {
+      const activeBlockedIssues = issue.blocks.filter(id => !closedIds.has(id))
+      issue.blocks = activeBlockedIssues.length ? activeBlockedIssues : undefined
+    }
+  }
+}
+
+/**
+ * Determine whether an issue should appear in blocked views.
+ *
+ * Supports both explicit blocked status and dependency-based blockers
+ * (`blockedBy`) while ignoring closed issues.
+ */
+export function isIssueBlocked(issue: Pick<Issue, 'status' | 'blockedBy'>): boolean {
+  if (issue.status === 'blocked') return true
+  if (!issue.blockedBy?.length) return false
+  return issue.status !== 'closed'
+}
+
+/**
+ * Determine whether an issue belongs in the WORKFLOW view.
+ *
+ * WORKFLOW includes everything except closed/deleted/tombstone and blocked.
+ */
+export function isIssueWorkflow(issue: Pick<Issue, 'status' | 'blockedBy'>): boolean {
+  const status = issue.status as string
+  if (status === 'closed' || status === 'deleted' || status === 'tombstone') return false
+  return !isIssueBlocked(issue)
+}
+
 /**
  * Natural sort comparison for IDs (handles multi-digit numbers correctly).
  * e.g., "40b.2" < "40b.10" instead of "40b.10" < "40b.2"
@@ -199,11 +250,11 @@ export function filterIssues(
 ): Issue[] {
   let result = issues
 
-  // Search bypasses all other filters
+  // Text search filter
   const searchTerm = filters.search?.trim()
   if (searchTerm) {
     const search = searchTerm.toLowerCase()
-    return result.filter(
+    result = result.filter(
       (issue) =>
         issue.title.toLowerCase().includes(search) ||
         issue.id.toLowerCase().includes(search) ||
@@ -211,11 +262,17 @@ export function filterIssues(
     )
   }
 
-  // Status filter (default: exclude closed + tombstone)
+  // Status filter (default: WORKFLOW view)
   if (filters.status.length > 0) {
-    result = result.filter((issue) => filters.status.includes(issue.status))
+    const includeBlocked = filters.status.includes('blocked')
+    result = result.filter((issue) => {
+      if (includeBlocked && isIssueBlocked(issue)) return true
+      // Exclude dependency-blocked issues when 'blocked' is not in the filter
+      if (!includeBlocked && isIssueBlocked(issue)) return false
+      return filters.status.includes(issue.status)
+    })
   } else {
-    result = result.filter((issue) => issue.status !== 'closed' && issue.status !== 'tombstone')
+    result = result.filter((issue) => isIssueWorkflow(issue))
   }
 
   if (filters.type.length > 0) {
@@ -241,7 +298,11 @@ export function filterIssues(
 
   // Exclusion filters
   if (exclusions.status.length > 0) {
-    result = result.filter(issue => !exclusions.status.includes(issue.status))
+    const excludeBlocked = exclusions.status.includes('blocked')
+    result = result.filter((issue) => {
+      if (excludeBlocked && isIssueBlocked(issue)) return false
+      return !exclusions.status.includes(issue.status)
+    })
   }
   if (exclusions.priority.length > 0) {
     result = result.filter(issue => !exclusions.priority.includes(issue.priority))
@@ -344,7 +405,7 @@ export function groupIssues(
 
 /**
  * Compute dashboard stats from an issues array.
- * Excludes tombstone issues. Groups open/deferred/pinned/hooked as "open".
+ * "open" counts only true open issues to match the Open KPI filter.
  */
 export function computeStatsFromIssues(issues: Issue[]): DashboardStats {
   const stats: DashboardStats = {
@@ -353,31 +414,31 @@ export function computeStatsFromIssues(issues: Issue[]): DashboardStats {
     inProgress: 0,
     blocked: 0,
     closed: 0,
+    workflow: 0,
     ready: 0,
     byType: { bug: 0, task: 0, feature: 0, epic: 0, chore: 0 },
     byPriority: { p0: 0, p1: 0, p2: 0, p3: 0, p4: 0 },
   }
 
-  const activeIssues = issues.filter((issue) => issue.status !== 'tombstone')
-  stats.total = activeIssues.length
+  for (const issue of issues) {
+    if (isIssueWorkflow(issue)) {
+      stats.workflow++
+    }
 
-  for (const issue of activeIssues) {
-    switch (issue.status) {
-      case 'open':
-      case 'deferred':
-      case 'pinned':
-      case 'hooked':
-        stats.open++
-        break
-      case 'in_progress':
-        stats.inProgress++
-        break
-      case 'blocked':
-        stats.blocked++
-        break
-      case 'closed':
-        stats.closed++
-        break
+    if (isIssueBlocked(issue)) {
+      stats.blocked++
+    } else {
+      switch (issue.status) {
+        case 'open':
+          stats.open++
+          break
+        case 'in_progress':
+          stats.inProgress++
+          break
+        case 'closed':
+          stats.closed++
+          break
+      }
     }
 
     if (issue.type in stats.byType) {
@@ -389,6 +450,8 @@ export function computeStatsFromIssues(issues: Issue[]): DashboardStats {
     }
   }
 
+  stats.total = issues.length
+
   return stats
 }
 
diff --git a/docs/churn-stress-runbook.md b/docs/churn-stress-runbook.md
new file mode 100644
index 00000000..f9dcee74
--- /dev/null
+++ b/docs/churn-stress-runbook.md
@@ -0,0 +1,121 @@
+# .beads Churn Stress Test Runbook
+
+## Overview
+
+This document describes how to reproduce and validate that the app remains responsive under sustained `.beads` file write churn (e.g., concurrent writers, CI pipelines, rapid issue creation).
+
+## Architecture Summary
+
+The change detection pipeline has multiple layers of protection:
+
+```
+Filesystem events
+  → Rust watcher (1s debounce, 2s min emit interval)
+    → Frontend debounce (300ms)
+      → Queued handler (single-flight + max 5 reruns)
+        → Poll scheduler (2s backpressure gate)
+          → Data fetch
+```
+
+## Key Constants
+
+| Constant | Value | Location | Purpose |
+|----------|-------|----------|---------|
+| `WATCHER_DEBOUNCE_INTERVAL_MS` | 1000ms | `src-tauri/src/lib.rs` | Rust-side debounce of filesystem events |
+| `WATCHER_MIN_EMIT_INTERVAL_MS` | 2000ms | `src-tauri/src/lib.rs` | Min time between emitting events to frontend (env-overridable) |
+| `DEBOUNCE_MS` | 300ms | `app/composables/useChangeDetection.ts` | Frontend event debounce |
+| `SELF_TRIGGER_COOLDOWN_MS` | 3000ms | `app/composables/useChangeDetection.ts` | Ignore self-writes for this long |
+| `MAX_CONSECUTIVE_RERUNS` | 5 | `app/composables/useChangeDetection.ts` | Max sequential reruns per handler activation |
+| `DEFAULT_MIN_INTERVAL_MS` | 2000ms | `app/composables/usePollScheduler.ts` | Backpressure gate min interval |
+| `INTERVAL_ACTIVE` | 5000ms | `app/composables/useAdaptivePolling.ts` | Poll interval when active (no watcher) |
+| `INTERVAL_WATCHER_SAFETY` | 30000ms | `app/composables/useAdaptivePolling.ts` | Safety-net poll when watcher is active |
+
+## Reproduction
+
+### Automated (CI / Local)
+
+Run the vitest stress tests:
+
+```bash
+pnpm test -- tests/composables/churn-stress.test.ts
+```
+
+These tests simulate 500+ rapid trigger events over simulated time and verify:
+- `onChanged` call count stays bounded (< 100 for 500 triggers)
+- Poll execution count stays bounded (< 20 for 200 triggers over 20s)
+- Pipeline converges after burst activity
+- Consecutive reruns bounded by `MAX_CONSECUTIVE_RERUNS`
+
+### Manual (with running app)
+
+1. Start the app: `pnpm tauri:dev`
+2. Open the pipeline diagnostics panel (Ctrl+Shift+D or console)
+3. Run the churn script in another terminal:
+
+```bash
+# Default: 60s of writes every 50ms to .beads/
+./scripts/churn-stress.sh
+
+# Custom: 5 minutes at 20ms intervals against a specific directory
+./scripts/churn-stress.sh /path/to/project/.beads 300 20
+```
+
+4. Observe the app — it should remain responsive throughout.
+
+### Expected Metrics
+
+Under default churn (20 writes/sec for 60s = ~1200 writes):
+
+| Metric | Expected | Alarm threshold |
+|--------|----------|-----------------|
+| UI frame drops | < 5 | > 20 sustained |
+| Poll executions | ~30 (≈ 60s / 2s gate) | > 60 |
+| Watcher triggers (frontend) | ~60 (≈ 60s / 1s emit) | > 120 |
+| Watcher cooldown skips | 0 (no self-writes) | > 10 |
+| Consecutive rerun cap hits | 0 | > 5 |
+| Poll avg duration | < 500ms | > 2000ms |
+
+## Tuning Guide
+
+### If the UI still freezes
+
+1. **Increase `WATCHER_MIN_EMIT_INTERVAL_MS`**: Set environment variable before launching:
+   ```bash
+   WATCHER_MIN_EMIT_INTERVAL_MS=5000 pnpm tauri:dev
+   ```
+   This reduces the rate of events reaching the frontend. Min value: 250ms.
+
+2. **Increase `DEFAULT_MIN_INTERVAL_MS`** in `usePollScheduler.ts`: Widens the backpressure gate. Try 5000ms.
+
+3. **Decrease `MAX_CONSECUTIVE_RERUNS`** in `useChangeDetection.ts`: Reduces how many times the handler re-enters before yielding. Try 2-3.
+
+### If changes feel slow to appear
+
+1. **Decrease `WATCHER_MIN_EMIT_INTERVAL_MS`**: Set to 500ms for faster event delivery.
+2. **Decrease `DEFAULT_MIN_INTERVAL_MS`**: Set to 1000ms for more frequent polls.
+3. **Decrease `DEBOUNCE_MS`**: Set to 100ms for faster trigger response.
+
+### Rollback
+
+To revert all tuning to defaults, remove any environment variable overrides and restore the source constants:
+
+```
+WATCHER_DEBOUNCE_INTERVAL_MS = 1000
+WATCHER_MIN_EMIT_INTERVAL_MS = 2000
+DEBOUNCE_MS = 300
+SELF_TRIGGER_COOLDOWN_MS = 3000
+MAX_CONSECUTIVE_RERUNS = 5
+DEFAULT_MIN_INTERVAL_MS = 2000
+```
+
+## Diagnostics
+
+The pipeline diagnostics composable (`usePipelineDiagnostics`) provides real-time counters:
+
+- `watcherTriggers` / `watcherCooldownSkips` — events reaching/filtered at frontend
+- `watcherDebounces` / `watcherReruns` — debounce resets and rerun loops
+- `pollRequests` / `pollExecuted` / `pollSkipped` / `pollDeferred` — scheduler decisions
+- `pollAvgMs` / `pollMaxMs` — execution timing
+- `mtimeChecks` / `mtimeHits` — fast change detection stats
+
+Access via `usePipelineDiagnostics().snapshot()` in console or the diagnostics panel.
diff --git a/scripts/churn-stress.sh b/scripts/churn-stress.sh
new file mode 100755
index 00000000..f3a40fb0
--- /dev/null
+++ b/scripts/churn-stress.sh
@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# churn-stress.sh — Generate controlled .beads file churn for stress testing
+#
+# Usage: ./scripts/churn-stress.sh [BEADS_DIR] [DURATION_SECS] [INTERVAL_MS]
+#   BEADS_DIR     — path to .beads directory (default: .beads)
+#   DURATION_SECS — how long to run (default: 60)
+#   INTERVAL_MS   — ms between writes (default: 50)
+#
+# Creates a temporary churn file inside the .beads directory and writes to it
+# at the specified interval. Cleans up on exit (SIGINT/SIGTERM).
+#
+# Expected behavior: the app should remain responsive throughout. Observe via
+# the pipeline diagnostics panel (Ctrl+Shift+D) or console logs.
+#
+# Exit codes:
+#   0 — completed successfully
+#   1 — .beads directory not found
+
+set -euo pipefail
+
+BEADS_DIR="${1:-.beads}"
+DURATION_SECS="${2:-60}"
+INTERVAL_MS="${3:-50}"
+
+if [[ ! -d "$BEADS_DIR" ]]; then
+  echo "Error: .beads directory not found at '$BEADS_DIR'" >&2
+  exit 1
+fi
+
+CHURN_FILE="$BEADS_DIR/.churn-stress-$$"
+INTERVAL_S=$(awk "BEGIN {printf \"%.3f\", $INTERVAL_MS / 1000}")
+
+cleanup() {
+  rm -f "$CHURN_FILE"
+}
+trap cleanup EXIT
+
+echo "churn-stress: writing to $CHURN_FILE every ${INTERVAL_MS}ms for ${DURATION_SECS}s"
+
+writes=0
+start_epoch=$(date +%s)
+last_report=$start_epoch
+
+while true; do
+  now=$(date +%s)
+  elapsed=$((now - start_epoch))
+
+  if (( elapsed >= DURATION_SECS )); then
+    break
+  fi
+
+  writes=$((writes + 1))
+  echo "$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ) write=$writes" > "$CHURN_FILE"
+
+  if (( now - last_report >= 10 )); then
+    if (( elapsed > 0 )); then
+      rate=$(awk "BEGIN {printf \"%.1f\", $writes / $elapsed}")
+    else
+      rate="$writes"
+    fi
+    echo "  [${elapsed}s] writes=$writes rate=${rate}/s"
+    last_report=$now
+  fi
+
+  sleep "$INTERVAL_S"
+done
+
+end_epoch=$(date +%s)
+total_elapsed=$((end_epoch - start_epoch))
+if (( total_elapsed > 0 )); then
+  avg_rate=$(awk "BEGIN {printf \"%.1f\", $writes / $total_elapsed}")
+else
+  avg_rate="$writes"
+fi
+
+echo ""
+echo "churn-stress: done"
+echo "  total writes : $writes"
+echo "  duration     : ${total_elapsed}s"
+echo "  avg rate     : ${avg_rate}/s"
diff --git a/server/utils/bd-transformers.ts b/server/utils/bd-transformers.ts
index 2ce97890..698ab686 100644
--- a/server/utils/bd-transformers.ts
+++ b/server/utils/bd-transformers.ts
@@ -23,6 +23,13 @@ interface BdRawIssue {
     content?: string
     created_at: string
   }>
+  dependencies?: Array<{
+    issue_id?: string
+    depends_on_id?: string
+    id?: string
+    type?: string
+    dependency_type?: string
+  }>
   dependency_count?: number
   dependent_count?: number
   external_ref?: string
@@ -61,7 +68,7 @@ export function normalizeIssueType(type: string): IssueType {
  * Validate and normalize issue status
  */
 export function normalizeIssueStatus(status: string): IssueStatus {
-  const validStatuses: IssueStatus[] = ['open', 'in_progress', 'blocked', 'closed']
+  const validStatuses: IssueStatus[] = ['open', 'in_progress', 'blocked', 'closed', 'deferred', 'pinned', 'hooked']
   return validStatuses.includes(status as IssueStatus) ? (status as IssueStatus) : 'open'
 }
 
@@ -69,6 +76,22 @@ export function normalizeIssueStatus(status: string): IssueStatus {
  * Transform raw bd CLI issue to Issue type interface
  */
 export function transformIssue(raw: BdRawIssue): Issue {
+  // Compute blockedBy from dependencies (mirroring Tauri/Rust logic)
+  const blockedBy = [...(raw.blocked_by || [])]
+  if (raw.dependencies) {
+    for (const dep of raw.dependencies) {
+      const depType = dep.dependency_type || dep.type
+      // bd show format: { id, dependency_type: "blocks" }
+      if (depType === 'blocks' && dep.id && !blockedBy.includes(dep.id)) {
+        blockedBy.push(dep.id)
+      }
+      // bd list format: { issue_id, depends_on_id, type: "blocks" }
+      if (depType === 'blocks' && dep.depends_on_id && !blockedBy.includes(dep.depends_on_id)) {
+        blockedBy.push(dep.depends_on_id)
+      }
+    }
+  }
+
   return {
     id: raw.id,
     title: raw.title,
@@ -87,7 +110,7 @@ export function transformIssue(raw: BdRawIssue): Issue {
       content: c.text || c.content || '',
       createdAt: c.created_at,
     })),
-    blockedBy: raw.blocked_by,
+    blockedBy: blockedBy.length > 0 ? blockedBy : undefined,
     blocks: raw.blocks,
     externalRef: raw.external_ref,
     estimateMinutes: raw.estimate,
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index b978e54e..5920f0ca 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -130,7 +130,7 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "beads-issue-tracker"
-version = "1.24.1"
+version = "1.24.2"
 dependencies = [
  "dirs",
  "dotenvy",
diff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.json
index 09b85d8a..1689265a 100644
--- a/src-tauri/capabilities/default.json
+++ b/src-tauri/capabilities/default.json
@@ -6,6 +6,7 @@
   "permissions": [
     "core:default",
     "core:window:allow-start-dragging",
+    "core:window:allow-set-title",
     "core:window:allow-close",
     "shell:allow-open",
     "shell:allow-execute",
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 9ea46234..dc6b2e27 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -1,13 +1,13 @@
 use notify_debouncer_mini::{new_debouncer, DebouncedEventKind};
 use serde::{Deserialize, Serialize};
-use tauri::Emitter;
+use tauri::{Emitter, WebviewWindowBuilder};
 use std::collections::HashMap;
 use std::env;
 use std::fs;
 use std::path::PathBuf;
 use std::process::Command;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{LazyLock, Mutex};
+use std::sync::{Arc, LazyLock, Mutex};
 use std::time::{Duration, Instant};
 
 // Global flags for logging
@@ -136,6 +136,8 @@ pub struct BdCliUpdateInfo {
 struct WatcherState {
     debouncer: Option<notify_debouncer_mini::Debouncer<notify::RecommendedWatcher>>,
     watched_path: Option<String>,
+    watch_session_id: u64,
+    project_emit_state: HashMap<String, Arc<Mutex<ProjectWatcherEmitState>>>,
 }
 
 impl Default for WatcherState {
@@ -143,10 +145,141 @@ impl Default for WatcherState {
         Self {
             debouncer: None,
             watched_path: None,
+            watch_session_id: 0,
+            project_emit_state: HashMap::new(),
         }
     }
 }
 
+#[derive(Debug)]
+struct ProjectWatcherEmitState {
+    session_id: u64,
+    last_emit: Option<Instant>,
+    pending: bool,
+    flush_scheduled: bool,
+    emitted_batches: u64,
+    suppressed_batches: u64,
+}
+
+impl ProjectWatcherEmitState {
+    fn new(session_id: u64) -> Self {
+        Self {
+            session_id,
+            last_emit: None,
+            pending: false,
+            flush_scheduled: false,
+            emitted_batches: 0,
+            suppressed_batches: 0,
+        }
+    }
+}
+
+const WATCHER_DEBOUNCE_INTERVAL_MS: u64 = 1000;
+const WATCHER_MIN_EMIT_INTERVAL_MS_DEFAULT: u64 = 2000;
+
+static WATCHER_MIN_EMIT_INTERVAL_MS: LazyLock<u64> = LazyLock::new(|| {
+    env::var("WATCHER_MIN_EMIT_INTERVAL_MS")
+        .ok()
+        .and_then(|value| value.parse::<u64>().ok())
+        .unwrap_or(WATCHER_MIN_EMIT_INTERVAL_MS_DEFAULT)
+        .max(250)
+});
+
+fn watcher_min_emit_interval() -> Duration {
+    Duration::from_millis(*WATCHER_MIN_EMIT_INTERVAL_MS)
+}
+
+fn should_process_watcher_event(event: &notify_debouncer_mini::DebouncedEvent) -> bool {
+    if !matches!(event.kind, DebouncedEventKind::Any | DebouncedEventKind::AnyContinuous) {
+        return false;
+    }
+
+    let path = event.path.to_string_lossy().replace('\\', "/").to_lowercase();
+    if !path.contains("/.beads/") {
+        return false;
+    }
+
+    // Ignore high-churn internal files that do not carry issue data.
+    !(path.contains("/.beads/.dolt/stats/")
+        || path.contains("/.beads/.dolt/tmp/")
+        || path.contains("/.beads/.dolt/.tmp/")
+        || path.ends_with(".lock")
+        || path.ends_with(".tmp")
+        || path.ends_with(".swp")
+        || path.ends_with('~'))
+}
+
+fn emit_beads_changed(app_handle: &tauri::AppHandle, project_path: &str) {
+    if let Err(err) = app_handle.emit(
+        "beads-changed",
+        BeadsChangedPayload {
+            path: project_path.to_string(),
+        },
+    ) {
+        log::error!("[watcher] Failed to emit beads-changed for {}: {:?}", project_path, err);
+    }
+}
+
+fn schedule_pending_watcher_emit(
+    app_handle: tauri::AppHandle,
+    project_path: String,
+    emit_state: Arc<Mutex<ProjectWatcherEmitState>>,
+    session_id: u64,
+) {
+    std::thread::spawn(move || {
+        let min_interval = watcher_min_emit_interval();
+        loop {
+            let mut should_emit = false;
+            let mut counters = None;
+            let mut wait_time = Duration::from_millis(50);
+
+            match emit_state.lock() {
+                Ok(mut state) => {
+                    if state.session_id != session_id || !state.pending {
+                        state.flush_scheduled = false;
+                        return;
+                    }
+
+                    let can_emit_now = state
+                        .last_emit
+                        .map(|last| last.elapsed() >= min_interval)
+                        .unwrap_or(true);
+
+                    if can_emit_now {
+                        state.pending = false;
+                        state.flush_scheduled = false;
+                        state.last_emit = Some(Instant::now());
+                        state.emitted_batches += 1;
+                        counters = Some((state.emitted_batches, state.suppressed_batches));
+                        should_emit = true;
+                    } else if let Some(last_emit) = state.last_emit {
+                        wait_time = min_interval.saturating_sub(last_emit.elapsed());
+                    }
+                }
+                Err(err) => {
+                    log::error!("[watcher] Failed to lock emit state for delayed flush: {}", err);
+                    return;
+                }
+            }
+
+            if should_emit {
+                emit_beads_changed(&app_handle, &project_path);
+                if let Some((emitted, suppressed)) = counters {
+                    log::info!(
+                        "[watcher] Delayed coalesced emit for {} (emitted={}, suppressed={})",
+                        project_path,
+                        emitted,
+                        suppressed
+                    );
+                }
+                return;
+            }
+
+            std::thread::sleep(wait_time);
+        }
+    });
+}
+
 #[derive(Debug, Clone, Serialize)]
 struct BeadsChangedPayload {
     path: String,
@@ -449,7 +582,7 @@ fn normalize_issue_type(issue_type: &str) -> String {
 }
 
 fn normalize_issue_status(status: &str) -> String {
-    let valid_statuses = ["open", "in_progress", "blocked", "closed", "deferred", "tombstone", "pinned", "hooked"];
+    let valid_statuses = ["open", "in_progress", "blocked", "closed", "deferred", "pinned", "hooked"];
     if valid_statuses.contains(&status) {
         status.to_string()
     } else {
@@ -4409,10 +4542,22 @@ fn start_watching(
     state: tauri::State<'_, Mutex<WatcherState>>,
 ) -> Result<(), String> {
     let mut watcher_state = state.lock().map_err(|e| format!("Lock error: {}", e))?;
+    watcher_state.watch_session_id = watcher_state.watch_session_id.wrapping_add(1);
+    let watch_session_id = watcher_state.watch_session_id;
 
     // Stop existing watcher if any
     if watcher_state.debouncer.is_some() {
         log::info!("[watcher] Stopping previous watcher for: {:?}", watcher_state.watched_path);
+        if let Some(previous_path) = watcher_state.watched_path.clone() {
+            if let Some(previous_emit_state) = watcher_state.project_emit_state.get(&previous_path) {
+                if let Ok(mut emit_state) = previous_emit_state.lock() {
+                    emit_state.session_id = watch_session_id;
+                    emit_state.pending = false;
+                    emit_state.flush_scheduled = false;
+                }
+            }
+            watcher_state.project_emit_state.remove(&previous_path);
+        }
         watcher_state.debouncer = None;
         watcher_state.watched_path = None;
     }
@@ -4424,21 +4569,98 @@ fn start_watching(
 
     let project_path = path.clone();
     let app_handle = app.clone();
+    let project_emit_state = watcher_state
+        .project_emit_state
+        .entry(path.clone())
+        .or_insert_with(|| Arc::new(Mutex::new(ProjectWatcherEmitState::new(watch_session_id))))
+        .clone();
+    {
+        let mut emit_state = project_emit_state
+            .lock()
+            .map_err(|e| format!("Watcher emit-state lock error: {}", e))?;
+        *emit_state = ProjectWatcherEmitState::new(watch_session_id);
+    }
 
     let mut debouncer = new_debouncer(
-        Duration::from_millis(1000),
+        Duration::from_millis(WATCHER_DEBOUNCE_INTERVAL_MS),
         move |res: Result<Vec<notify_debouncer_mini::DebouncedEvent>, notify::Error>| {
             match res {
                 Ok(events) => {
-                    // Filter: only emit if we have actual data-change events
-                    let has_data_events = events.iter().any(|e| {
-                        matches!(e.kind, DebouncedEventKind::Any | DebouncedEventKind::AnyContinuous)
-                    });
-                    if has_data_events {
-                        log::info!("[watcher] Change detected in .beads/ ({} events)", events.len());
-                        let _ = app_handle.emit(
-                            "beads-changed",
-                            BeadsChangedPayload { path: project_path.clone() },
+                    let relevant_count = events
+                        .iter()
+                        .filter(|event| should_process_watcher_event(event))
+                        .count();
+                    if relevant_count == 0 {
+                        return;
+                    }
+
+                    let mut emit_now = false;
+                    let mut schedule_delayed_emit = false;
+                    let mut counters = None;
+                    let min_interval = watcher_min_emit_interval();
+
+                    match project_emit_state.lock() {
+                        Ok(mut emit_state) => {
+                            if emit_state.session_id != watch_session_id {
+                                return;
+                            }
+
+                            let can_emit_now = emit_state
+                                .last_emit
+                                .map(|last| last.elapsed() >= min_interval)
+                                .unwrap_or(true);
+
+                            if can_emit_now {
+                                emit_state.pending = false;
+                                emit_state.last_emit = Some(Instant::now());
+                                emit_state.emitted_batches += 1;
+                                counters = Some((emit_state.emitted_batches, emit_state.suppressed_batches));
+                                emit_now = true;
+                            } else {
+                                emit_state.pending = true;
+                                emit_state.suppressed_batches += 1;
+                                counters = Some((emit_state.emitted_batches, emit_state.suppressed_batches));
+                                if !emit_state.flush_scheduled {
+                                    emit_state.flush_scheduled = true;
+                                    schedule_delayed_emit = true;
+                                }
+                            }
+                        }
+                        Err(err) => {
+                            log::error!("[watcher] Failed to lock emit state for {}: {}", project_path, err);
+                            return;
+                        }
+                    }
+
+                    if emit_now {
+                        emit_beads_changed(&app_handle, &project_path);
+                        if let Some((emitted, suppressed)) = counters {
+                            log::info!(
+                                "[watcher] Emitted coalesced update for {} (events={}, relevant={}, emitted={}, suppressed={})",
+                                project_path,
+                                events.len(),
+                                relevant_count,
+                                emitted,
+                                suppressed
+                            );
+                        }
+                    } else if let Some((emitted, suppressed)) = counters {
+                        log::info!(
+                            "[watcher] Suppressed watcher batch for {} (events={}, relevant={}, emitted={}, suppressed={})",
+                            project_path,
+                            events.len(),
+                            relevant_count,
+                            emitted,
+                            suppressed
+                        );
+                    }
+
+                    if schedule_delayed_emit {
+                        schedule_pending_watcher_emit(
+                            app_handle.clone(),
+                            project_path.clone(),
+                            project_emit_state.clone(),
+                            watch_session_id,
                         );
                     }
                 }
@@ -4474,9 +4696,21 @@ fn stop_watching(
     state: tauri::State<'_, Mutex<WatcherState>>,
 ) -> Result<(), String> {
     let mut watcher_state = state.lock().map_err(|e| format!("Lock error: {}", e))?;
+    watcher_state.watch_session_id = watcher_state.watch_session_id.wrapping_add(1);
+    let watch_session_id = watcher_state.watch_session_id;
 
     if watcher_state.debouncer.is_some() {
         log::info!("[watcher] Stopped watching: {:?}", watcher_state.watched_path);
+        if let Some(previous_path) = watcher_state.watched_path.clone() {
+            if let Some(previous_emit_state) = watcher_state.project_emit_state.get(&previous_path) {
+                if let Ok(mut emit_state) = previous_emit_state.lock() {
+                    emit_state.session_id = watch_session_id;
+                    emit_state.pending = false;
+                    emit_state.flush_scheduled = false;
+                }
+            }
+            watcher_state.project_emit_state.remove(&previous_path);
+        }
         watcher_state.debouncer = None;
         watcher_state.watched_path = None;
     }
@@ -4701,6 +4935,16 @@ pub fn run() {
                     .build(),
             )?;
 
+            // Create the main window from config, applying titleBarStyle only on macOS
+            let window_config = &app.config().app.windows[0];
+            #[allow(unused_mut)]
+            let mut builder = WebviewWindowBuilder::from_config(app.handle(), window_config)?;
+            #[cfg(target_os = "macos")]
+            {
+                builder = builder.title_bar_style(tauri::TitleBarStyle::Overlay);
+            }
+            builder.build()?;
+
             // Log startup info
             log::info!("=== Beads Task-Issue Tracker starting ===");
             log::info!("[startup] Extended PATH: {}", get_extended_path());
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 058883ac..ae5df56e 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -20,7 +20,7 @@
         "resizable": true,
         "fullscreen": false,
         "decorations": true,
-        "titleBarStyle": "Overlay"
+        "create": false
       }
     ],
     "security": {
diff --git a/tests/composables/churn-stress.test.ts b/tests/composables/churn-stress.test.ts
new file mode 100644
index 00000000..d627eaf4
--- /dev/null
+++ b/tests/composables/churn-stress.test.ts
@@ -0,0 +1,230 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { createQueuedHandler } from '~/composables/useChangeDetection'
+import { usePollScheduler } from '~/composables/usePollScheduler'
+
+describe('churn stress', () => {
+  beforeEach(() => { vi.useFakeTimers() })
+  afterEach(() => { vi.useRealTimers() })
+
+  // ── helpers ──────────────────────────────────────────────────────────
+
+  function setupHandler(opts: { onChangedMs?: number } = {}) {
+    let resolvers: Array<() => void> = []
+    const onChanged = vi.fn(() => {
+      if (opts.onChangedMs != null) {
+        return new Promise<void>((resolve) => { resolvers.push(resolve) })
+      }
+      return Promise.resolve()
+    })
+    const onProcessed = vi.fn()
+
+    const handler = createQueuedHandler(onChanged, () => false, onProcessed)
+
+    return {
+      handler,
+      onChanged,
+      onProcessed,
+      resolveLatest: () => {
+        const r = resolvers.shift()
+        r?.()
+        return vi.advanceTimersByTimeAsync(0)
+      },
+    }
+  }
+
+  // ── (a) Sustained rapid triggers don't cause unbounded calls ────────
+
+  it('sustained rapid triggers stay bounded', async () => {
+    const { handler, onChanged } = setupHandler()
+
+    // Fire 500 triggers over 30s in bursts: trigger, then advance enough
+    // for some debounces to fire (mix of short and long gaps).
+    for (let i = 0; i < 500; i++) {
+      handler.trigger()
+      // Every 5th trigger, advance past DEBOUNCE_MS so calls actually fire.
+      // Other triggers advance only 10ms, resetting the debounce.
+      if (i % 5 === 4) {
+        await vi.advanceTimersByTimeAsync(350)
+      } else {
+        await vi.advanceTimersByTimeAsync(10)
+      }
+    }
+    // Drain final debounce
+    await vi.advanceTimersByTimeAsync(300)
+
+    // 500 triggers, but debounce collapses groups of ~5 into 1 call.
+    // Expect roughly 100 calls — well below 500.
+    expect(onChanged.mock.calls.length).toBeLessThan(150)
+    expect(onChanged.mock.calls.length).toBeGreaterThan(0)
+  })
+
+  // ── (b) Queue + scheduler pipeline stress ───────────────────────────
+
+  it('queue + scheduler pipeline stays bounded', async () => {
+    let inflightCount = 0
+    let maxInflight = 0
+
+    let pollResolvers: Array<() => void> = []
+    const pollFn = vi.fn(() => new Promise<void>((resolve) => {
+      inflightCount++
+      maxInflight = Math.max(maxInflight, inflightCount)
+      pollResolvers.push(() => {
+        inflightCount--
+        resolve()
+      })
+    }))
+
+    const scheduler = usePollScheduler(pollFn, { minInterval: 2_000 })
+
+    const onChanged = vi.fn(async () => {
+      scheduler.requestPoll()
+    })
+    const onProcessed = vi.fn()
+    const handler = createQueuedHandler(onChanged, () => false, onProcessed)
+
+    // Fire 200 triggers over ~20s. Use bursts of 10 rapid triggers
+    // followed by enough time for debounce to fire, so onChanged actually
+    // calls requestPoll repeatedly.
+    for (let i = 0; i < 200; i++) {
+      handler.trigger()
+      // Every 10th trigger, advance past debounce so onChanged fires
+      if (i % 10 === 9) {
+        await vi.advanceTimersByTimeAsync(350)
+      } else {
+        await vi.advanceTimersByTimeAsync(50)
+      }
+      // Resolve any pending poll so the pipeline keeps flowing
+      while (pollResolvers.length > 0) {
+        const r = pollResolvers.shift()
+        r?.()
+        await vi.advanceTimersByTimeAsync(0)
+      }
+    }
+
+    // Drain remaining deferred timers
+    await vi.advanceTimersByTimeAsync(3_000)
+    while (pollResolvers.length > 0) {
+      const r = pollResolvers.shift()
+      r?.()
+      await vi.advanceTimersByTimeAsync(0)
+    }
+
+    // With 2s min interval over ~20s, pollFn should execute ≤ ~12 times
+    expect(scheduler.stats.executed).toBeLessThan(20)
+    expect(scheduler.stats.executed).toBeGreaterThan(0)
+
+    // Skipped + deferred should outnumber executed
+    const nonExecuted = scheduler.stats.skipped + scheduler.stats.deferred
+    expect(nonExecuted).toBeGreaterThan(scheduler.stats.executed)
+
+    // No concurrent polls ever
+    expect(maxInflight).toBeLessThanOrEqual(1)
+  })
+
+  // ── (c) Burst followed by quiet converges ───────────────────────────
+
+  it('burst followed by quiet fully settles', async () => {
+    let pollResolvers: Array<() => void> = []
+    const pollFn = vi.fn(() => new Promise<void>((resolve) => {
+      pollResolvers.push(resolve)
+    }))
+
+    const scheduler = usePollScheduler(pollFn, { minInterval: 2_000 })
+
+    const onChanged = vi.fn(async () => {
+      scheduler.requestPoll()
+    })
+    const onProcessed = vi.fn()
+    const handler = createQueuedHandler(onChanged, () => false, onProcessed)
+
+    // Burst: 50 rapid triggers in 100ms (every 2ms)
+    for (let i = 0; i < 50; i++) {
+      handler.trigger()
+      await vi.advanceTimersByTimeAsync(2)
+    }
+
+    // Let debounce fire
+    await vi.advanceTimersByTimeAsync(300)
+
+    // Resolve all polls that were started
+    while (pollResolvers.length > 0) {
+      const r = pollResolvers.shift()
+      r?.()
+      await vi.advanceTimersByTimeAsync(0)
+    }
+
+    // Quiet period — advance 10s with no new triggers
+    await vi.advanceTimersByTimeAsync(10_000)
+
+    // Resolve any final deferred polls
+    while (pollResolvers.length > 0) {
+      const r = pollResolvers.shift()
+      r?.()
+      await vi.advanceTimersByTimeAsync(0)
+    }
+
+    // Pipeline should have settled: pollFn was called at least once
+    expect(pollFn.mock.calls.length).toBeGreaterThan(0)
+
+    // No more pending work — advancing more time should not trigger anything
+    const callsAfterSettle = pollFn.mock.calls.length
+    await vi.advanceTimersByTimeAsync(5_000)
+    expect(pollFn.mock.calls.length).toBe(callsAfterSettle)
+
+    // Last poll ran to completion (no unresolved promises)
+    expect(pollResolvers).toHaveLength(0)
+  })
+
+  // ── (d) Continuous rerun bounding under churn ───────────────────────
+
+  it('consecutive reruns are bounded by MAX_CONSECUTIVE_RERUNS', async () => {
+    let resolvers: Array<() => void> = []
+    const onChanged = vi.fn(() => new Promise<void>((resolve) => {
+      resolvers.push(resolve)
+    }))
+    const onProcessed = vi.fn()
+
+    const handler = createQueuedHandler(onChanged, () => false, onProcessed)
+
+    // Initial trigger → debounce fires → first onChanged starts
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged).toHaveBeenCalledTimes(1)
+
+    // Keep firing triggers before each resolution to keep pendingRerun set.
+    // MAX_CONSECUTIVE_RERUNS = 5, so the while loop should stop after 5
+    // iterations (including the first run that resets the counter).
+    for (let i = 0; i < 10; i++) {
+      handler.trigger() // set pendingRerun
+      const r = resolvers.shift()
+      r?.()
+      await vi.advanceTimersByTimeAsync(0)
+    }
+
+    // The handler should have stopped re-entering after at most 6 calls
+    // (1 initial + up to 5 consecutive reruns = 6 total, but the loop
+    // resets consecutiveReruns to 0 at the start so the initial run counts
+    // as rerun #1 after increment → max 5+1=6).
+    expect(onChanged.mock.calls.length).toBeLessThanOrEqual(6)
+    expect(onChanged.mock.calls.length).toBeGreaterThanOrEqual(2)
+
+    // After the handler stops, further triggers should schedule a fresh
+    // debounce rather than immediately re-entering.
+    const callsBefore = onChanged.mock.calls.length
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(0)
+    // No immediate call — still debouncing
+    expect(onChanged.mock.calls.length).toBe(callsBefore)
+
+    // Resolve any remaining in-flight call
+    while (resolvers.length > 0) {
+      const r = resolvers.shift()
+      r?.()
+      await vi.advanceTimersByTimeAsync(0)
+    }
+
+    // After debounce, a new run starts fresh
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged.mock.calls.length).toBeGreaterThan(callsBefore)
+  })
+})
diff --git a/tests/composables/useChangeDetection.test.ts b/tests/composables/useChangeDetection.test.ts
new file mode 100644
index 00000000..6fed6fd8
--- /dev/null
+++ b/tests/composables/useChangeDetection.test.ts
@@ -0,0 +1,174 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { createQueuedHandler } from '~/composables/useChangeDetection'
+
+describe('createQueuedHandler', () => {
+  beforeEach(() => { vi.useFakeTimers() })
+  afterEach(() => { vi.useRealTimers() })
+
+  function setup(opts: { onChangedMs?: number; cooldown?: boolean } = {}) {
+    const calls: number[] = []
+    let callId = 0
+    let resolvers: Array<() => void> = []
+
+    const onChanged = vi.fn(() => {
+      const id = ++callId
+      calls.push(id)
+      if (opts.onChangedMs != null) {
+        return new Promise<void>((resolve) => {
+          resolvers.push(resolve)
+        })
+      }
+      return Promise.resolve()
+    })
+
+    const cooldownActive = opts.cooldown ?? false
+    const onProcessed = vi.fn()
+
+    const handler = createQueuedHandler(
+      onChanged,
+      () => cooldownActive,
+      onProcessed,
+    )
+
+    return {
+      handler,
+      onChanged,
+      onProcessed,
+      calls,
+      resolveLatest: () => {
+        const r = resolvers.shift()
+        r?.()
+        return vi.advanceTimersByTimeAsync(0)
+      },
+    }
+  }
+
+  it('debounces rapid triggers into a single call', async () => {
+    const { handler, onChanged } = setup()
+
+    handler.trigger()
+    handler.trigger()
+    handler.trigger()
+
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged).toHaveBeenCalledTimes(1)
+  })
+
+  it('at most one onChanged in flight', async () => {
+    const { handler, onChanged, resolveLatest } = setup({ onChangedMs: 100 })
+
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(300) // debounce fires, onChanged starts
+    expect(onChanged).toHaveBeenCalledTimes(1)
+
+    // Trigger again while in-flight — should set pendingRerun, not start another
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged).toHaveBeenCalledTimes(1) // still just 1
+
+    // Resolve the first call — triggers the pending rerun
+    await resolveLatest()
+    expect(onChanged).toHaveBeenCalledTimes(2)
+  })
+
+  it('collapses multiple events during processing into one follow-up', async () => {
+    const { handler, onChanged, resolveLatest } = setup({ onChangedMs: 100 })
+
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged).toHaveBeenCalledTimes(1)
+
+    // Fire many events while in-flight
+    for (let i = 0; i < 10; i++) {
+      handler.trigger()
+    }
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged).toHaveBeenCalledTimes(1) // still 1
+
+    // Resolve — exactly one follow-up
+    await resolveLatest()
+    expect(onChanged).toHaveBeenCalledTimes(2)
+
+    // Resolve the follow-up — no more calls
+    await resolveLatest()
+    expect(onChanged).toHaveBeenCalledTimes(2)
+  })
+
+  it('respects self-write cooldown', async () => {
+    const { handler, onChanged } = setup({ cooldown: true })
+
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged).not.toHaveBeenCalled()
+  })
+
+  it('bounds consecutive reruns', async () => {
+    // onChanged takes time, and events keep arriving, so pendingRerun is always set
+    let resolvers: Array<() => void> = []
+    const onChanged = vi.fn(() => new Promise<void>((resolve) => {
+      resolvers.push(resolve)
+    }))
+    const onProcessed = vi.fn()
+
+    const handler = createQueuedHandler(onChanged, () => false, onProcessed)
+
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged).toHaveBeenCalledTimes(1)
+
+    // Continuously fire events and resolve calls to test bounding
+    for (let i = 0; i < 10; i++) {
+      handler.trigger() // set pendingRerun
+      const r = resolvers.shift()
+      r?.()
+      await vi.advanceTimersByTimeAsync(0)
+    }
+
+    // Should be bounded at MAX_CONSECUTIVE_RERUNS (5) + the initial = 6 max,
+    // but since the initial counts as the first in the run loop, it's 5 total.
+    expect(onChanged.mock.calls.length).toBeLessThanOrEqual(6)
+    expect(onChanged.mock.calls.length).toBeGreaterThanOrEqual(2)
+  })
+
+  it('cancel stops pending debounce timer', async () => {
+    const { handler, onChanged } = setup()
+
+    handler.trigger()
+    handler.cancel()
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onChanged).not.toHaveBeenCalled()
+  })
+
+  it('calls onProcessed after each onChanged completes', async () => {
+    const { handler, onProcessed } = setup()
+
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(300)
+    expect(onProcessed).toHaveBeenCalledTimes(1)
+  })
+
+  it('handles onChanged errors gracefully and still reruns', async () => {
+    let callCount = 0
+    let resolvers: Array<(err?: Error) => void> = []
+    const onChanged = vi.fn(() => new Promise<void>((resolve, reject) => {
+      callCount++
+      resolvers.push((err) => err ? reject(err) : resolve())
+    }))
+    const onProcessed = vi.fn()
+
+    const handler = createQueuedHandler(onChanged, () => false, onProcessed)
+
+    handler.trigger()
+    await vi.advanceTimersByTimeAsync(300)
+
+    // Set pending rerun, then reject the first call
+    handler.trigger()
+    const r = resolvers.shift()
+    r?.(new Error('fail'))
+    await vi.advanceTimersByTimeAsync(0)
+
+    // Should have started the rerun despite the error
+    expect(onChanged).toHaveBeenCalledTimes(2)
+    expect(onProcessed).toHaveBeenCalledTimes(1) // first call still triggers onProcessed
+  })
+})
diff --git a/tests/composables/usePipelineDiagnostics.test.ts b/tests/composables/usePipelineDiagnostics.test.ts
new file mode 100644
index 00000000..fc67a944
--- /dev/null
+++ b/tests/composables/usePipelineDiagnostics.test.ts
@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { usePipelineDiagnostics } from '~/composables/usePipelineDiagnostics'
+
+describe('usePipelineDiagnostics', () => {
+  let diag: ReturnType<typeof usePipelineDiagnostics>
+
+  beforeEach(() => {
+    diag = usePipelineDiagnostics()
+    diag.reset()
+  })
+
+  it('starts with zero counters', () => {
+    const snap = diag.snapshot()
+    expect(snap.counters.watcherTriggers).toBe(0)
+    expect(snap.counters.pollExecuted).toBe(0)
+    expect(snap.counters.mtimeChecks).toBe(0)
+    expect(snap.pollAvgMs).toBe(0)
+  })
+
+  it('tracks watcher triggers', () => {
+    diag.recordWatcherTrigger(true)
+    diag.recordWatcherTrigger(true)
+    diag.recordWatcherTrigger(false)
+
+    const snap = diag.snapshot()
+    expect(snap.counters.watcherTriggers).toBe(2)
+    expect(snap.counters.watcherCooldownSkips).toBe(1)
+  })
+
+  it('tracks watcher debounces and reruns', () => {
+    diag.recordWatcherDebounce()
+    diag.recordWatcherDebounce()
+    diag.recordWatcherRerun()
+
+    const snap = diag.snapshot()
+    expect(snap.counters.watcherDebounces).toBe(2)
+    expect(snap.counters.watcherReruns).toBe(1)
+  })
+
+  it('tracks poll requests', () => {
+    diag.recordPollRequest('normal')
+    diag.recordPollRequest('normal')
+    diag.recordPollRequest('immediate')
+
+    const snap = diag.snapshot()
+    expect(snap.counters.pollRequests).toBe(3)
+    expect(snap.counters.pollImmediateRequests).toBe(1)
+  })
+
+  it('tracks poll decisions', () => {
+    diag.recordPollDecision('executed')
+    diag.recordPollDecision('skipped')
+    diag.recordPollDecision('skipped')
+    diag.recordPollDecision('deferred')
+
+    const snap = diag.snapshot()
+    expect(snap.counters.pollExecuted).toBe(1)
+    expect(snap.counters.pollSkipped).toBe(2)
+    expect(snap.counters.pollDeferred).toBe(1)
+  })
+
+  it('tracks poll execution timing', () => {
+    diag.recordPollStart()
+    diag.recordPollFinish(100, false)
+    diag.recordPollStart()
+    diag.recordPollFinish(300, false)
+
+    const snap = diag.snapshot()
+    expect(snap.counters.pollStarted).toBe(2)
+    expect(snap.counters.pollFinished).toBe(2)
+    expect(snap.counters.pollLastMs).toBe(300)
+    expect(snap.counters.pollMaxMs).toBe(300)
+    expect(snap.counters.pollTotalMs).toBe(400)
+    expect(snap.pollAvgMs).toBe(200)
+    expect(snap.counters.pollErrors).toBe(0)
+  })
+
+  it('tracks poll errors', () => {
+    diag.recordPollStart()
+    diag.recordPollFinish(50, true)
+
+    const snap = diag.snapshot()
+    expect(snap.counters.pollErrors).toBe(1)
+    expect(snap.counters.pollFinished).toBe(1)
+  })
+
+  it('tracks mtime checks and hits', () => {
+    diag.recordMtimeCheck(false)
+    diag.recordMtimeCheck(false)
+    diag.recordMtimeCheck(true)
+
+    const snap = diag.snapshot()
+    expect(snap.counters.mtimeChecks).toBe(3)
+    expect(snap.counters.mtimeHits).toBe(1)
+  })
+
+  it('reset clears all counters', () => {
+    diag.recordWatcherTrigger(true)
+    diag.recordPollStart()
+    diag.recordPollFinish(200, false)
+    diag.recordMtimeCheck(true)
+
+    diag.reset()
+    const snap = diag.snapshot()
+    expect(snap.counters.watcherTriggers).toBe(0)
+    expect(snap.counters.pollStarted).toBe(0)
+    expect(snap.counters.mtimeChecks).toBe(0)
+    expect(snap.uptimeSeconds).toBe(0)
+  })
+
+  it('snapshot returns uptime', () => {
+    const snap = diag.snapshot()
+    expect(snap.uptimeSeconds).toBeGreaterThanOrEqual(0)
+  })
+
+  it('is a singleton — multiple calls share state', () => {
+    const diag2 = usePipelineDiagnostics()
+    diag.recordWatcherTrigger(true)
+
+    const snap = diag2.snapshot()
+    expect(snap.counters.watcherTriggers).toBe(1)
+  })
+})
diff --git a/tests/composables/usePollScheduler.test.ts b/tests/composables/usePollScheduler.test.ts
new file mode 100644
index 00000000..c686cd80
--- /dev/null
+++ b/tests/composables/usePollScheduler.test.ts
@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { usePollScheduler } from '~/composables/usePollScheduler'
+
+describe('usePollScheduler', () => {
+  beforeEach(() => { vi.useFakeTimers() })
+  afterEach(() => { vi.useRealTimers() })
+
+  function setup(opts: { minInterval?: number; pollMs?: number } = {}) {
+    let resolvers: Array<() => void> = []
+    const pollFn = vi.fn(() => {
+      if (opts.pollMs) {
+        return new Promise<void>((resolve) => { resolvers.push(resolve) })
+      }
+      return Promise.resolve()
+    })
+
+    const scheduler = usePollScheduler(pollFn, {
+      minInterval: opts.minInterval ?? 100,
+    })
+
+    const resolveOnePoll = () => {
+      const r = resolvers.shift()
+      r?.()
+    }
+
+    return { pollFn, scheduler, resolveOnePoll }
+  }
+
+  it('executes first poll immediately', async () => {
+    const { pollFn, scheduler } = setup()
+    scheduler.requestPoll()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(pollFn).toHaveBeenCalledTimes(1)
+    expect(scheduler.stats.executed).toBe(1)
+  })
+
+  it('enforces min interval between polls', async () => {
+    const { pollFn, scheduler } = setup({ minInterval: 100 })
+
+    scheduler.requestPoll()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(pollFn).toHaveBeenCalledTimes(1)
+
+    // Request again immediately — should defer
+    scheduler.requestPoll()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(pollFn).toHaveBeenCalledTimes(1)
+    expect(scheduler.stats.deferred).toBe(1)
+
+    // Advance past min interval — deferred poll should fire
+    await vi.advanceTimersByTimeAsync(100)
+    expect(pollFn).toHaveBeenCalledTimes(2)
+    expect(scheduler.stats.executed).toBe(2)
+  })
+
+  it('skips when a poll is already inflight', async () => {
+    const { pollFn, scheduler, resolveOnePoll } = setup({ pollMs: 50 })
+
+    scheduler.requestPoll()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(pollFn).toHaveBeenCalledTimes(1)
+
+    // Request while inflight — should skip
+    scheduler.requestPoll()
+    expect(scheduler.stats.skipped).toBe(1)
+
+    // Finish inflight poll
+    resolveOnePoll()
+    await vi.advanceTimersByTimeAsync(0)
+  })
+
+  it('deduplicates rapid triggers into one deferred poll', async () => {
+    const { pollFn, scheduler } = setup({ minInterval: 100 })
+
+    scheduler.requestPoll()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(pollFn).toHaveBeenCalledTimes(1)
+
+    // Three rapid triggers — first defers, rest skip
+    scheduler.requestPoll()
+    scheduler.requestPoll()
+    scheduler.requestPoll()
+    expect(scheduler.stats.deferred).toBe(1)
+    expect(scheduler.stats.skipped).toBe(2)
+
+    await vi.advanceTimersByTimeAsync(100)
+    expect(pollFn).toHaveBeenCalledTimes(2)
+  })
+
+  it('requestImmediatePoll bypasses min interval', async () => {
+    const { pollFn, scheduler } = setup({ minInterval: 100 })
+
+    scheduler.requestPoll()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(pollFn).toHaveBeenCalledTimes(1)
+
+    // Immediate poll right after — should bypass
+    scheduler.requestImmediatePoll()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(pollFn).toHaveBeenCalledTimes(2)
+  })
+
+  it('cancel clears pending deferred poll', async () => {
+    const { pollFn, scheduler } = setup({ minInterval: 100 })
+
+    scheduler.requestPoll()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(pollFn).toHaveBeenCalledTimes(1)
+
+    scheduler.requestPoll() // deferred
+    scheduler.cancel()
+
+    await vi.advanceTimersByTimeAsync(200)
+    expect(pollFn).toHaveBeenCalledTimes(1) // no deferred poll ran
+  })
+})
diff --git a/tests/utils/dashboard-stats.test.ts b/tests/utils/dashboard-stats.test.ts
index d9006de5..cba4dc59 100644
--- a/tests/utils/dashboard-stats.test.ts
+++ b/tests/utils/dashboard-stats.test.ts
@@ -27,21 +27,22 @@ describe('computeStatsFromIssues', () => {
     expect(stats.inProgress).toBe(0)
     expect(stats.blocked).toBe(0)
     expect(stats.closed).toBe(0)
+    expect(stats.workflow).toBe(0)
     expect(stats.byType.bug).toBe(0)
     expect(stats.byPriority.p0).toBe(0)
   })
 
-  it('counts total excluding tombstone', () => {
+  it('counts total across all issues', () => {
     const issues = [
       makeIssue({ id: '1', status: 'open' }),
       makeIssue({ id: '2', status: 'closed' }),
-      makeIssue({ id: '3', status: 'tombstone' as any }),
+      makeIssue({ id: '3', status: 'deferred' }),
     ]
     const stats = computeStatsFromIssues(issues)
-    expect(stats.total).toBe(2)
+    expect(stats.total).toBe(3)
   })
 
-  it('groups open, deferred, pinned, hooked as "open"', () => {
+  it('counts only true open issues as "open"', () => {
     const issues = [
       makeIssue({ id: '1', status: 'open' }),
       makeIssue({ id: '2', status: 'deferred' }),
@@ -49,7 +50,7 @@ describe('computeStatsFromIssues', () => {
       makeIssue({ id: '4', status: 'hooked' }),
     ]
     const stats = computeStatsFromIssues(issues)
-    expect(stats.open).toBe(4)
+    expect(stats.open).toBe(1)
     expect(stats.inProgress).toBe(0)
   })
 
@@ -68,6 +69,32 @@ describe('computeStatsFromIssues', () => {
     expect(stats.blocked).toBe(1)
   })
 
+  it('counts open issues with blockers as blocked', () => {
+    const issues = [
+      makeIssue({ id: '1', status: 'open', blockedBy: ['2'] }),
+      makeIssue({ id: '2', status: 'open' }),
+    ]
+    const stats = computeStatsFromIssues(issues)
+    expect(stats.blocked).toBe(1)
+    expect(stats.open).toBe(1)
+    expect(stats.workflow).toBe(1)
+  })
+
+  it('counts workflow as non-blocked, non-closed, non-deleted issues', () => {
+    const issues = [
+      makeIssue({ id: '1', status: 'open' }),
+      makeIssue({ id: '2', status: 'in_progress' }),
+      makeIssue({ id: '3', status: 'deferred' }),
+      makeIssue({ id: '4', status: 'blocked' }),
+      makeIssue({ id: '5', status: 'closed' }),
+      makeIssue({ id: '6', status: 'deleted' as any }),
+      makeIssue({ id: '7', status: 'tombstone' as any }),
+      makeIssue({ id: '8', status: 'open', blockedBy: ['1'] }),
+    ]
+    const stats = computeStatsFromIssues(issues)
+    expect(stats.workflow).toBe(3)
+  })
+
   it('counts closed separately', () => {
     const issues = [makeIssue({ status: 'closed' })]
     const stats = computeStatsFromIssues(issues)
@@ -102,14 +129,14 @@ describe('computeStatsFromIssues', () => {
     expect(stats.byPriority.p4).toBe(1)
   })
 
-  it('excludes tombstone from type and priority counts', () => {
+  it('includes closed issues in type and priority counts', () => {
     const issues = [
-      makeIssue({ id: '1', status: 'tombstone' as any, type: 'bug', priority: 'p0' }),
+      makeIssue({ id: '1', status: 'closed', type: 'bug', priority: 'p0' }),
       makeIssue({ id: '2', status: 'open', type: 'bug', priority: 'p0' }),
     ]
     const stats = computeStatsFromIssues(issues)
-    expect(stats.byType.bug).toBe(1)
-    expect(stats.byPriority.p0).toBe(1)
+    expect(stats.byType.bug).toBe(2)
+    expect(stats.byPriority.p0).toBe(2)
   })
 
   it('handles mixed realistic data', () => {
@@ -119,14 +146,14 @@ describe('computeStatsFromIssues', () => {
       makeIssue({ id: '3', status: 'blocked', type: 'feature', priority: 'p1' }),
       makeIssue({ id: '4', status: 'closed', type: 'task', priority: 'p3' }),
       makeIssue({ id: '5', status: 'deferred', type: 'chore', priority: 'p4' }),
-      makeIssue({ id: '6', status: 'tombstone' as any, type: 'bug', priority: 'p0' }),
     ]
     const stats = computeStatsFromIssues(issues)
     expect(stats.total).toBe(5)
-    expect(stats.open).toBe(2) // open + deferred
+    expect(stats.open).toBe(1)
     expect(stats.inProgress).toBe(1)
     expect(stats.blocked).toBe(1)
     expect(stats.closed).toBe(1)
+    expect(stats.workflow).toBe(3)
   })
 
   it('initializes ready to 0', () => {
diff --git a/tests/utils/issue-helpers.test.ts b/tests/utils/issue-helpers.test.ts
index 7cc50e00..86be3dd4 100644
--- a/tests/utils/issue-helpers.test.ts
+++ b/tests/utils/issue-helpers.test.ts
@@ -8,6 +8,7 @@ import {
   sortIssues,
   filterIssues,
   groupIssues,
+  pruneClosedBlockers,
   computeReadyIssues,
   statusOrder,
   priorityOrder,
@@ -275,19 +276,67 @@ describe('filterIssues', () => {
     makeIssue({ id: '1', title: 'Login bug', status: 'open', type: 'bug', priority: 'p0', labels: ['frontend'], assignee: 'alice' }),
     makeIssue({ id: '2', title: 'Add tests', status: 'in_progress', type: 'task', priority: 'p2', labels: ['backend'], assignee: 'bob' }),
     makeIssue({ id: '3', title: 'Old feature', status: 'closed', type: 'feature', priority: 'p3' }),
-    makeIssue({ id: '4', title: 'Tombstone', status: 'tombstone' as any, type: 'task', priority: 'p2' }),
   ]
 
-  it('excludes closed and tombstone by default (no status filter)', () => {
+  it('uses workflow view by default (no status filter)', () => {
     const result = filterIssues(issues, noFilters, noExclusions)
     expect(result.map(i => i.id)).toEqual(['1', '2'])
   })
 
+  it('default workflow view excludes blocked statuses and dependency-blocked issues', () => {
+    const dependencyBlocked = makeIssue({ id: '5', status: 'open', blockedBy: ['1'] })
+    const explicitlyBlocked = makeIssue({ id: '6', status: 'blocked' })
+    const result = filterIssues([...issues, dependencyBlocked, explicitlyBlocked], noFilters, noExclusions)
+    expect(result.map(i => i.id)).toEqual(['1', '2'])
+  })
+
   it('shows only selected statuses when status filter active', () => {
     const result = filterIssues(issues, { ...noFilters, status: ['closed'] }, noExclusions)
     expect(result.map(i => i.id)).toEqual(['3'])
   })
 
+  it('returns every supported status when all status filters are selected (TOTAL view)', () => {
+    const fullStatusSet = [
+      ...issues,
+      makeIssue({ id: '4', status: 'blocked' }),
+      makeIssue({ id: '5', status: 'deferred' }),
+      makeIssue({ id: '6', status: 'pinned' }),
+      makeIssue({ id: '7', status: 'hooked' }),
+    ]
+
+    const result = filterIssues(
+      fullStatusSet,
+      {
+        ...noFilters,
+        status: ['open', 'in_progress', 'blocked', 'closed', 'deferred', 'pinned', 'hooked'],
+      },
+      noExclusions,
+    )
+
+    expect(result.map(i => i.id)).toEqual(['1', '2', '3', '4', '5', '6', '7'])
+  })
+
+  it('includes dependency-blocked issues in blocked status filter', () => {
+    const dependencyBlocked = makeIssue({ id: '5', status: 'open', blockedBy: ['1'] })
+    const explicitlyBlocked = makeIssue({ id: '6', status: 'blocked' })
+    const result = filterIssues(
+      [...issues, dependencyBlocked, explicitlyBlocked],
+      { ...noFilters, status: ['blocked'] },
+      noExclusions,
+    )
+    expect(result.map(i => i.id)).toEqual(['5', '6'])
+  })
+
+  it('excludes dependency-blocked issues from open status filter', () => {
+    const dependencyBlocked = makeIssue({ id: '5', status: 'open', blockedBy: ['1'] })
+    const result = filterIssues(
+      [...issues, dependencyBlocked],
+      { ...noFilters, status: ['open'] },
+      noExclusions,
+    )
+    expect(result.map(i => i.id)).toEqual(['1'])
+  })
+
   it('filters by type', () => {
     const result = filterIssues(issues, { ...noFilters, type: ['bug'] }, noExclusions)
     expect(result.map(i => i.id)).toEqual(['1'])
@@ -313,11 +362,21 @@ describe('filterIssues', () => {
     expect(result.map(i => i.id)).toEqual(['1'])
   })
 
-  it('search bypasses all other filters (includes closed)', () => {
+  it('search respects active filters (excludes closed by default)', () => {
     const result = filterIssues(issues, { ...noFilters, search: 'old feature' }, noExclusions)
+    expect(result).toEqual([])
+  })
+
+  it('search combined with status filter returns matching results', () => {
+    const result = filterIssues(issues, { ...noFilters, status: ['closed'], search: 'old feature' }, noExclusions)
     expect(result.map(i => i.id)).toEqual(['3'])
   })
 
+  it('search combined with type filter narrows results', () => {
+    const result = filterIssues(issues, { ...noFilters, search: 'Login', type: ['task'] }, noExclusions)
+    expect(result).toEqual([])
+  })
+
   it('search matches title, id, and description', () => {
     const withDesc = [makeIssue({ id: 'x', title: 'Nothing', description: 'hidden keyword' })]
     const result = filterIssues(withDesc, { ...noFilters, search: 'keyword' }, noExclusions)
@@ -329,6 +388,16 @@ describe('filterIssues', () => {
     expect(result.map(i => i.id)).toEqual(['2'])
   })
 
+  it('status exclusion for blocked removes dependency-blocked issues', () => {
+    const dependencyBlocked = makeIssue({ id: '5', status: 'open', blockedBy: ['1'] })
+    const result = filterIssues(
+      [...issues, dependencyBlocked],
+      noFilters,
+      { ...noExclusions, status: ['blocked'] },
+    )
+    expect(result.map(i => i.id)).toEqual(['1', '2'])
+  })
+
   it('excludes by label', () => {
     const result = filterIssues(issues, noFilters, { ...noExclusions, labels: ['frontend'] })
     expect(result.map(i => i.id)).toEqual(['2'])
@@ -339,7 +408,7 @@ describe('filterIssues', () => {
     expect(result.map(i => i.id)).toEqual(['2'])
   })
 
-  it('returns all non-closed when no filters and no exclusions', () => {
+  it('returns all workflow issues when no filters and no exclusions', () => {
     const result = filterIssues(issues, noFilters, noExclusions)
     expect(result).toHaveLength(2)
   })
@@ -413,6 +482,48 @@ describe('groupIssues', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// pruneClosedBlockers
+// ---------------------------------------------------------------------------
+describe('pruneClosedBlockers', () => {
+  it('removes closed blockers from blockedBy and blocks', () => {
+    const issues = [
+      makeIssue({ id: 'open-1', status: 'open', blockedBy: ['closed-1', 'open-2'] }),
+      makeIssue({ id: 'open-2', status: 'open', blocks: ['open-1', 'closed-1'] }),
+      makeIssue({ id: 'closed-1', status: 'closed' }),
+    ]
+
+    pruneClosedBlockers(issues)
+
+    expect(issues[0]!.blockedBy).toEqual(['open-2'])
+    expect(issues[1]!.blocks).toEqual(['open-1'])
+  })
+
+  it('clears dependency arrays when all references are closed', () => {
+    const issues = [
+      makeIssue({ id: 'open-1', status: 'open', blockedBy: ['closed-1'] }),
+      makeIssue({ id: 'open-2', status: 'open', blocks: ['closed-1'] }),
+      makeIssue({ id: 'closed-1', status: 'closed' }),
+    ]
+
+    pruneClosedBlockers(issues)
+
+    expect(issues[0]!.blockedBy).toBeUndefined()
+    expect(issues[1]!.blocks).toBeUndefined()
+  })
+
+  it('keeps unknown blocker IDs untouched', () => {
+    const issues = [
+      makeIssue({ id: 'open-1', status: 'open', blockedBy: ['missing-1'] }),
+      makeIssue({ id: 'open-2', status: 'open' }),
+    ]
+
+    pruneClosedBlockers(issues)
+
+    expect(issues[0]!.blockedBy).toEqual(['missing-1'])
+  })
+})
+
 // ---------------------------------------------------------------------------
 // computeReadyIssues
 // ---------------------------------------------------------------------------