Sort dashboard by dependency depth, show depth next to blocked indicator

Add BlockDepth and CreatedAt fields to BeadSummary. Compute dependency
depth by walking the blocker DAG (with memoization), including blockers
inherited from parent epics. Dashboard Open and Not Ready sections now
sort by depth ascending then oldest-created first, surfacing items
closest to becoming actionable. Blocked items display their depth next
to the lock icon (e.g. 🔒1, 🔒2).

Author: vector76

e2e/e2e_test.go

@@ -1234,11 +1234,11 @@ func TestDashboardBlockedIndicator_OpenLifecycle(t *testing.T) {
 	// 2. Link: blocked is blocked by blocker
 	run(t, "link", blocked.ID, "--blocked-by", blocker.ID)
 
-	// 3. Dashboard should show the lock emoji for the blocked bead in Open section
+	// 3. Dashboard should show the lock emoji with depth for the blocked bead in Open section
 	body := fetchDashboard(t, ts.URL)
-	lockedRow := `🔒</td><td><a href="/bead/default/` + blocked.ID + `">`
+	lockedRow := `🔒1</td><td><a href="/bead/default/` + blocked.ID + `">`
 	if !strings.Contains(body, lockedRow) {
-		t.Errorf("expected lock emoji in Open section for blocked bead %s; body:\n%s", blocked.ID, body)
+		t.Errorf("expected lock emoji with depth in Open section for blocked bead %s; body:\n%s", blocked.ID, body)
 	}
 
 	// 4. Close the blocker
@@ -1265,11 +1265,11 @@ func TestDashboardBlockedIndicator_NotReadyLifecycle(t *testing.T) {
 
 	run(t, "link", blocked.ID, "--blocked-by", blocker.ID)
 
-	// 2. Dashboard should show lock in Not Ready section
+	// 2. Dashboard should show lock with depth in Not Ready section
 	body := fetchDashboard(t, ts.URL)
-	lockedRow := `🔒</td><td><a href="/bead/default/` + blocked.ID + `">`
+	lockedRow := `🔒1</td><td><a href="/bead/default/` + blocked.ID + `">`
 	if !strings.Contains(body, lockedRow) {
-		t.Errorf("expected lock emoji in Not Ready section for blocked bead %s; body:\n%s", blocked.ID, body)
+		t.Errorf("expected lock emoji with depth in Not Ready section for blocked bead %s; body:\n%s", blocked.ID, body)
 	}
 
 	// 3. Close the blocker — lock should disappear

internal/server/dashboard.go

@@ -47,9 +47,9 @@ func (s *Server) handleDashboard(w http.ResponseWriter, r *http.Request) {
 			}
 		}
 		sortByUpdatedDesc(dp.InProgress)
-		sortByUpdatedDesc(dp.Open)
+		sortByDepthThenOldest(dp.Open)
 		sortByUpdatedDesc(dp.Closed)
-		sortByUpdatedDesc(dp.NotReady)
+		sortByDepthThenOldest(dp.NotReady)
 		data.Projects = append(data.Projects, dp)
 	}
 
@@ -120,6 +120,17 @@ func sortByUpdatedDesc(beads []store.BeadSummary) {
 	})
 }
 
