@vue-skuilder/db 0.2.8 → 0.2.9

package/docs/navigators-architecture.md

@@ -18,7 +18,7 @@ A card with a suitability score, audit trail, and pre-fetched metadata:
 interface WeightedCard {
   cardId: string;
   courseId: string;
-  score: number;              // 0-1 suitability score
+  score: number;              // suitability; anchored at [0,1] but unbounded above (see Score Semantics)
   provenance: StrategyContribution[];  // Audit trail
   tags?: string[];            // Pre-fetched tags (hydrated by Pipeline)
 }
@@ -47,17 +47,21 @@ interface CardGenerator {
 
 **Implementations:**
 - `ELONavigator` — New cards scored by ELO proximity to user skill (scores 0.0-1.0)
-- `SRSNavigator` — Review cards scored by overdueness, interval recency, and **backlog pressure** (scores 0.5-1.0)
-- `HardcodedOrderNavigator` — Fixed sequence defined by course author // NB this no longer exists but /home/colin/pn/vue-skuilder/master/packages/db/src/core/navigators/generators/prescribed.ts does - please update the doc in place
+- `SRSNavigator` — Review cards scored by overdueness, interval recency, and a multiplicative **backlog pressure** (base urgency ~0.5–0.95, scaled up by the backlog multiplier — can exceed 1.0)
+- `PrescribedCardsGenerator` — Stateful generator for authored, course-prescribed content (e.g. intro cards that must eventually surface). Tracks whether prescribed targets have been encountered, applies progressive pressure to stale/pending target groups, can emit upstream support cards to satisfy prereqs of still-blocked targets, and drills unlocked-but-under-practiced skills under a **practice-debt pressure** (base ×2 escalating with debt age, capped — a persistent, self-discharging analog of SRS backlog pressure that guarantees a minimum number of reps land after intro). Registered as `prescribed`. See `generators/prescribed.ts`.
 - `CompositeGenerator` — Merges multiple generators with frequency boost
 
 #### SRS Backlog Pressure
 
-The SRS generator implements a self-regulating **backlog pressure** mechanism that prevents review pile-up while maintaining healthy new/review balance:
+The SRS generator implements a self-regulating **backlog pressure** mechanism that prevents review pile-up while maintaining healthy new/review balance.
 
-- **Healthy backlog** (≤20 due reviews): No pressure boost, scores 0.5-0.95. New content (ELO) naturally dominates.
-- **Elevated backlog** (40 due): +0.25 boost, scores 0.75-1.0. Reviews compete with new cards.
-- **High backlog** (60+ due): +0.50 boost (max), scores 0.95-1.0. Reviews take priority.
+Each review's per-card urgency is `base 0.5 + (overdueness/recency factors)·0.45` → ~0.5–0.95. Backlog pressure then **multiplies** that urgency by a global factor that grows as the due pile exceeds the healthy threshold (default `MAX_BACKLOG_MULTIPLIER = 2.0`, reached at 3× healthy):
+
+- **Healthy backlog** (≤20 due reviews): ×1.0 — no boost, scores ~0.5–0.95. New content (ELO) naturally dominates.
+- **Elevated backlog** (40 due): ×1.5 — scores ~0.85–1.4. Reviews compete with new cards.
+- **High backlog** (60+ due): ×2.0 (max) — scores ~1.1–1.9. Reviews take priority.
+
+**Why multiplicative, and not clamped to 1.0:** review scores are *not* capped at 1.0. They are designed to be cross-comparable with new-card scores, which are themselves no longer [0,1]-bounded — session hints multiply scores (an intro can boost its exercise tag ×5+), and `SessionController` draws one rank-ordered supply queue where reviews and new compete on a single open scale (see `decision-single-supply-queue.md`). A flat additive `+0.5` (the previous design) was both too small to contend with such boosts and largely swallowed by the old 1.0 clamp. A bounded multiplier scales review priority onto the same open scale, so a heavy backlog can genuinely lift reviews into contention; the cap (not a score ceiling) is what keeps them from running away.
 
 This treats SRS scheduling times as **eligibility dates** rather than hard due dates—reviewing slightly later may be optimal. The system maintains a healthy backlog rather than always clearing to zero (avoiding "Anki death spiral").
 
@@ -66,7 +70,7 @@ Configuration via strategy `serializedData`:
 { "healthyBacklog": 20 }
 ```
 
-See `todo-review-adaptation.md` for planned per-user adaptation extensions.
+`MAX_BACKLOG_MULTIPLIER` is currently a module constant in `generators/srs.ts` (tune against the dbg overlay's "review backpressure" panel). See `todo-review-adaptation.md` for planned per-user adaptation extensions.
 
 ### CardFilter
 
@@ -200,10 +204,14 @@ Pipeline(
 
 | Score | Meaning |
 |-------|---------|
-| 1.0 | Fully suitable |
+| 1.0 | Fully suitable (the generator anchor, **not** a ceiling) |
 | 0.5 | Neutral |
 | 0.0 | Exclude (hard filter) |
 | 0.x | Proportional suitability |
+| >1.0 | Boosted / elevated-urgency — above the nominal "fully suitable" anchor |
+| +INF | Mandatory — a required card injected by a `requireCards`/`requireTags` hint |
+
+**1.0 is an anchor, not a cap.** Generators emit in ~[0,1], but the final score is an *open* scale: multiplicative filters and session hints can push scores above 1.0 (an intro boosting its exercise tag ×5), and the SRS backlog multiplier lifts urgent reviews past 1.0 under heavy backlog. This is deliberate — it lets reviews and new cards compete on one cross-comparable scale, which is what `SessionController`'s single supply queue draws against (see `decision-single-supply-queue.md`). `+INF` is the require-injection sentinel; such cards float to the head of the supply.
 
 **All filters are multipliers.** This means:
 - Filter order doesn't affect final scores (multiplication is commutative)
@@ -531,8 +539,15 @@ class MyFilter extends ContentNavigator implements CardFilter {
 ```
 
 This enables **single source of truth** patterns: the consumer app writes state
-via `UsrCrsDataInterface.putStrategyState()`, and the consumer filter reads it
-via the same key. No framework changes needed.
+through the course-scoped interface, which is reached via the **async**
+`getCourseInterface(courseId)` (await it first — it returns a `Promise`):
+
+```typescript
+const courseDb = await userDB.getCourseInterface(courseId);
+await courseDb.putStrategyState<MyStateType>('MySharedStateKey', data);
+```
+
+The consumer filter then reads it via the same key. No framework changes needed.
 
 ---
 
@@ -633,8 +648,9 @@ return { ...card, score: card.score * multiplier };
 | `core/navigators/PipelineAssembler.ts` | Builds Pipeline from strategy docs |
 | `core/navigators/CompositeGenerator.ts` | Merges multiple generators |
 | `core/navigators/generators/elo.ts` | ELO generator |
-| `core/navigators/generators/srs.ts` | SRS generator (with backlog pressure) |
-| `core/navigators/hardcodedOrder.ts` | Fixed-order generator |
+| `core/navigators/generators/srs.ts` | SRS generator (multiplicative backlog pressure) |
+| `core/navigators/generators/prescribed.ts` | Prescribed-content generator (authored targets, support cards, practice drilling) |
+| `core/navigators/SrsDebugger.ts` | Per-run SRS backlog capture for the session overlay |
 | `core/navigators/hierarchyDefinition.ts` | Prerequisite filter |
 | `core/navigators/interferenceMitigator.ts` | Interference filter |
 | `core/navigators/relativePriority.ts` | Priority filter |

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Database layer for vue-skuilder",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@nilock2/pouchdb-authentication": "^1.0.2",
-    "@vue-skuilder/common": "0.2.8",
+    "@vue-skuilder/common": "0.2.9",
     "cross-fetch": "^4.1.0",
     "moment": "^2.29.4",
     "pouchdb": "^9.0.0",
@@ -62,5 +62,5 @@
     "vite": "^8.0.0",
     "vitest": "^4.1.0"
   },
