feat: auto-unblock dependents when blocker is approved/closed

When a blocking issue is closed (via approve or close), td now
automatically transitions dependent issues from blocked → open if all
their dependencies are resolved. Includes fix for GetBlockedBy missing
relation_type filter and conservative handling of missing deps.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: marcus

cmd/review.go

@@ -425,6 +425,13 @@ Supports bulk operations:
 				}
 			}
 
+			// Auto-unblock dependents whose dependencies are now all closed
+			if count, ids := database.CascadeUnblockDependents(issueID, sess.ID); count > 0 {
+				for _, id := range ids {
+					fmt.Printf("  ↓ Dependent %s auto-unblocked\n", id)
+				}
+			}
+
 			approved++
 		}
 
@@ -751,6 +758,13 @@ Examples:
 				}
 			}
 
+			// Auto-unblock dependents whose dependencies are now all closed
+			if count, ids := database.CascadeUnblockDependents(issueID, sess.ID); count > 0 {
+				for _, id := range ids {
+					fmt.Printf("  ↓ Dependent %s auto-unblocked\n", id)
+				}
+			}
+
 			closed++
 		}
 

cmd/review_test.go

@@ -1377,3 +1377,114 @@ func TestReviewWithWorkSessionTaggedIssue(t *testing.T) {
 		t.Error("Work session should NOT be ended by individual handoff")
 	}
 }
+
+// ============================================================================
+// Auto-Unblock Integration Tests
+// ============================================================================
+
+func TestApproveAutoUnblocksDependents(t *testing.T) {
+	dir := t.TempDir()
+	database, err := db.Initialize(dir)
+	if err != nil {
+		t.Fatalf("Initialize failed: %v", err)
+	}
+	defer database.Close()
+
+	// Create blocker (in_review, ready to be approved)
+	blocker := &models.Issue{
+		Title:              "Blocker",
+		Status:             models.StatusInReview,
+		ImplementerSession: "ses_impl",
+	}
+	database.CreateIssue(blocker)
+
+	// Create dependent (blocked, depends on blocker)
+	dependent := &models.Issue{
+		Title:  "Dependent",
+		Status: models.StatusBlocked,
+	}
+	database.CreateIssue(dependent)
+	database.AddDependency(dependent.ID, blocker.ID, "depends_on")
+
+	// Simulate approve: close the blocker then cascade unblock
+	blocker.Status = models.StatusClosed
+	database.UpdateIssue(blocker)
+	database.CascadeUnblockDependents(blocker.ID, "ses_reviewer")
+
+	// Verify dependent is now open
+	updated, _ := database.GetIssue(dependent.ID)
+	if updated.Status != models.StatusOpen {
+		t.Errorf("dependent should be open after blocker approved, got %s", updated.Status)
+	}
+}
+
+func TestCloseAutoUnblocksDependents(t *testing.T) {
+	dir := t.TempDir()
+	database, err := db.Initialize(dir)
+	if err != nil {
+		t.Fatalf("Initialize failed: %v", err)
+	}
+	defer database.Close()
+
+	blocker := &models.Issue{
+		Title:  "Blocker",
+		Status: models.StatusOpen,
+	}
+	database.CreateIssue(blocker)
+
+	dependent := &models.Issue{
+		Title:  "Dependent",
+		Status: models.StatusBlocked,
+	}
+	database.CreateIssue(dependent)
+	database.AddDependency(dependent.ID, blocker.ID, "depends_on")
+
+	// Simulate close: set closed then cascade unblock
+	blocker.Status = models.StatusClosed
+	database.UpdateIssue(blocker)
+	database.CascadeUnblockDependents(blocker.ID, "ses_closer")
+
+	updated, _ := database.GetIssue(dependent.ID)
+	if updated.Status != models.StatusOpen {
+		t.Errorf("dependent should be open after blocker closed, got %s", updated.Status)
+	}
+}
+
+func TestApproveAutoUnblockPartialDeps(t *testing.T) {
+	dir := t.TempDir()
+	database, err := db.Initialize(dir)
+	if err != nil {
+		t.Fatalf("Initialize failed: %v", err)
+	}
+	defer database.Close()
+
+	a1 := &models.Issue{
+		Title:              "A1",
+		Status:             models.StatusInReview,
+		ImplementerSession: "ses_impl",
+	}
+	a2 := &models.Issue{
+		Title:  "A2",
+		Status: models.StatusOpen,
+	}
+	dependent := &models.Issue{
+		Title:  "Dependent",
+		Status: models.StatusBlocked,
+	}
+	database.CreateIssue(a1)
+	database.CreateIssue(a2)
+	database.CreateIssue(dependent)
+	database.AddDependency(dependent.ID, a1.ID, "depends_on")
+	database.AddDependency(dependent.ID, a2.ID, "depends_on")
+
+	// Approve only A1
+	a1.Status = models.StatusClosed
+	database.UpdateIssue(a1)
+	database.CascadeUnblockDependents(a1.ID, "ses_reviewer")
+
+	// Dependent should still be blocked (A2 not closed)
+	updated, _ := database.GetIssue(dependent.ID)
+	if updated.Status != models.StatusBlocked {
+		t.Errorf("dependent should remain blocked (A2 still open), got %s", updated.Status)
+	}
+}

