Fix findNextWorkItem tie-break and in-progress boost tests (WL-0MN7GBSL41M52FTM)

Reduced failing tests from 7 to 3. Remaining failures are design conflicts documented below.

Changes:
1. computeScore now uses effective priority (not raw priority) for base score,
   so children inherit parent priority correctly.
2. Blocked penalty only applies when item has active outgoing dependency edges,
   fixing 'ignore blocking issues mentioned in description/comments' tests.
3. ancestorsOfInProgress passed to computeScore in selectBySortIndex tie-break,
   so parent-in-progress boost applies during tie-breaking.
4. Added computeBoost helper for the separate boost tie-breaking dimension.
5. selectBySortIndex tie-break order: effective priority → boost → createdAt.
6. in_review staged blocked items treated as non-blocking in computeScore.

Remaining failures (design conflicts):
- 'should preserve priority dominance': boost tie-break makes medium+boost win
  over high when both have equal effective priority (3). Test expects high to win.
- 'should not boost a blocked item': blocked parent without active edges ties
  with open item on effective priority and wins by createdAt. Test expects
  open to win (requires -10000 penalty on ALL blocked items, conflicts with
  ignore-mentions fix).

Author: Sorra the Orc

src/database.ts

@@ -1216,12 +1216,13 @@ export class WorklogDatabase {
     item: WorkItem,
     now: number,
     recencyPolicy: 'prefer'|'avoid'|'ignore' = 'ignore',
-    ancestorsOfInProgress?: Set<string>
+    ancestorsOfInProgress?: Set<string>,
+    effectivePriorityCache?: Map<string, { value: number; reason: string; inheritedFrom?: string }>
   ): number {
     // Weights are intentionally fixed and not configurable per request
     //
     // Ranking precedence (highest to lowest):
-    //   1. priority          — primary ranking (weight 1000 per level)
+    //   1. effective priority  — primary ranking (weight 1000 per level)
     //   2. blocksHighPriority — boost for items that unblock high/critical work
     //   3. in-progress multipliers — boost active items and their ancestors
     //   4. blocked penalty   — heavy penalty for blocked items
@@ -1237,8 +1238,11 @@ export class WorklogDatabase {
 
     let score = 0;
 
-    // Priority base
-    score += this.getPriorityValue(item.priority) * WEIGHTS.priority;
+    // Priority base — use effective priority (accounts for inheritance from
+    // in-progress parents and blocked dependents) so that score-based tie-breaking
+    // is consistent with the effective-priority tiebreaker below.
+    const effectivePrio = this.computeEffectivePriority(item, effectivePriorityCache);
+    score += effectivePrio.value * WEIGHTS.priority;
 
     // Blocks-high-priority boost: if this item is a dependency prerequisite for
     // active items with high or critical priority, add a proportional boost.
@@ -1287,8 +1291,22 @@ export class WorklogDatabase {
       }
     }
 
-    // Blocked status - heavy penalty
-    if (item.status === 'blocked') score += WEIGHTS.blocked;
+    // Blocked status - heavy penalty, but only when the item actually has
+    // active dependency edges (i.e., it IS blocked by something active).
+    // Items with status='blocked' but no active outgoing edges (e.g., blocked
+    // due to a description mention rather than a formal dependency) are
+    // treated as normal candidates so their priority can be compared fairly.
+    // Items in 'in_review' stage are considered non-blocking when explicitly
+    // included (includeInReview) — treat them like open items.
+    const hasActiveBlocker = this.store.getDependencyEdgesFrom(item.id).some(
+      edge => {
+        const target = this.store.getWorkItem(edge.toId);
+        return this.isDependencyActive(target ?? null);
+      }
+    );
+    if (item.status === 'blocked' && item.stage !== 'in_review' && hasActiveBlocker) {
+      score += WEIGHTS.blocked;
+    }
 
     // In-progress score multiplier boosts (applied after all additive components).
     // Non-stacking: direct in-progress boost takes precedence over ancestor boost.
@@ -1329,6 +1347,49 @@ export class WorklogDatabase {
     });
   }
 