-  "stableVersion": "0.2.8"
+  "stableVersion": "0.2.9"
 }

package/src/core/interfaces/contentSource.ts

@@ -40,6 +40,13 @@ export interface StudySessionItem {
   cardID: string;
   courseID: string;
   elo?: number;
+  /**
+   * Pipeline suitability score at queue-build time, carried for observability
+   * (the debug overlay renders the now-load-bearing supply ranking). `+INF`
+   * marks a mandatory required card. Not used for any draw decision — the
+   * supplyQ is already ordered, so the controller draws front-to-back.
+   */
+  score?: number;
   // reviewID?: string;
 }
 

package/src/core/navigators/SrsDebugger.ts

@@ -0,0 +1,53 @@
+// ============================================================================
+// SRS BACKLOG DEBUGGER
+// ============================================================================
+//
+// A tiny module-level capture of the SRS generator's per-run backlog state,
+// so the live session overlay can show whether reviews being out-competed by
+// (boosted) new cards is *temporary* (the backlog multiplier still has headroom
+// to climb and lift reviews) or *boost-driven* (the multiplier is maxed and the
+// new-card boosts simply sit higher — only a hint relaxation reorders them).
+//
+// Mirrors MixerDebugger/PipelineDebugger: the generator pushes a snapshot each
+// run (keyed by course, latest wins); the overlay reads it via the controller's
+// getDebugSnapshot(). No DB load on the read path.
+//
+// ============================================================================
+
+/** Per-course snapshot of SRS backlog state, captured on each SRS generator run. */
+export interface SrsBacklogDebug {
+  courseId: string;
+  /** Total reviews scheduled for this course (due + not-yet-due). */
+  scheduledTotal: number;
+  /** Reviews eligible (due) right now. */
+  dueNow: number;
+  /** Healthy backlog threshold; multiplier is ×1.0 at or below this. */
+  healthyBacklog: number;
+  /** Global multiplier applied to every due review's urgency this run (1.0 → max). */
+  backlogMultiplier: number;
+  /** Max achievable backlog multiplier (the cap), for headroom context. */
+  maxBacklogMultiplier: number;
+  /** Highest review score produced this run (post-multiplier; can exceed 1.0); null if none due. */
+  topReviewScore: number | null;
+  /** Human-readable time until the next review comes due, or null if some are due now. */
+  nextDueIn: string | null;
+  /** Epoch ms of capture. */
+  timestamp: number;
+}
+
+const snapshots = new Map<string, SrsBacklogDebug>();
+
+/** Called by the SRS generator once per run. Latest snapshot per course wins. */
+export function captureSrsBacklog(snapshot: SrsBacklogDebug): void {
+  snapshots.set(snapshot.courseId, snapshot);
+}
+
+/** Current backlog snapshot for every course seen, newest-first. */
+export function getSrsBacklogDebug(): SrsBacklogDebug[] {
+  return [...snapshots.values()].sort((a, b) => b.timestamp - a.timestamp);
+}
+
+/** Drop all captured snapshots (called on session start, alongside pipeline history). */
+export function clearSrsBacklogDebug(): void {
+  snapshots.clear();
+}