+// sortByDepthThenOldest sorts beads by BlockDepth ascending (unblocked first),
+// then by CreatedAt ascending (oldest first) within equal depth.
+func sortByDepthThenOldest(beads []store.BeadSummary) {
+	sort.Slice(beads, func(i, j int) bool {
+		if beads[i].BlockDepth != beads[j].BlockDepth {
+			return beads[i].BlockDepth < beads[j].BlockDepth
+		}
+		return beads[i].CreatedAt.Before(beads[j].CreatedAt)
+	})
+}
+
 var dashboardTmpl = template.Must(template.New("dashboard").Funcs(template.FuncMap{
 	"fmtTime": func(t time.Time) template.HTML {
 		utc := t.UTC().Format(time.RFC3339)
@@ -200,7 +211,7 @@ var dashboardTmpl = template.Must(template.New("dashboard").Funcs(template.FuncM
 <h3>Not Ready</h3>
 <div class="table-wrap"><table>
 <tr><th style="width:1.5em"></th><th>ID</th><th>Title</th><th>Priority</th><th>Type</th><th>Updated</th></tr>
-{{range .NotReady}}<tr><td>{{if .Blocked}}🔒{{end}}</td><td><a href="/bead/{{$proj}}/{{.ID}}">{{.ID}}</a></td><td>{{.Title}}</td><td>{{.Priority}}</td><td>{{.Type}}</td><td>{{fmtTime .UpdatedAt}}</td></tr>
+{{range .NotReady}}<tr><td>{{if .Blocked}}🔒{{.BlockDepth}}{{end}}</td><td><a href="/bead/{{$proj}}/{{.ID}}">{{.ID}}</a></td><td>{{.Title}}</td><td>{{.Priority}}</td><td>{{.Type}}</td><td>{{fmtTime .UpdatedAt}}</td></tr>
 {{end}}</table></div>
 {{end}}
 
@@ -216,7 +227,7 @@ var dashboardTmpl = template.Must(template.New("dashboard").Funcs(template.FuncM
 <h3>Open</h3>
 <div class="table-wrap"><table>
 <tr><th style="width:1.5em"></th><th>ID</th><th>Title</th><th>Priority</th><th>Type</th><th>Updated</th></tr>
-{{range .Open}}<tr><td>{{if .Blocked}}🔒{{end}}</td><td><a href="/bead/{{$proj}}/{{.ID}}">{{.ID}}</a></td><td>{{.Title}}</td><td>{{.Priority}}</td><td>{{.Type}}</td><td>{{fmtTime .UpdatedAt}}</td></tr>
+{{range .Open}}<tr><td>{{if .Blocked}}🔒{{.BlockDepth}}{{end}}</td><td><a href="/bead/{{$proj}}/{{.ID}}">{{.ID}}</a></td><td>{{.Title}}</td><td>{{.Priority}}</td><td>{{.Type}}</td><td>{{fmtTime .UpdatedAt}}</td></tr>
 {{end}}</table></div>
 {{end}}
 

internal/server/dashboard_test.go

@@ -36,11 +36,37 @@ func TestSortByUpdatedDesc_Empty(t *testing.T) {
 	sortByUpdatedDesc([]store.BeadSummary{{ID: "bd-only"}})
 }
 
+func TestSortByDepthThenOldest(t *testing.T) {
+	now := time.Now().UTC()
+	beads := []store.BeadSummary{
+		{ID: "bd-d1-new", BlockDepth: 1, CreatedAt: now},
+		{ID: "bd-d0-old", BlockDepth: 0, CreatedAt: now.Add(-3 * time.Hour)},
+		{ID: "bd-d0-new", BlockDepth: 0, CreatedAt: now},
+		{ID: "bd-d2", BlockDepth: 2, CreatedAt: now},
+		{ID: "bd-d1-old", BlockDepth: 1, CreatedAt: now.Add(-1 * time.Hour)},
+	}
+
+	sortByDepthThenOldest(beads)
+
+	expected := []string{"bd-d0-old", "bd-d0-new", "bd-d1-old", "bd-d1-new", "bd-d2"}
+	for i, want := range expected {
+		if beads[i].ID != want {
+			t.Errorf("position %d: got %s, want %s", i, beads[i].ID, want)
+		}
+	}
+}
+
+func TestSortByDepthThenOldest_Empty(t *testing.T) {
+	// Should not panic on empty or single-element slices.
+	sortByDepthThenOldest(nil)
+	sortByDepthThenOldest([]store.BeadSummary{})
+	sortByDepthThenOldest([]store.BeadSummary{{ID: "bd-only"}})
+}
+
 func TestDashboardSortOrder(t *testing.T) {
 	srv := crudServer(t)
 
-	// Create beads with different statuses.
-	// Create them in order so UpdatedAt differs.
+	// Create two open beads with different creation times.
 	b1 := createViaAPI(t, srv, map[string]any{"title": "Open old", "status": "open"})
 	time.Sleep(10 * time.Millisecond)
 	b2 := createViaAPI(t, srv, map[string]any{"title": "Open new", "status": "open"})
@@ -55,15 +81,16 @@ func TestDashboardSortOrder(t *testing.T) {
 
 	body := w.Body.String()
 
-	// "Open new" should appear before "Open old" in the HTML
+	// Open section sorts by depth (asc) then oldest-first.
+	// Both beads are unblocked (depth 0), so "Open old" should appear before "Open new".
 	posNew := strings.Index(body, b2.Title)
 	posOld := strings.Index(body, b1.Title)
 
 	if posNew == -1 || posOld == -1 {
 		t.Fatalf("expected both beads in HTML; got body:\n%s", body)
 	}
-	if posNew >= posOld {
-		t.Errorf("expected %q (newer) before %q (older) in dashboard", b2.Title, b1.Title)
+	if posOld >= posNew {
+		t.Errorf("expected %q (older) before %q (newer) in dashboard Open section", b1.Title, b2.Title)
 	}
 }
 
@@ -423,8 +450,9 @@ func TestDashboardSortOrderNotReady(t *testing.T) {
 	if posNew == -1 || posOld == -1 {
 		t.Fatalf("expected both not_ready beads in HTML")
 	}
-	if posNew >= posOld {
-		t.Errorf("expected %q (newer) before %q (older) in Not Ready section", b2.Title, b1.Title)
+	// Not Ready section sorts by depth (asc) then oldest-first.
+	if posOld >= posNew {
+		t.Errorf("expected %q (older) before %q (newer) in Not Ready section", b1.Title, b2.Title)
 	}
 }
 
@@ -460,11 +488,10 @@ func TestDashboardBlockedIndicator_OpenSectionBlocked(t *testing.T) {
 
 	body := getDashboard(t, srv)
 
-	// The lock emoji must appear in the Open section row for the blocked bead.
-	// We verify by checking that the row containing the blocked bead ID also contains the lock emoji.
-	blockedRow := `<td>🔒</td><td><a href="/bead/default/` + blocked.ID + `">`
+	// The lock emoji with depth must appear in the Open section row for the blocked bead.
+	blockedRow := `<td>🔒1</td><td><a href="/bead/default/` + blocked.ID + `">`
 	if !strings.Contains(body, blockedRow) {
-		t.Errorf("expected lock emoji in Open section row for blocked bead, body:\n%s", body)
+		t.Errorf("expected lock emoji with depth in Open section row for blocked bead, body:\n%s", body)
 	}
 }
 
@@ -489,9 +516,9 @@ func TestDashboardBlockedIndicator_NotReadySectionBlocked(t *testing.T) {
 
 	body := getDashboard(t, srv)
 
-	blockedRow := `<td>🔒</td><td><a href="/bead/default/` + blocked.ID + `">`
+	blockedRow := `<td>🔒1</td><td><a href="/bead/default/` + blocked.ID + `">`
 	if !strings.Contains(body, blockedRow) {
-		t.Errorf("expected lock emoji in Not Ready section row for blocked bead, body:\n%s", body)
+		t.Errorf("expected lock emoji with depth in Not Ready section row for blocked bead, body:\n%s", body)
 	}
 }
 
@@ -939,6 +966,58 @@ func TestBeadDetailNoCookieIntegration(t *testing.T) {
 	}
 }
 
+func TestDashboardDepthShownNextToLock(t *testing.T) {
+	srv := crudServer(t)
+
+	// Create a chain: C blocks B blocks A → A has depth 2, B has depth 1
+	c := createViaAPI(t, srv, map[string]any{"title": "Chain C", "status": "open"})
+	b := createViaAPI(t, srv, map[string]any{"title": "Chain B", "status": "open"})
+	a := createViaAPI(t, srv, map[string]any{"title": "Chain A", "status": "open"})
+	linkBeads(t, srv, b.ID, c.ID)
+	linkBeads(t, srv, a.ID, b.ID)
+
+	body := getDashboard(t, srv)
+
+	depth1Row := `<td>🔒1</td><td><a href="/bead/default/` + b.ID + `">`
+	if !strings.Contains(body, depth1Row) {
+		t.Errorf("expected 🔒1 for depth-1 bead %s", b.ID)
+	}
+
+	depth2Row := `<td>🔒2</td><td><a href="/bead/default/` + a.ID + `">`
+	if !strings.Contains(body, depth2Row) {
+		t.Errorf("expected 🔒2 for depth-2 bead %s", a.ID)
+	}
+}
+
+func TestDashboardSortByDepthThenOldest(t *testing.T) {
+	srv := crudServer(t)
+
+	// Create: blocker (unblocked, depth 0), blocked (depth 1), another unblocked (depth 0, newer)
+	blocker := createViaAPI(t, srv, map[string]any{"title": "Depth0 oldest", "status": "open"})
+	time.Sleep(10 * time.Millisecond)
+	blocked := createViaAPI(t, srv, map[string]any{"title": "Depth1 item", "status": "open"})
+	linkBeads(t, srv, blocked.ID, blocker.ID)
+	time.Sleep(10 * time.Millisecond)
+	unblocked2 := createViaAPI(t, srv, map[string]any{"title": "Depth0 newest", "status": "open"})
+
+	body := getDashboard(t, srv)
+
+	// Expected order in Open section: Depth0 oldest, Depth0 newest, Depth1 item
+	pos0old := strings.Index(body, blocker.Title)
+	pos0new := strings.Index(body, unblocked2.Title)
+	pos1 := strings.Index(body, blocked.Title)
+
+	if pos0old == -1 || pos0new == -1 || pos1 == -1 {
+		t.Fatalf("expected all three beads in HTML")
+	}
+	if pos0old >= pos0new {
+		t.Errorf("expected %q (depth 0, older) before %q (depth 0, newer)", blocker.Title, unblocked2.Title)
+	}
+	if pos0new >= pos1 {
+		t.Errorf("expected %q (depth 0) before %q (depth 1)", unblocked2.Title, blocked.Title)
+	}
+}
+
 func TestDashboardToggleButtonIconDark(t *testing.T) {
 	srv := crudServer(t)
 	req := httptest.NewRequest(http.MethodGet, "/", nil)

internal/store/list.go

@@ -21,6 +21,8 @@ type BeadSummary struct {
 	ParentID    string         `json:"parent_id,omitempty"`
 	ParentTitle string         `json:"parent_title,omitempty"`
 	Blocked     bool           `json:"blocked,omitempty"`
+	BlockDepth  int            `json:"block_depth,omitempty"`
+	CreatedAt   time.Time      `json:"created_at"`
 }
 
 // ListFilters specifies filtering criteria for listing beads.
@@ -45,21 +47,67 @@ type ListResult struct {
 	TotalPages int           `json:"total_pages"`
 }
 
-// summaryFromBead builds a BeadSummary for b, including blocked status.
+// summaryFromBead builds a BeadSummary for b, including blocked status and depth.
 // Caller must hold s.mu (at least RLock).
-func (s *Store) summaryFromBead(b model.Bead) BeadSummary {
+func (s *Store) summaryFromBead(b model.Bead, memo map[string]int) BeadSummary {
+	depth := s.computeBlockDepth(b, memo)
 	return BeadSummary{
-		ID:        b.ID,
-		Title:     b.Title,
-		Status:    b.Status,
-		Priority:  b.Priority,
-		Type:      b.Type,
-		Assignee:  b.Assignee,
-		UpdatedAt: b.UpdatedAt,
-		Blocked:   s.hasActiveBlocker(b),
+		ID:         b.ID,
+		Title:      b.Title,
+		Status:     b.Status,
+		Priority:   b.Priority,
+		Type:       b.Type,
+		Assignee:   b.Assignee,
+		UpdatedAt:  b.UpdatedAt,
+		CreatedAt:  b.CreatedAt,
+		Blocked:    depth > 0,
+		BlockDepth: depth,
 	}
 }
 
+// computeBlockDepth returns the dependency depth of a bead.
+// Depth 0 means unblocked. Depth N means blocked, where N is 1 + the max
+// depth of any active blocker (direct or inherited from parent epic).
+// Caller must hold s.mu (at least RLock).
+func (s *Store) computeBlockDepth(b model.Bead, memo map[string]int) int {
+	if v, ok := memo[b.ID]; ok {
+		return v
+	}
+	// Mark as visited with 0 to guard against unexpected cycles.
+	memo[b.ID] = 0
+
+	depth := 0
+	// Check own blockers.
+	for _, bid := range b.BlockedBy {
+		blocker, ok := s.beads[bid]
+		if !ok || !isActiveBlocker(blocker.Status) {
+			continue
+		}
+		d := s.computeBlockDepth(blocker, memo) + 1
+		if d > depth {
+			depth = d
+		}
+	}
+	// Check parent epic's blockers (inherited blocking).
+	if b.ParentID != "" {
+		if parent, ok := s.beads[b.ParentID]; ok {
+			for _, bid := range parent.BlockedBy {
+				blocker, ok := s.beads[bid]
+				if !ok || !isActiveBlocker(blocker.Status) {
+					continue
+				}
+				d := s.computeBlockDepth(blocker, memo) + 1
+				if d > depth {
+					depth = d
+				}
+			}
+		}
+	}
+
+	memo[b.ID] = depth
+	return depth
+}
+
 // isActiveBlocker returns true if the status counts as an active blocker.
 func isActiveBlocker(s model.Status) bool {
 	return s == model.StatusOpen || s == model.StatusInProgress || s == model.StatusNotReady
@@ -121,9 +169,10 @@ func (s *Store) listFlat(filters ListFilters, statusSet map[model.Status]bool) L
 
 	total := len(matched)
 	page := paginate(matched, filters.Page, filters.PerPage)
+	memo := make(map[string]int)
 	summaries := make([]BeadSummary, len(page))
 	for i, b := range page {
-		sum := s.summaryFromBead(b)
+		sum := s.summaryFromBead(b, memo)
 		if b.ParentID != "" {
 			sum.ParentID = b.ParentID
 			if parent, ok := s.beads[b.ParentID]; ok {
@@ -168,9 +217,10 @@ func (s *Store) listHierarchical(filters ListFilters, statusSet map[model.Status
 
 	total := len(topLevel)
 	page := paginate(topLevel, filters.Page, filters.PerPage)
+	memo := make(map[string]int)
 	summaries := make([]BeadSummary, len(page))
 	for i, b := range page {
-		sum := s.summaryFromBead(b)
+		sum := s.summaryFromBead(b, memo)
 		children := s.childrenOf(b.ID)
 		if len(children) > 0 {
 			sum.IsEpic = true
@@ -181,7 +231,7 @@ func (s *Store) listHierarchical(filters ListFilters, statusSet map[model.Status
 				if c.Status == model.StatusDeleted {
 					continue
 				}
-				childSummaries = append(childSummaries, s.summaryFromBead(c))
+				childSummaries = append(childSummaries, s.summaryFromBead(c, memo))
 			}
 			if childSummaries == nil {
 				childSummaries = []BeadSummary{}