internal/db/issue_relations.go

@@ -232,6 +232,11 @@ func (db *DB) CascadeUpParentStatus(issueID string, targetStatus models.Status,
 	cascadedIDs = append(cascadedIDs, parent.ID)
 	cascadedCount++
 
+	// Auto-unblock issues that depend on this newly-closed parent
+	if targetStatus == models.StatusClosed {
+		db.CascadeUnblockDependents(parent.ID, sessionID)
+	}
+
 	// Recursively check parent's parent
 	moreCount, moreIDs := db.CascadeUpParentStatus(parent.ID, targetStatus, sessionID)
 	cascadedCount += moreCount
@@ -240,6 +245,80 @@ func (db *DB) CascadeUpParentStatus(issueID string, targetStatus models.Status,
 	return cascadedCount, cascadedIDs
 }
 
+// CascadeUnblockDependents checks issues that depend on closedIssueID.
+// For each dependent in "blocked" status, if ALL its dependencies are now closed,
+// it transitions the dependent from blocked → open.
+// Returns the count and IDs of unblocked issues.
+func (db *DB) CascadeUnblockDependents(closedIssueID, sessionID string) (int, []string) {
+	dependents, err := db.GetBlockedBy(closedIssueID)
+	if err != nil || len(dependents) == 0 {
+		return 0, nil
+	}
+
+	var unblockedIDs []string
+
+	for _, depID := range dependents {
+		issue, err := db.GetIssue(depID)
+		if err != nil || issue == nil {
+			continue
+		}
+
+		if issue.Status != models.StatusBlocked {
+			continue
+		}
+
+		// Check if ALL dependencies of this issue are now closed
+		deps, err := db.GetDependencies(depID)
+		if err != nil {
+			continue
+		}
+
+		allClosed := true
+		for _, d := range deps {
+			depIssue, err := db.GetIssue(d)
+			if err != nil || depIssue == nil {
+				allClosed = false
+				break
+			}
+			if depIssue.Status != models.StatusClosed {
+				allClosed = false
+				break
+			}
+		}
+
+		if !allClosed {
+			continue
+		}
+
+		prevData, _ := json.Marshal(issue)
+		issue.Status = models.StatusOpen
+		if err := db.UpdateIssue(issue); err != nil {
+			continue
+		}
+
+		newData, _ := json.Marshal(issue)
+		db.LogAction(&models.ActionLog{
+			SessionID:    sessionID,
+			ActionType:   models.ActionUnblock,
+			EntityType:   "issue",
+			EntityID:     depID,
+			PreviousData: string(prevData),
+			NewData:      string(newData),
+		})
+
+		db.AddLog(&models.Log{
+			IssueID:   depID,
+			SessionID: sessionID,
+			Message:   fmt.Sprintf("Auto-unblocked (dependency %s closed)", closedIssueID),
+			Type:      models.LogTypeProgress,
+		})
+
+		unblockedIDs = append(unblockedIDs, depID)
+	}
+
+	return len(unblockedIDs), unblockedIDs
+}
+
 // ============================================================================
 // Dependency Functions
 // ============================================================================
@@ -287,7 +366,7 @@ func (db *DB) GetDependencies(issueID string) ([]string, error) {
 // GetBlockedBy returns what issues are blocked by this issue
 func (db *DB) GetBlockedBy(issueID string) ([]string, error) {
 	rows, err := db.conn.Query(`
-		SELECT issue_id FROM issue_dependencies WHERE depends_on_id = ?
+		SELECT issue_id FROM issue_dependencies WHERE depends_on_id = ? AND relation_type = 'depends_on'
 	`, issueID)
 	if err != nil {
 		return nil, err