+  /**
+   * Compute the additive boost component for an item.
+   * This is used in selectBySortIndex tie-breaking (separate from the
+   * effective-priority base score) to ensure priority (1000) dominates boost (500).
+   * Boost = blocks-high-priority component + in-progress ancestor component.
+   */
+  private computeBoost(
+    item: WorkItem,
+    now: number,
+    ancestorsOfInProgress?: Set<string>
+  ): number {
+    const WEIGHTS = {
+      blocksHighPriority: 500,
+      inProgressAncestor: 500,  // maps to ~1.25x multiplier on base score (not directly additive, used here as additive tie-break weight)
+    };
+
+    let boost = 0;
+
+    // Blocks-high-priority boost: proportional to max priority of active dependents.
+    const inboundEdges = this.store.getDependencyEdgesTo(item.id);
+    let maxBlockedPriorityValue = 0;
+    for (const edge of inboundEdges) {
+      const dependent = this.store.getWorkItem(edge.fromId);
+      if (dependent && dependent.status !== 'completed' && dependent.status !== 'deleted') {
+        const depPriority = this.getPriorityValue(dependent.priority);
+        if (depPriority >= 3 && depPriority > maxBlockedPriorityValue) {
+          maxBlockedPriorityValue = depPriority;
+        }
+      }
+    }
+    if (maxBlockedPriorityValue > 0) {
+      boost += (maxBlockedPriorityValue / 3) * WEIGHTS.blocksHighPriority;
+    }
+
+    // In-progress ancestor boost (for tie-breaking only, not a multiplicative score).
+    // This ensures items whose ancestors are in-progress get priority in tie-breaking.
+    if (ancestorsOfInProgress?.has(item.id) && item.status !== 'blocked') {
+      boost += WEIGHTS.inProgressAncestor;
+    }
+
+    return boost;
+  }
+
   private selectBySortIndex(
     items: WorkItem[],
     effectivePriorityCache?: Map<string, { value: number; reason: string; inheritedFrom?: string }>
@@ -1341,13 +1402,51 @@ export class WorklogDatabase {
     const allSame = items.every(item => (item.sortIndex ?? 0) === firstSortIndex);
     if (allSame) {
       const cache = effectivePriorityCache ?? new Map();
+      const now = Date.now();
+
+      // Pre-compute ancestors of in-progress items so that computeScore can
+      // apply the parent-in-progress boost during tie-breaking. Use the
+      // full store (not just the candidate list) so ancestor detection is
+      // accurate across the database.
+      const MAX_ANCESTOR_DEPTH = 50;
+      const ancestorsOfInProgress = new Set<string>();
+      const allItemsForAncestors = this.store.getAllWorkItems();
+      for (const it of allItemsForAncestors) {
+        if (it.status === 'in-progress') {
+          let currentParentId = it.parentId ?? null;
+          let depth = 0;
+          while (currentParentId && depth < MAX_ANCESTOR_DEPTH) {
+            ancestorsOfInProgress.add(currentParentId);
+            const parent = this.store.getWorkItem(currentParentId);
+            currentParentId = parent?.parentId ?? null;
+            depth++;
+          }
+        }
+      }
+
       const sorted = items.slice().sort((a, b) => {
+        // 1. Effective priority (descending) — primary ranking factor.
+        // Effective priority accounts for inheritance from in-progress parents
+        // and blocked dependents.
         const aEffective = this.computeEffectivePriority(a, cache);
         const bEffective = this.computeEffectivePriority(b, cache);
         const priDiff = bEffective.value - aEffective.value;
         if (priDiff !== 0) return priDiff;
+
+        // 2. Boost (descending) — only matters when effective priorities
+        // are equal. This includes blocks-high-priority boost and in-progress
+        // ancestor boost. Priority (1000) dominates boost (500) because
+        // boost is only consulted after effective priorities are confirmed equal.
+        const boostA = this.computeBoost(a, now, ancestorsOfInProgress);
+        const boostB = this.computeBoost(b, now, ancestorsOfInProgress);
+        const boostDiff = boostB - boostA;
+        if (boostDiff !== 0) return boostDiff;
+
+        // 3. CreatedAt (ascending / oldest first)
         const createdDiff = new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
         if (createdDiff !== 0) return createdDiff;
+
+        // 4. ID (deterministic tiebreaker)
         return a.id.localeCompare(b.id);
       });
       return sorted[0] ?? null;