package/src/core/navigators/generators/prescribed.ts

@@ -79,6 +79,14 @@ interface GroupCardState {
 interface PrescribedProgressState {
   updatedAt: string;
   groups: Record<string, GroupCardState>;
+  /**
+   * Per-practice-tag debt age: tag → ISO timestamp when the skill first appeared
+   * unlocked-but-under-practiced. Drives the practice-debt staleness escalation
+   * (older unpaid debt → higher pressure). An entry is carried while the debt is
+   * open and dropped the moment the skill reaches `practiceMinCount` — so the
+   * map self-prunes and "staleness" is measured from first-owed, not last-seen.
+   */
+  practiceDebt?: Record<string, string>;
 }
 
 interface TagPrerequisite {
@@ -126,10 +134,20 @@ const DEFAULT_MAX_PRACTICE_PER_RUN = 4;
 const BASE_TARGET_SCORE = 1.0;
 const BASE_SUPPORT_SCORE = 0.8;
 const DISCOVERED_SUPPORT_SCORE = 12.0;
-// Practice drill cards enter the pool at parity with a well-matched target so
-// they survive into the candidate set; per-skill *emphasis* (recency, decay) is
-// the durable boost's job, not this base score's.
+// Practice drill cards: a *practice-debt pressure*, parallel to the SRS backlog
+// multiplier. An unlocked-but-under-practiced skill owes reps; that debt is
+// durable (keyed off per-tag attempt count) and discharges by practice, not
+// time. The score is base × a debt multiplier that starts at PRACTICE_BASE_MULT
+// (so a few reps land promptly after intro, competing with pressured reviews)
+// and escalates by how long the debt has stayed open (capped), so a chronically
+// out-competed skill eventually forces exposure rather than competing at flat
+// parity forever. Replaces the old flat 1.0, which punted emphasis to the
+// session-scoped intro boost that evaporates at session end.
 const BASE_PRACTICE_SCORE = 1.0;
+const PRACTICE_BASE_MULT = 2.0;
+const MAX_PRACTICE_MULTIPLIER = 4.0;
+// Added to the multiplier per day the debt stays open (linear, then clamped).
+const PRACTICE_STALENESS_BUMP_PER_DAY = 0.5;
 const MAX_TARGET_MULTIPLIER = 8.0;
 const MAX_SUPPORT_MULTIPLIER = 4.0;
 
@@ -271,6 +289,10 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
     const emitted: WeightedCard[] = [];
     const emittedIds = new Set<string>();
     const groupRuntimes: GroupRuntimeState[] = [];
+    // Practice-debt ages carried forward: stamped when a skill first appears
+    // under-practiced, dropped once it's discharged (see buildPracticeCards).
+    const priorPracticeDebt = progress.practiceDebt ?? {};
+    const nextPracticeDebt: Record<string, string> = {};
 
     for (const group of this.config.groups) {
       const runtime = this.buildGroupRuntimeState({
@@ -346,11 +368,17 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
         userGlobalElo,
         activeIds,
         seenIds,
+        priorPracticeDebt,
+        nextPracticeDebt,
       });
 
       emitted.push(...directCards, ...supportCards, ...discoveredSupportCards, ...practiceCards);
     }
 
+    // Persist the carried-forward practice debt (self-pruned: discharged skills
+    // simply aren't re-stamped above, so they drop out of the next state).
+    nextState.practiceDebt = nextPracticeDebt;
+
     const hintSummary = this.buildSupportHintSummary(groupRuntimes);
     const hints: ReplanHints | undefined =
       Object.keys(hintSummary.boostTags).length > 0
@@ -821,9 +849,16 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
    * `practiceMinCount`), this resolves cards carrying that tag and emits them
    * into the candidate pool. It exists because global-ELO retrieval
    * systematically fails to fetch the (low-ELO) drill cards for a
-   * freshly-introduced skill — putting them in the pool here lets the pipeline's
-   * scoring + the durable per-skill boost order them. Ordering/emphasis is NOT
-   * this method's job; it only guarantees presence.
+   * freshly-introduced skill — putting them in the pool here guarantees presence.
+   *
+   * Emphasis is a **practice-debt pressure** (parallel to SRS backlog pressure):
+   * cards score `base × multiplier`, where the multiplier starts at
+   * PRACTICE_BASE_MULT (so a few reps land promptly post-intro, competing with
+   * pressured reviews) and escalates by how long the debt has stayed open
+   * (per-tag, time-based via `priorPracticeDebt`/`nextPracticeDebt`), clamped at
+   * MAX_PRACTICE_MULTIPLIER. The debt is durable and self-discharges the instant
+   * the skill reaches `practiceMinCount` — so this no longer relies on the
+   * session-scoped intro boost to actually surface.
    *
    * Fully data-driven: the unlock relation comes from the hierarchy config and
    * practice-status from per-tag ELO. No card-id or tag-namespace hard-coding.
@@ -838,6 +873,8 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
     userGlobalElo: number;
     activeIds: Set<string>;
     seenIds: Set<string>;
+    priorPracticeDebt: Record<string, string>;
+    nextPracticeDebt: Record<string, string>;
   }): WeightedCard[] {
     const {
       group,
@@ -849,6 +886,8 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
       userGlobalElo,
       activeIds,
       seenIds,
+      priorPracticeDebt,
+      nextPracticeDebt,
     } = args;
 
     const patterns = group.practiceTagPatterns ?? [];
@@ -866,6 +905,25 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
 
     if (practiceTags.length === 0) return [];
 
+    // Carry forward (or open) each under-practiced skill's debt age, and derive
+    // its practice multiplier: base + staleness-since-first-owed, clamped. Done
+    // for every under-practiced tag (not just emitted ones) so the debt clock
+    // keeps running even on runs where the cap or de-dup emits nothing.
+    const now = Date.now();
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    const tagMultiplier = new Map<string, number>();
+    for (const tag of practiceTags) {
+      const firstOwedAt = priorPracticeDebt[tag] ?? isoNow();
+      nextPracticeDebt[tag] = firstOwedAt;
+      const staleDays = Math.max(0, (now - new Date(firstOwedAt).getTime()) / DAY_MS);
+      const mult = clamp(
+        PRACTICE_BASE_MULT + staleDays * PRACTICE_STALENESS_BUMP_PER_DAY,
+        PRACTICE_BASE_MULT,
+        MAX_PRACTICE_MULTIPLIER
+      );
+      tagMultiplier.set(tag, mult);
+    }
+
     // Reuse the diversity-aware tag→cards collector (stem-dedup + shuffle).
     const practiceCardIds = this.findDiscoveredSupportCards({
       supportTags: practiceTags,
@@ -886,19 +944,28 @@ export default class PrescribedCardsGenerator extends ContentNavigator implement
     const cards: WeightedCard[] = [];
     for (const cardId of practiceCardIds) {
       emittedIds.add(cardId);
+      // Most-stale wins: a card may carry several practice tags; take the
+      // highest debt multiplier among the ones it serves.
+      let mult = PRACTICE_BASE_MULT;
+      for (const tag of practiceTags) {
+        if ((cardsByTag.get(tag)?.includes(cardId) ?? false)) {
+          mult = Math.max(mult, tagMultiplier.get(tag) ?? PRACTICE_BASE_MULT);
+        }
+      }
+      const score = BASE_PRACTICE_SCORE * mult;
       cards.push({
         cardId,
         courseId,
-        score: BASE_PRACTICE_SCORE,
+        score,
         provenance: [
           {
             strategy: 'prescribed',
             strategyName: this.strategyName || this.name,
             strategyId: this.strategyId || 'NAVIGATION_STRATEGY-prescribed',
             action: 'generated' as const,
-            score: BASE_PRACTICE_SCORE,
+            score,
             reason:
-              `mode=practice;group=${group.id};` +
+              `mode=practice;group=${group.id};debtMult=×${mult.toFixed(2)};` +
               `underPracticedSkills=${practiceTags.length};` +
               `practiceTags=${practiceTags.slice(0, 8).join('|')}${practiceTags.length > 8 ? '|…' : ''};` +
               `testversion=${PRESCRIBED_DEBUG_VERSION}`,

package/src/core/navigators/generators/srs.ts

@@ -3,6 +3,7 @@ import type { ScheduledCard } from '../../types/user';
 import type { CourseDBInterface } from '../../interfaces/courseDB';
 import type { UserDBInterface } from '../../interfaces/userDB';
 import { ContentNavigator } from '../index';
+import { captureSrsBacklog } from '../SrsDebugger';
 import type { ContentNavigationStrategyData } from '../../types/contentNavigationStrategy';
 import type { CardGenerator, GeneratorContext, GeneratorResult } from './types';
 import { logger } from '@db/util/logger';
@@ -41,10 +42,19 @@ import { logger } from '@db/util/logger';
 const DEFAULT_HEALTHY_BACKLOG = 20;
 
 /**
- * Maximum backlog pressure contribution to score.
- * At 3x healthy backlog, pressure maxes out.
+ * Maximum backlog pressure as a *multiplier* on review urgency.
+ *
+ * Backlog pressure is multiplicative (×1.0 at/below healthy, scaling up as the
+ * due pile grows, maxing here at 3× healthy backlog). It replaces an older
+ * additive +0..+0.5 term that was a [0,1]-era modifier — once review scores
+ * stopped being clamped to 1.0 and new cards could be boosted well past it
+ * (e.g. an intro ×5 → 7+), a flat +0.5 was both too small to compete and mostly
+ * eaten by the old 1.0 clamp. A multiplier scales review priority onto the same
+ * open scale the boosted new cards live on, so a heavy backlog can genuinely
+ * lift reviews into competition. Tunable — verify review vs new ordering in the
+ * dbg overlay's "review backpressure" panel.
  */
-const MAX_BACKLOG_PRESSURE = 0.5;
+const MAX_BACKLOG_MULTIPLIER = 2.0;
 
 /**
  * Configuration for the SRS strategy.
@@ -158,14 +168,31 @@ export default class SRSNavigator extends ContentNavigator implements CardGenera
       }
     }
 
-    // Compute backlog pressure - applies globally to all reviews
-    const backlogPressure = this.computeBacklogPressure(dueReviews.length);
+    // Compute backlog pressure (multiplicative) - applies globally to all reviews
+    const backlogMultiplier = this.computeBacklogMultiplier(dueReviews.length);
+
+    // Time until the next not-yet-due review (for the debug overlay): shows
+    // reviews are *coming* even when none are due right now.
+    const notDue = reviews.filter((r) => !now.isAfter(moment.utc(r.reviewTime)));
+    let nextDueIn: string | null = null;
+    if (notDue.length > 0) {
+      const next = notDue.reduce((a, b) =>
+        moment.utc(a.reviewTime).isBefore(moment.utc(b.reviewTime)) ? a : b
+      );
+      const until = moment.duration(moment.utc(next.reviewTime).diff(now));
+      nextDueIn =
+        until.asHours() < 1
+          ? `${Math.round(until.asMinutes())}m`
+          : until.asHours() < 24
+            ? `${Math.round(until.asHours())}h`
+            : `${Math.round(until.asDays())}d`;
+    }
 
     // Log review status for transparency
     if (dueReviews.length > 0) {
       const pressureNote =
-        backlogPressure > 0
-          ? ` [backlog pressure: +${backlogPressure.toFixed(2)}]`
+        backlogMultiplier > 1
+          ? ` [backlog pressure: ×${backlogMultiplier.toFixed(2)}]`
           : ` [healthy backlog]`;
       logger.info(
         `[SRS] Course ${courseId}: ${dueReviews.length} reviews due now (of ${reviews.length} scheduled)${pressureNote}`
@@ -192,7 +219,7 @@ export default class SRSNavigator extends ContentNavigator implements CardGenera
     }
 
     const scored = dueReviews.map((review) => {
-      const { score, reason } = this.computeUrgencyScore(review, now, backlogPressure);
+      const { score, reason } = this.computeUrgencyScore(review, now, backlogMultiplier);
 
       return {
         cardId: review.cardId,
@@ -213,41 +240,56 @@ export default class SRSNavigator extends ContentNavigator implements CardGenera
     });
 
     // Sort by score descending and limit
+    const sorted = scored.sort((a, b) => b.score - a.score);
+
+    // Capture backlog state for the live session overlay (see SrsDebugger).
+    captureSrsBacklog({
+      courseId,
+      scheduledTotal: reviews.length,
+      dueNow: dueReviews.length,
+      healthyBacklog: this.healthyBacklog,
+      backlogMultiplier,
+      maxBacklogMultiplier: MAX_BACKLOG_MULTIPLIER,
+      topReviewScore: sorted.length > 0 ? sorted[0].score : null,
+      nextDueIn,
+      timestamp: Date.now(),
+    });
+
     // [perf] parked: SRSgen / getPendingReviews timing
-    // const srsResult = { cards: scored.sort((a, b) => b.score - a.score).slice(0, limit) };
+    // const srsResult = { cards: sorted.slice(0, limit) };
     // logger.info(
     //   `[perf][SRSgen] total=${(performance.now() - tSrs0).toFixed(0)}ms ` +
     //     `(pendingReviews=${(tReviews - tSrs0).toFixed(0)}) ` +
     //     `[scheduled=${reviews.length} due=${dueReviews.length}]`
     // );
-    return { cards: scored.sort((a, b) => b.score - a.score).slice(0, limit) };
+    return { cards: sorted.slice(0, limit) };
   }
 
   /**
-   * Compute backlog pressure based on number of due reviews.
+   * Compute the multiplicative backlog pressure based on number of due reviews.
    *
-   * Backlog pressure is 0 when at or below healthy threshold,
-   * and increases linearly above it, maxing out at MAX_BACKLOG_PRESSURE.
+   * ×1.0 at or below the healthy threshold (no boost), increasing linearly above
+   * it and maxing out at MAX_BACKLOG_MULTIPLIER at 3× the healthy backlog.
    *
-   * Examples (with default healthyBacklog=20):
-   * - 10 due reviews → 0.00 (healthy)
-   * - 20 due reviews → 0.00 (at threshold)
-   * - 40 due reviews → 0.25 (2x threshold)
-   * - 60 due reviews → 0.50 (3x threshold, maxed)
+   * Examples (with default healthyBacklog=20, MAX_BACKLOG_MULTIPLIER=2.0):
+   * - 10 due reviews → ×1.00 (healthy)
+   * - 20 due reviews → ×1.00 (at threshold)
+   * - 40 due reviews → ×1.50 (2x threshold)
+   * - 60 due reviews → ×2.00 (3x threshold, maxed)
    *
    * @param dueCount - Number of reviews currently due
-   * @returns Backlog pressure score to add to urgency (0 to MAX_BACKLOG_PRESSURE)
+   * @returns Multiplier applied to review urgency (1.0 to MAX_BACKLOG_MULTIPLIER)
    */
-  private computeBacklogPressure(dueCount: number): number {
+  private computeBacklogMultiplier(dueCount: number): number {
     if (dueCount <= this.healthyBacklog) {
-      return 0;
+      return 1.0;
     }
 
-    // Linear increase: at 2x healthy, pressure = 0.25; at 3x, pressure = 0.50
+    // Linear in excess: ×1 at healthy, reaching MAX at 3× healthy (excess = 2×healthy).
     const excess = dueCount - this.healthyBacklog;
-    const pressure = (excess / this.healthyBacklog) * (MAX_BACKLOG_PRESSURE / 2);
+    const multiplier = 1 + (excess / this.healthyBacklog) * ((MAX_BACKLOG_MULTIPLIER - 1) / 2);
 
-    return Math.min(MAX_BACKLOG_PRESSURE, pressure);
+    return Math.min(MAX_BACKLOG_MULTIPLIER, multiplier);
   }
 
   /**
@@ -263,22 +305,23 @@ export default class SRSNavigator extends ContentNavigator implements CardGenera
    *    - 30 days (720h) → ~0.56
    *    - 180 days → ~0.30
    *
-   * 3. Backlog pressure = global boost when review backlog exceeds healthy threshold
-   *    - At healthy backlog: 0
-   *    - At 2x healthy: +0.25
-   *    - At 3x+ healthy: +0.50 (max)
+   * 3. Backlog pressure = global *multiplier* when review backlog exceeds the
+   *    healthy threshold (×1.0 healthy → up to MAX_BACKLOG_MULTIPLIER at 3×).
    *
-   * Combined: base 0.5 + (urgency factors * 0.45) + backlog pressure
-   * Result range: 0.5 to 1.0 (uncapped to allow high-urgency reviews to compete with new cards)
+   * Combined: (base 0.5 + urgency factors * 0.45) × backlog multiplier.
+   * Per-card range before pressure: ~0.57–0.95. NOT clamped to 1.0 — under a
+   * heavy backlog reviews scale onto the open scale to compete with (and exceed)
+   * new cards; what keeps them from running away is the bounded multiplier, not
+   * a hard ceiling.
    *
    * @param review - The scheduled card to score
    * @param now - Current time
-   * @param backlogPressure - Pre-computed backlog pressure (0 to 0.5)
+   * @param backlogMultiplier - Pre-computed backlog multiplier (1.0 to MAX_BACKLOG_MULTIPLIER)
    */
   private computeUrgencyScore(
     review: ScheduledCard,
     now: moment.Moment,
-    backlogPressure: number
+    backlogMultiplier: number
   ): { score: number; reason: string } {
     const scheduledAt = moment.utc(review.scheduledAt);
     const due = moment.utc(review.reviewTime);
@@ -299,10 +342,11 @@ export default class SRSNavigator extends ContentNavigator implements CardGenera
     const overdueContribution = Math.min(1.0, Math.max(0, relativeOverdue));
     const urgency = overdueContribution * 0.5 + recencyFactor * 0.5;
 
-    // Final score: base 0.5 + urgency contribution + backlog pressure
-    // Uncapped at 1.0 (no 0.95 ceiling) - allows high-urgency reviews to compete with new cards
+    // Final score: per-card urgency (base 0.5 + contribution) scaled by the
+    // global backlog multiplier. No 1.0 clamp — reviews compete on the open
+    // scale; the bounded multiplier (not a ceiling) caps the lift.
     const baseScore = 0.5 + urgency * 0.45;
-    const score = Math.min(1.0, baseScore + backlogPressure);
+    const score = baseScore * backlogMultiplier;
 
     // Build reason string with all contributing factors
     const reasonParts = [
@@ -312,8 +356,8 @@ export default class SRSNavigator extends ContentNavigator implements CardGenera
       `recency: ${recencyFactor.toFixed(2)}`,
     ];
 
-    if (backlogPressure > 0) {
-      reasonParts.push(`backlog: +${backlogPressure.toFixed(2)}`);
+    if (backlogMultiplier > 1) {
+      reasonParts.push(`backlog: ×${backlogMultiplier.toFixed(2)}`);
     }
 
     reasonParts.push('review');

package/src/core/navigators/index.ts

@@ -27,6 +27,11 @@ export {
 
 // Re-export the commit-free forecast capability surface.
 export type { PipelineForecaster } from './Pipeline';
+export {
+  getSrsBacklogDebug,
+  clearSrsBacklogDebug,
+  type SrsBacklogDebug,
+} from './SrsDebugger';
 
 import { LearnableWeight } from '../types/contentNavigationStrategy';
 export type { ContentNavigationStrategyData, LearnableWeight } from '../types/contentNavigationStrategy';