@vue-skuilder/db 0.2.7 → 0.2.9

package/dist/index.mjs

@@ -944,6 +944,7 @@ __export(PipelineDebugger_exports, {
   buildRunReport: () => buildRunReport,
   captureRun: () => captureRun,
   clearRunHistory: () => clearRunHistory,
+  getActivePipeline: () => getActivePipeline,
   mountPipelineDebugger: () => mountPipelineDebugger,
   pipelineDebugAPI: () => pipelineDebugAPI,
   registerPipelineForDebug: () => registerPipelineForDebug
@@ -951,6 +952,9 @@ __export(PipelineDebugger_exports, {
 function registerPipelineForDebug(pipeline) {
   _activePipeline = pipeline;
 }
+function getActivePipeline() {
+  return _activePipeline;
+}
 function clearRunHistory() {
   runHistory.length = 0;
 }
@@ -1766,6 +1770,30 @@ Example:
   }
 });
 
+// src/core/navigators/SrsDebugger.ts
+var SrsDebugger_exports = {};
+__export(SrsDebugger_exports, {
+  captureSrsBacklog: () => captureSrsBacklog,
+  clearSrsBacklogDebug: () => clearSrsBacklogDebug,
+  getSrsBacklogDebug: () => getSrsBacklogDebug
+});
+function captureSrsBacklog(snapshot) {
+  snapshots.set(snapshot.courseId, snapshot);
+}
+function getSrsBacklogDebug() {
+  return [...snapshots.values()].sort((a, b) => b.timestamp - a.timestamp);
+}
+function clearSrsBacklogDebug() {
+  snapshots.clear();
+}
+var snapshots;
+var init_SrsDebugger = __esm({
+  "src/core/navigators/SrsDebugger.ts"() {
+    "use strict";
+    snapshots = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/core/navigators/generators/CompositeGenerator.ts
 var CompositeGenerator_exports = {};
 __export(CompositeGenerator_exports, {
@@ -2133,7 +2161,7 @@ function shuffleInPlace(arr) {
 function pickTopByScore(cards, limit) {
   return [...cards].sort((a, b) => b.score - a.score || a.cardId.localeCompare(b.cardId)).slice(0, limit);
 }
-var DEFAULT_FRESHNESS_WINDOW, DEFAULT_MAX_DIRECT_PER_RUN, DEFAULT_MAX_SUPPORT_PER_RUN, DEFAULT_HIERARCHY_DEPTH, DEFAULT_MIN_COUNT, DEFAULT_PRACTICE_MIN_COUNT, DEFAULT_MAX_PRACTICE_PER_RUN, BASE_TARGET_SCORE, BASE_SUPPORT_SCORE, DISCOVERED_SUPPORT_SCORE, BASE_PRACTICE_SCORE, MAX_TARGET_MULTIPLIER, MAX_SUPPORT_MULTIPLIER, PRESCRIBED_DEBUG_VERSION, PrescribedCardsGenerator;
+var DEFAULT_FRESHNESS_WINDOW, DEFAULT_MAX_DIRECT_PER_RUN, DEFAULT_MAX_SUPPORT_PER_RUN, DEFAULT_HIERARCHY_DEPTH, DEFAULT_MIN_COUNT, DEFAULT_PRACTICE_MIN_COUNT, DEFAULT_MAX_PRACTICE_PER_RUN, BASE_TARGET_SCORE, BASE_SUPPORT_SCORE, DISCOVERED_SUPPORT_SCORE, BASE_PRACTICE_SCORE, PRACTICE_BASE_MULT, MAX_PRACTICE_MULTIPLIER, PRACTICE_STALENESS_BUMP_PER_DAY, MAX_TARGET_MULTIPLIER, MAX_SUPPORT_MULTIPLIER, PRESCRIBED_DEBUG_VERSION, PrescribedCardsGenerator;
 var init_prescribed = __esm({
   "src/core/navigators/generators/prescribed.ts"() {
     "use strict";
@@ -2150,6 +2178,9 @@ var init_prescribed = __esm({
     BASE_SUPPORT_SCORE = 0.8;
     DISCOVERED_SUPPORT_SCORE = 12;
     BASE_PRACTICE_SCORE = 1;
+    PRACTICE_BASE_MULT = 2;
+    MAX_PRACTICE_MULTIPLIER = 4;
+    PRACTICE_STALENESS_BUMP_PER_DAY = 0.5;
     MAX_TARGET_MULTIPLIER = 8;
     MAX_SUPPORT_MULTIPLIER = 4;
     PRESCRIBED_DEBUG_VERSION = "testversion-prescribed-v3";
@@ -2209,6 +2240,8 @@ var init_prescribed = __esm({
         const emitted = [];
         const emittedIds = /* @__PURE__ */ new Set();
         const groupRuntimes = [];
+        const priorPracticeDebt = progress.practiceDebt ?? {};
+        const nextPracticeDebt = {};
         for (const group of this.config.groups) {
           const runtime = this.buildGroupRuntimeState({
             group,
@@ -2266,10 +2299,13 @@ var init_prescribed = __esm({
             userTagElo,
             userGlobalElo,
             activeIds,
-            seenIds
+            seenIds,
+            priorPracticeDebt,
+            nextPracticeDebt
           });
           emitted.push(...directCards, ...supportCards, ...discoveredSupportCards, ...practiceCards);
         }
+        nextState.practiceDebt = nextPracticeDebt;
         const hintSummary = this.buildSupportHintSummary(groupRuntimes);
         const hints = Object.keys(hintSummary.boostTags).length > 0 ? {
           boostTags: hintSummary.boostTags,
@@ -2603,9 +2639,16 @@ var init_prescribed = __esm({
        * `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.
@@ -2620,7 +2663,9 @@ var init_prescribed = __esm({
           userTagElo,
           userGlobalElo,
           activeIds,
-          seenIds
+          seenIds,
+          priorPracticeDebt,
+          nextPracticeDebt
         } = args;
         const patterns = group.practiceTagPatterns ?? [];
         if (patterns.length === 0) return [];
@@ -2630,6 +2675,20 @@ var init_prescribed = __esm({
           (tag) => patterns.some((p) => matchesTagPattern(tag, p)) && this.isUnlockedGatedSkill(tag, hierarchyConfigs, userTagElo, userGlobalElo) && (userTagElo[tag]?.count ?? 0) < practiceMinCount
         );
         if (practiceTags.length === 0) return [];
+        const now = Date.now();
+        const DAY_MS = 24 * 60 * 60 * 1e3;
+        const tagMultiplier = /* @__PURE__ */ new Map();
+        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);
+        }
         const practiceCardIds = this.findDiscoveredSupportCards({
           supportTags: practiceTags,
           cardsByTag,
@@ -2645,18 +2704,25 @@ var init_prescribed = __esm({
         const cards = [];
         for (const cardId of practiceCardIds) {
           emittedIds.add(cardId);
+          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",
-                score: BASE_PRACTICE_SCORE,
-                reason: `mode=practice;group=${group.id};underPracticedSkills=${practiceTags.length};practiceTags=${practiceTags.slice(0, 8).join("|")}${practiceTags.length > 8 ? "|\u2026" : ""};testversion=${PRESCRIBED_DEBUG_VERSION}`
+                score,
+                reason: `mode=practice;group=${group.id};debtMult=\xD7${mult.toFixed(2)};underPracticedSkills=${practiceTags.length};practiceTags=${practiceTags.slice(0, 8).join("|")}${practiceTags.length > 8 ? "|\u2026" : ""};testversion=${PRESCRIBED_DEBUG_VERSION}`
               }
             ]
           });
@@ -2830,14 +2896,15 @@ __export(srs_exports, {
   default: () => SRSNavigator
 });
 import moment3 from "moment";
-var DEFAULT_HEALTHY_BACKLOG, MAX_BACKLOG_PRESSURE, SRSNavigator;
+var DEFAULT_HEALTHY_BACKLOG, MAX_BACKLOG_MULTIPLIER, SRSNavigator;
 var init_srs = __esm({
   "src/core/navigators/generators/srs.ts"() {
     "use strict";
     init_navigators();
+    init_SrsDebugger();
     init_logger();
     DEFAULT_HEALTHY_BACKLOG = 20;
-    MAX_BACKLOG_PRESSURE = 0.5;
+    MAX_BACKLOG_MULTIPLIER = 2;
     SRSNavigator = class extends ContentNavigator {
       /** Human-readable name for CardGenerator interface */
       name;
@@ -2904,9 +2971,18 @@ var init_srs = __esm({
             }
           }
         }
-        const backlogPressure = this.computeBacklogPressure(dueReviews.length);
+        const backlogMultiplier = this.computeBacklogMultiplier(dueReviews.length);
+        const notDue = reviews.filter((r) => !now.isAfter(moment3.utc(r.reviewTime)));
+        let nextDueIn = null;
+        if (notDue.length > 0) {
+          const next = notDue.reduce(
+            (a, b) => moment3.utc(a.reviewTime).isBefore(moment3.utc(b.reviewTime)) ? a : b
+          );
+          const until = moment3.duration(moment3.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`;
+        }
         if (dueReviews.length > 0) {
-          const pressureNote = backlogPressure > 0 ? ` [backlog pressure: +${backlogPressure.toFixed(2)}]` : ` [healthy backlog]`;
+          const pressureNote = backlogMultiplier > 1 ? ` [backlog pressure: \xD7${backlogMultiplier.toFixed(2)}]` : ` [healthy backlog]`;
           logger.info(
             `[SRS] Course ${courseId}: ${dueReviews.length} reviews due now (of ${reviews.length} scheduled)${pressureNote}`
           );
@@ -2925,7 +3001,7 @@ var init_srs = __esm({
           logger.info(`[SRS] Course ${courseId}: No reviews scheduled`);
         }
         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,
             courseId: review.courseId,
@@ -2943,30 +3019,42 @@ var init_srs = __esm({
             ]
           };
         });
-        return { cards: scored.sort((a, b) => b.score - a.score).slice(0, limit) };
+        const sorted = scored.sort((a, b) => b.score - a.score);
+        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()
+        });
+        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)
        */
-      computeBacklogPressure(dueCount) {
+      computeBacklogMultiplier(dueCount) {
         if (dueCount <= this.healthyBacklog) {
-          return 0;
+          return 1;
         }
         const excess = dueCount - this.healthyBacklog;
-        const pressure = excess / this.healthyBacklog * (MAX_BACKLOG_PRESSURE / 2);
-        return Math.min(MAX_BACKLOG_PRESSURE, pressure);
+        const multiplier = 1 + excess / this.healthyBacklog * ((MAX_BACKLOG_MULTIPLIER - 1) / 2);
+        return Math.min(MAX_BACKLOG_MULTIPLIER, multiplier);
       }
       /**
        * Compute urgency score for a review card.
@@ -2981,19 +3069,20 @@ var init_srs = __esm({
        *    - 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)
        */
-      computeUrgencyScore(review, now, backlogPressure) {
+      computeUrgencyScore(review, now, backlogMultiplier) {
         const scheduledAt = moment3.utc(review.scheduledAt);
         const due = moment3.utc(review.reviewTime);
         const intervalHours = Math.max(1, due.diff(scheduledAt, "hours"));
@@ -3003,15 +3092,15 @@ var init_srs = __esm({
         const overdueContribution = Math.min(1, Math.max(0, relativeOverdue));
         const urgency = overdueContribution * 0.5 + recencyFactor * 0.5;
         const baseScore = 0.5 + urgency * 0.45;
-        const score = Math.min(1, baseScore + backlogPressure);
+        const score = baseScore * backlogMultiplier;
         const reasonParts = [
           `${Math.round(hoursOverdue)}h overdue`,
           `interval: ${Math.round(intervalHours)}h`,
           `relative: ${relativeOverdue.toFixed(2)}`,
           `recency: ${recencyFactor.toFixed(2)}`
         ];
-        if (backlogPressure > 0) {
-          reasonParts.push(`backlog: +${backlogPressure.toFixed(2)}`);
+        if (backlogMultiplier > 1) {
+          reasonParts.push(`backlog: \xD7${backlogMultiplier.toFixed(2)}`);
         }
         reasonParts.push("review");
         const reason = reasonParts.join(", ");
@@ -4983,6 +5072,68 @@ var init_Pipeline = __esm({
       // ---------------------------------------------------------------------------
       // Card-space diagnostic
       // ---------------------------------------------------------------------------
+      /**
+       * Commit-free forecast: score the user's full card space through the filter
+       * chain and return the cards that are currently *reachable* (score >=
+       * threshold), optionally nudged by caller-supplied hints and/or restricted
+       * to cards the user hasn't seen yet.
+       *
+       * This is a GENERIC primitive — it returns scored, tag-hydrated cards and
+       * stops there. It has no knowledge of any particular tag convention; callers
+       * decide what the surviving cards mean (e.g. filter to their own "intro"
+       * tag family). Nothing is written and no session is started.
+       *
+       * The optional `hints` are the "out-of-band kick": they run through the same
+       * {@link applyHints} path a live replan uses, so the two semantics carry over —
+       *   - `boostTags`/`boostCards` reweight *within* gating (a gated score-0 card
+       *     stays out), and
+       *   - `requireTags`/`requireCards` inject from the full pre-filter pool,
+       *     *bypassing* gating (use when you want a card regardless of reachability).
+       * Note `unseenOnly` is applied LAST, so it can drop a `require`d card that the
+       * user has already seen — pass `unseenOnly: false` if that matters.
+       *
+       * Cost note: like {@link diagnoseCardSpace}, this scans every card through the
+       * filters, so it's heavier than a normal replan. Intended for one-shot
+       * out-of-band use (e.g. a session-end "what's next" snapshot), not the hot path.
+       *
+       * @param opts.hints       Optional ephemeral hints to apply after the filter chain.
+       * @param opts.unseenOnly  Only return cards the user hasn't encountered (default true).
+       * @param opts.threshold   Min score to count as reachable (default 0.10).
+       * @param opts.limit       Optional cap on results (already sorted desc).
+       */
+      async forecast(opts) {
+        const threshold = opts?.threshold ?? 0.1;
+        const unseenOnly = opts?.unseenOnly ?? true;
+        const courseId = this.course.getCourseID();
+        const allCardIds = await this.course.getAllCardIds();
+        let cards = allCardIds.map((cardId) => ({
+          cardId,
+          courseId,
+          score: 1,
+          provenance: []
+        }));
+        cards = await this.hydrateTags(cards);
+        const fullPool = cards.slice();
+        const context = await this.buildContext();
+        for (const filter of this.filters) {
+          cards = await filter.transform(cards, context);
+        }
+        if (opts?.hints) {
+          cards = this.applyHints(cards, opts.hints, fullPool);
+        }
+        cards = cards.filter((c) => c.score >= threshold);
+        if (unseenOnly) {
+          let encountered;
+          try {
+            encountered = new Set(await this.user.getSeenCards(courseId));
+          } catch {
+            encountered = /* @__PURE__ */ new Set();
+          }
+          cards = cards.filter((c) => !encountered.has(c.cardId));
+        }
+        cards.sort((a, b) => b.score - a.score);
+        return opts?.limit ? cards.slice(0, opts.limit) : cards;
+      }
       /**
        * Scan every card in the course through the filter chain and report
        * how many are "well indicated" (score >= threshold) for the current user.
@@ -5247,6 +5398,7 @@ var init_3 = __esm({
       "./Pipeline.ts": () => Promise.resolve().then(() => (init_Pipeline(), Pipeline_exports)),
       "./PipelineAssembler.ts": () => Promise.resolve().then(() => (init_PipelineAssembler(), PipelineAssembler_exports)),
       "./PipelineDebugger.ts": () => Promise.resolve().then(() => (init_PipelineDebugger(), PipelineDebugger_exports)),
+      "./SrsDebugger.ts": () => Promise.resolve().then(() => (init_SrsDebugger(), SrsDebugger_exports)),
       "./defaults.ts": () => Promise.resolve().then(() => (init_defaults(), defaults_exports)),
       "./diversityRerank.ts": () => Promise.resolve().then(() => (init_diversityRerank(), diversityRerank_exports)),
       "./filters/WeightedFilter.ts": () => Promise.resolve().then(() => (init_WeightedFilter(), WeightedFilter_exports)),
@@ -5279,11 +5431,14 @@ __export(navigators_exports, {
   NavigatorRole: () => NavigatorRole,
   NavigatorRoles: () => NavigatorRoles,
   Navigators: () => Navigators,
+  clearSrsBacklogDebug: () => clearSrsBacklogDebug,
   diversityRerank: () => diversityRerank,
+  getActivePipeline: () => getActivePipeline,
   getCardOrigin: () => getCardOrigin,
   getRegisteredNavigator: () => getRegisteredNavigator,
   getRegisteredNavigatorNames: () => getRegisteredNavigatorNames,
   getRegisteredNavigatorRole: () => getRegisteredNavigatorRole,
+  getSrsBacklogDebug: () => getSrsBacklogDebug,
   hasRegisteredNavigator: () => hasRegisteredNavigator,
   initializeNavigatorRegistry: () => initializeNavigatorRegistry,
   isFilter: () => isFilter,
@@ -5365,6 +5520,7 @@ var init_navigators = __esm({
     "use strict";
     init_diversityRerank();
     init_PipelineDebugger();
+    init_SrsDebugger();
     init_logger();
     init_();
     init_2();
@@ -13271,6 +13427,7 @@ mountMixerDebugger();
 // src/study/SessionDebugger.ts
 init_logger();
 init_PipelineDebugger();
+init_SrsDebugger();
 
 // src/study/SessionOverlay.ts
 init_logger();
@@ -13292,8 +13449,7 @@ var lastSnapshot = null;
 var copyFlashUntil = 0;
 var minified = false;
 var expanded = {
-  reviewQ: false,
-  newQ: false,
+  supplyQ: false,
   failedQ: false,
   drawn: false
 };
@@ -13362,7 +13518,7 @@ function render() {
     attachHandlers();
     return;
   }
-  overlayEl.innerHTML = headerHtml() + replanHtml(s) + metaHtml(s) + hintsHtml(s.sessionHints) + queueHtml("reviewQ", "reviewQ", s.reviewQ) + queueHtml("newQ", "newQ", s.newQ) + queueHtml("failedQ", "failedQ", s.failedQ) + drawnHtml("drawn", s.drawnCards);
+  overlayEl.innerHTML = headerHtml() + replanHtml(s) + metaHtml(s) + hintsHtml(s.sessionHints) + backlogHtml(s.reviewBacklog) + queueHtml("supplyQ", "supplyQ", s.supplyQ) + queueHtml("failedQ", "failedQ", s.failedQ) + drawnHtml("drawn", s.drawnCards);
   attachHandlers();
 }
 function attachHandlers() {
@@ -13454,6 +13610,29 @@ function hintsHtml(h) {
   const body = parts.length ? parts.map((p) => `<div style="margin-left:6px">${p}</div>`).join("") : `<div style="margin-left:6px;opacity:.6">none</div>`;
   return `<div style="margin-bottom:6px"><div style="color:#86efac">sessionHints</div>${body}</div>`;
 }
+function backlogHtml(backlog) {
+  if (!backlog.length) return "";
+  const rows = backlog.map((b) => {
+    const maxed = b.backlogMultiplier >= b.maxBacklogMultiplier - 1e-9;
+    const multColor = b.backlogMultiplier <= 1 ? "#86efac" : maxed ? "#fca5a5" : "#fcd34d";
+    const headroom = maxed ? "maxed \u2014 boosts decide order until they relax" : b.backlogMultiplier > 1 ? "climbing as backlog grows" : "healthy \u2014 no pressure";
+    const top = b.topReviewScore !== null ? b.topReviewScore.toFixed(2) : "\u2014";
+    const next = b.nextDueIn ? ` <span style="opacity:.6">\xB7 next due ${esc(b.nextDueIn)}</span>` : "";
+    return `<div style="margin-left:6px"><span style="opacity:.7">${esc(b.courseId.slice(0, 8))}</span> due ${b.dueNow}/${b.scheduledTotal} <span style="opacity:.6">(healthy ${b.healthyBacklog})</span>${next}<div style="margin-left:6px">pressure <span style="color:${multColor}">\xD7${b.backlogMultiplier.toFixed(2)}/${b.maxBacklogMultiplier.toFixed(2)}</span> <span style="opacity:.6">${headroom} \xB7 top review ${top}</span></div></div>`;
+  }).join("");
+  return `<div style="margin-bottom:6px"><div style="color:#93c5fd">review backpressure</div>${rows}</div>`;
+}
+function fmtScore(score) {
+  if (score === void 0) return "";
+  if (!Number.isFinite(score)) return "REQ";
+  return score.toFixed(2);
+}
+function queueItemHtml(item) {
+  const tagColor = item.origin === "review" ? "#93c5fd" : "#fcd34d";
+  const score = fmtScore(item.score);
+  const label = `${item.origin === "review" ? "r" : "n"}${score ? " " + score : ""}`;
+  return `${esc(item.cardID)}<span style="color:${tagColor};opacity:.85"> [${label}]</span>`;
+}
 function queueHtml(key, label, q) {
   const collapsible = q.length > INLINE_THRESHOLD;
   const isOpen = collapsible && expanded[key];
@@ -13468,7 +13647,7 @@ function queueHtml(key, label, q) {
   const shown = isOpen ? q.cards : q.cards.slice(0, INLINE_THRESHOLD);
   const hiddenCount = q.length - shown.length;
   const listMarginBottom = collapsible ? 2 : 6;
-  let body = `<ol style="margin:2px 0 ${listMarginBottom}px 0;padding-left:20px">` + shown.map((c) => `<li style="white-space:nowrap">${esc(c)}</li>`).join("") + `</ol>`;
+  let body = `<ol style="margin:2px 0 ${listMarginBottom}px 0;padding-left:20px">` + shown.map((c) => `<li style="white-space:nowrap">${queueItemHtml(c)}</li>`).join("") + `</ol>`;
   if (collapsible) {
     const footer = isOpen ? "\u25BE show less" : `\u2026 +${hiddenCount} more`;
     body += `<div data-q="${key}" style="cursor:pointer;margin:0 0 6px 20px;opacity:.6">${footer}</div>`;
@@ -13531,13 +13710,29 @@ function snapshotToText(s) {
     if (h.excludeCards?.length) hintParts.push(`  excludeCards: ${h.excludeCards.join(", ")}`);
   }
   lines.push(hintParts.length ? hintParts.join("\n") : "  none");
+  if (s.reviewBacklog.length) {
+    lines.push("");
+    lines.push("review backpressure:");
+    for (const b of s.reviewBacklog) {
+      const maxed = b.backlogMultiplier >= b.maxBacklogMultiplier - 1e-9;
+      const headroom = maxed ? "maxed (boosts decide order)" : b.backlogMultiplier > 1 ? "climbing" : "healthy";
+      const top = b.topReviewScore !== null ? b.topReviewScore.toFixed(2) : "\u2014";
+      const next = b.nextDueIn ? `, next due ${b.nextDueIn}` : "";
+      lines.push(
+        `  ${b.courseId.slice(0, 8)}: due ${b.dueNow}/${b.scheduledTotal} (healthy ${b.healthyBacklog})${next}; pressure \xD7${b.backlogMultiplier.toFixed(2)}/${b.maxBacklogMultiplier.toFixed(2)} ${headroom}; top review ${top}`
+      );
+    }
+  }
   const queueText = (label, q) => {
     lines.push("");
     lines.push(`${label}: ${q.length} (drawn ${q.dequeueCount})`);
-    q.cards.forEach((c, i) => lines.push(`  ${i + 1}. ${c}`));
+    q.cards.forEach((c, i) => {
+      const score = fmtScore(c.score);
+      const tag = `${c.origin === "review" ? "r" : "n"}${score ? " " + score : ""}`;
+      lines.push(`  ${i + 1}. ${c.cardID} [${tag}]`);
+    });
   };
-  queueText("reviewQ", s.reviewQ);
-  queueText("newQ", s.newQ);
+  queueText("supplyQ", s.supplyQ);
   queueText("failedQ", s.failedQ);
   lines.push("");
   lines.push(`drawn: ${s.drawnCards.length}`);
@@ -13562,16 +13757,16 @@ function esc(value) {
 var activeSession = null;
 var sessionHistory = [];
 var MAX_HISTORY = 5;
-function startSessionTracking(reviewQLength, newQLength, failedQLength) {
+function startSessionTracking(supplyQLength, failedQLength) {
   clearRunHistory();
+  clearSrsBacklogDebug();
   const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   activeSession = {
     sessionId,
     startTime: /* @__PURE__ */ new Date(),
     initialQueues: {
       timestamp: /* @__PURE__ */ new Date(),
-      reviewQLength,
-      newQLength,
+      supplyQLength,
       failedQLength
     },
     presentations: [],
@@ -13595,17 +13790,15 @@ function recordCardPresentation(cardId, courseId, courseName, origin, queueSourc
     score
   });
 }
-function snapshotQueues(reviewQLength, newQLength, failedQLength, reviewQNext3, newQNext3) {
+function snapshotQueues(supplyQLength, failedQLength, supplyQNext3) {
   if (!activeSession) {
     return;
   }
   activeSession.queueSnapshots.push({
     timestamp: /* @__PURE__ */ new Date(),
-    reviewQLength,
-    newQLength,
+    supplyQLength,
     failedQLength,
-    reviewQNext3,
-    newQNext3
+    supplyQNext3
   });
 }
 function endSessionTracking() {
@@ -13627,13 +13820,9 @@ function showCurrentQueue() {
   }
   const latest = activeSession.queueSnapshots[activeSession.queueSnapshots.length - 1] || activeSession.initialQueues;
   console.group("\u{1F4CA} Current Queue State");
-  logger.info(`Review Queue: ${latest.reviewQLength} cards`);
-  if (latest.reviewQNext3 && latest.reviewQNext3.length > 0) {
-    logger.info(`  Next: ${latest.reviewQNext3.join(", ")}`);
-  }
-  logger.info(`New Queue: ${latest.newQLength} cards`);
-  if (latest.newQNext3 && latest.newQNext3.length > 0) {
-    logger.info(`  Next: ${latest.newQNext3.join(", ")}`);
+  logger.info(`Supply Queue: ${latest.supplyQLength} cards`);
+  if (latest.supplyQNext3 && latest.supplyQNext3.length > 0) {
+    logger.info(`  Next: ${latest.supplyQNext3.join(", ")}`);
   }
   logger.info(`Failed Queue: ${latest.failedQLength} cards`);
   console.groupEnd();
@@ -13850,15 +14039,6 @@ var SessionController = class _SessionController extends Loggable {
    * Individual replans can override via `ReplanOptions.limit`.
    */
   _defaultBatchLimit = 20;
-  /**
-   * Maximum number of reviews enqueued at session start. Reviews live
-   * outside the replan flow — the queue drains via consumption and is
-   * not refilled mid-session. The session timer caps total review
-   * exposure, so overfilling here is intentional. Default is generous
-   * to accommodate Anki-style power users with hundreds of due reviews;
-   * apps targeting nimbler sessions should override via constructor.
-   */
-  _initialReviewCap = 200;
   sources;
   // dataLayer and getViewComponent now injected into CardHydrationService
   _sessionRecord = [];
@@ -13867,10 +14047,28 @@ var SessionController = class _SessionController extends Loggable {
   }
   // Session card stores
   _currentCard = null;
-  reviewQ = new ItemQueue();
-  newQ = new ItemQueue();
+  /**
+   * The single supply queue: `new` + `review` items interleaved in pipeline
+   * rank order (the mixer's score-ordered, source-interleaved output, with
+   * `+INF` required cards floated to the front). Drawn front-to-back; reviews
+   * and new compete on one cross-comparable scale rather than being re-mixed
+   * by a probability gate. Replaced/re-ranked wholesale on replan. See
+   * `docs/decision-single-supply-queue.md`.
+   */
+  supplyQ = new ItemQueue();
   failedQ = new ItemQueue();
   // END   Session card stores
+  /**
+   * Supply draws since the last failed-queue *event* (a failed draw, or a card
+   * entering failedQ on failure). Drives the light steady failed-interleave
+   * (§7): after this many consecutive supply draws, a pending failed card is
+   * drawn so remediation doesn't starve mid-session. Incremented on each supply
+   * draw; reset to 0 both when a failed card is drawn AND when one is added to
+   * failedQ — the latter gives a just-failed card spacing instead of an instant
+   * retry (the counter would otherwise already be ≥ threshold from the preceding
+   * supply run).
+   */
+  _supplyDrawsSinceFailed = 0;
   /**
    * Promise tracking a currently in-progress replan, or null if idle.
    * Used by nextCard() to await completion before drawing from queues.
@@ -13884,8 +14082,8 @@ var SessionController = class _SessionController extends Loggable {
    */
   _activeReplanLabel = null;
   /**
-   * Number of well-indicated new cards remaining before the queue
-   * degrades to poorly-indicated content. Decremented on each newQ
+   * Number of well-indicated supply cards remaining before the queue
+   * degrades to poorly-indicated content. Decremented on each supplyQ
    * draw; when it hits 0, a replan is triggered automatically
    * (user state has changed from completing good cards).
    */
@@ -13894,7 +14092,7 @@ var SessionController = class _SessionController extends Loggable {
    * When true, suppresses the quality-based auto-replan trigger in
    * nextCard(). Set after a burst replan (small limit) to prevent the
    * auto-replan from clobbering the burst cards before they're consumed.
-   * Cleared when the depletion-triggered replan fires (newQ exhausted).
+   * Cleared when the depletion-triggered replan fires (supplyQ exhausted).
    */
   _suppressQualityReplan = false;
   /**
@@ -13923,13 +14121,15 @@ var SessionController = class _SessionController extends Loggable {
    * a draw the instant it happens — earlier than `_sessionRecord`, which only
    * lands once the card is *responded to*.
    *
-   * Used to keep already-served cards out of newQ on every (re)plan: a `new`
-   * card shown once must never re-enter newQ this session. This is the general
-   * guard against re-presentation — including the case where a replan in flight
-   * captured a now-drawn card (e.g. a +INF require-injected follow-up the
-   * depletion prefetch grabbed just before it was drawn). Reviews/failed cards
-   * legitimately recur and are tracked by their own queues, so this only gates
-   * `new`-origin candidates.
+   * Used to keep already-served cards out of supplyQ on every (re)plan, across
+   * ALL origins: a `new` card shown once must never re-enter, and once replans
+   * re-pull reviews, an answered/in-flight review must not re-enter the supply
+   * before its SRS reschedule clears the due-window (the review-loop guard,
+   * decision doc §4). This is the general guard against re-presentation —
+   * including the case where a replan in flight captured a now-drawn card (e.g.
+   * a +INF require-injected follow-up the depletion prefetch grabbed just before
+   * it was drawn). failedQ is separate and controller-owned, so failed cards
+   * legitimately recur there without being gated here.
    */
   _servedCardIds = /* @__PURE__ */ new Set();
   /**
@@ -13954,14 +14154,12 @@ var SessionController = class _SessionController extends Loggable {
     return this._minCardsGuarantee > 0;
   }
   get report() {
-    const reviewCount = this.reviewQ.dequeueCount;
-    const newCount = this.newQ.dequeueCount;
-    const reviewWord = reviewCount === 1 ? "review" : "reviews";
-    const newCardWord = newCount === 1 ? "new card" : "new cards";
-    return `${reviewCount} ${reviewWord}, ${newCount} ${newCardWord}`;
+    const supplyCount = this.supplyQ.dequeueCount;
+    const supplyWord = supplyCount === 1 ? "card" : "cards";
+    return `${supplyCount} supply ${supplyWord} drawn`;
   }
   get detailedReport() {
-    return this.newQ.toString + "\n" + this.reviewQ.toString + "\n" + this.failedQ.toString;
+    return this.supplyQ.toString + "\n" + this.failedQ.toString;
   }
   // @ts-expect-error NodeJS.Timeout type not available in browser context
   _intervalHandle;
@@ -13972,11 +14170,9 @@ var SessionController = class _SessionController extends Loggable {
    * @param getViewComponent - Function to resolve view components
    * @param mixer - Optional source mixer strategy (defaults to QuotaRoundRobinMixer)
    * @param options - Optional session-level configuration
-   * @param options.defaultBatchLimit - Default pipeline batch size (default: 20).
+   * @param options.defaultBatchLimit - Default supply working-set size (default: 20).
    *   Smaller values for newer users cause more frequent replans, keeping plans
    *   aligned with rapidly-changing user state.
-   * @param options.initialReviewCap - Max reviews loaded at session start (default: 200).
-   *   Applied only on initial planning; replans do not refill the review queue.
    */
   constructor(sources, time, dataLayer, getViewComponent, mixer, options) {
     super();
@@ -13999,17 +14195,13 @@ var SessionController = class _SessionController extends Loggable {
     if (options?.defaultBatchLimit !== void 0) {
       this._defaultBatchLimit = options.defaultBatchLimit;
     }
-    if (options?.initialReviewCap !== void 0) {
-      this._initialReviewCap = options.initialReviewCap;
-    }
     if (options?.outcomeObservers?.length) {
       this._outcomeObservers = [...options.outcomeObservers];
     }
     this.log(`Session constructed:
     startTime: ${this.startTime}
     endTime: ${this.endTime}
-    defaultBatchLimit: ${this._defaultBatchLimit}
-    initialReviewCap: ${this._initialReviewCap}`);
+    defaultBatchLimit: ${this._defaultBatchLimit}`);
     registerActiveController(this);
   }
   tick() {
@@ -14043,15 +14235,6 @@ var SessionController = class _SessionController extends Loggable {
     this.log(`Failed card cleanup estimate: ${Math.round(ret)}`);
     return ret;
   }
-  /**
-   * Extremely rough, conservative, estimate of amound of time to complete
-   * all scheduled reviews
-   */
-  estimateReviewTime() {
-    const ret = 5 * this.reviewQ.length;
-    this.log(`Review card time estimate: ${ret}`);
-    return ret;
-  }
   async prepareSession() {
     if (this.sources.some((s) => typeof s.getWeightedCards !== "function")) {
       throw new Error(
@@ -14066,15 +14249,15 @@ var SessionController = class _SessionController extends Loggable {
       );
     }
     await this.hydrationService.ensureHydratedCards();
-    startSessionTracking(this.reviewQ.length, this.newQ.length, this.failedQ.length);
+    startSessionTracking(this.supplyQ.length, this.failedQ.length);
     this._intervalHandle = setInterval(() => {
       this.tick();
     }, 1e3);
   }
   /**
    * Request a mid-session replan. Re-runs the pipeline with current user state
-   * and atomically replaces the newQ contents. Safe to call at any time during
-   * a session.
+   * and atomically replaces (or merges into) the supplyQ contents. Safe to call
+   * at any time during a session.
    *
    * Concurrency policy:
    * - Two unhinted auto-replans never run in parallel; the second coalesces
@@ -14088,7 +14271,8 @@ var SessionController = class _SessionController extends Loggable {
    *   results (e.g. surfacing another gpc-intro card right after one
    *   completed, skipping the prescribed `c-wst-*` follow-up).
    *
-   * Does NOT affect reviewQ or failedQ.
+   * Re-pulls and re-ranks the whole supply (including reviews); does NOT affect
+   * failedQ (controller-owned remediation).
    *
    * If nextCard() is called while a replan is in flight, it will automatically
    * await the replan before drawing from queues, ensuring the user always sees
@@ -14154,7 +14338,7 @@ var SessionController = class _SessionController extends Loggable {
    * excludeCards happen at *invocation* time, not at *queue* time. For a
    * queued replan that means excludes reflect the state after the prior
    * replan landed — which is what we want, since the prior replan's
-   * newQ.peek(0) is the imminent draw we need to exclude.
+   * supplyQ.peek(0) is the imminent draw we need to exclude.
    */
   async _runReplan(opts) {
     this._activeReplanLabel = opts.label ?? "(auto)";
@@ -14167,8 +14351,8 @@ var SessionController = class _SessionController extends Loggable {
     for (const rec of this._sessionRecord) {
       excludeSet.add(rec.card.card_id);
     }
-    if (this.newQ.length > 0) {
-      excludeSet.add(this.newQ.peek(0).cardID);
+    if (this.supplyQ.length > 0) {
+      excludeSet.add(this.supplyQ.peek(0).cardID);
     }
     hints.excludeCards = [...excludeSet];
     if (opts.sessionHints !== void 0) {
@@ -14229,7 +14413,13 @@ var SessionController = class _SessionController extends Loggable {
     const describe = (q) => {
       const cards = [];
       for (let i = 0; i < q.length; i++) {
-        cards.push(q.peek(i).cardID);
+        const item = q.peek(i);
+        cards.push({
+          cardID: item.cardID,
+          status: item.status,
+          origin: isReview(item) ? "review" : "new",
+          score: item.score
+        });
       }
       return { length: q.length, dequeueCount: q.dequeueCount, cards };
     };
@@ -14252,9 +14442,9 @@ var SessionController = class _SessionController extends Loggable {
       sessionHints: this._sessionHints,
       replanActive: this._replanPromise !== null,
       replanLabel: this._activeReplanLabel,
-      reviewQ: describe(this.reviewQ),
-      newQ: describe(this.newQ),
+      supplyQ: describe(this.supplyQ),
       failedQ: describe(this.failedQ),
+      reviewBacklog: getSrsBacklogDebug(),
       drawnCards
     };
   }
@@ -14374,7 +14564,7 @@ var SessionController = class _SessionController extends Loggable {
    */
   static WELL_INDICATED_SCORE = 0.1;
   /**
-   * newQ length at or below which the opportunistic depletion-prefetch
+   * supplyQ length at or below which the opportunistic depletion-prefetch
    * fires. Sets the lead time available for the background replan to land
    * before the user actually empties the queue and falls into the
    * (synchronous) wedge-breaker path.
@@ -14387,7 +14577,7 @@ var SessionController = class _SessionController extends Loggable {
    */
   static DEPLETION_PREFETCH_THRESHOLD = 3;
   /**
-   * Internal replan execution. Runs the pipeline, builds a new newQ,
+   * Internal replan execution. Runs the pipeline, rebuilds the supplyQ,
    * atomically swaps it in, and triggers hydration for the new contents.
    *
    * If the initial replan produces fewer than MIN_WELL_INDICATED cards that
@@ -14416,8 +14606,8 @@ var SessionController = class _SessionController extends Loggable {
     }
     await this.hydrationService.ensureHydratedCards();
     const labelTag = opts.label ? ` [${opts.label}]` : "";
-    this.log(`Replan complete${labelTag}: newQ now has ${this.newQ.length} cards (mode=${mode})`);
-    snapshotQueues(this.reviewQ.length, this.newQ.length, this.failedQ.length);
+    this.log(`Replan complete${labelTag}: supplyQ now has ${this.supplyQ.length} cards (mode=${mode})`);
+    snapshotQueues(this.supplyQ.length, this.failedQ.length);
   }
   addTime(seconds) {
     this.endTime = new Date(this.endTime.valueOf() + 1e3 * seconds);
@@ -14426,10 +14616,10 @@ var SessionController = class _SessionController extends Loggable {
     return this.failedQ.length;
   }
   toString() {
-    return `Session: ${this.reviewQ.length} Reviews, ${this.newQ.length} New, ${this.failedQ.length} failed`;
+    return `Session: ${this.supplyQ.length} supply, ${this.failedQ.length} failed`;
   }
   reportString() {
-    return `${this.reviewQ.dequeueCount} Reviews, ${this.newQ.dequeueCount} New, ${this.failedQ.dequeueCount} failed`;
+    return `${this.supplyQ.dequeueCount} supply, ${this.failedQ.dequeueCount} failed`;
   }
   /**
    * Returns debug information about the current session state.
@@ -14446,7 +14636,8 @@ var SessionController = class _SessionController extends Loggable {
         items.push({
           courseID: item.courseID || "unknown",
           cardID: item.cardID || "unknown",
-          status: item.status || "unknown"
+          status: item.status || "unknown",
+          score: item.score
         });
       }
       return items;
@@ -14456,15 +14647,10 @@ var SessionController = class _SessionController extends Loggable {
         mode: supportsWeightedCards ? "weighted" : "legacy",
         description: supportsWeightedCards ? "Using getWeightedCards() API with scored candidates" : "ERROR: getWeightedCards() not a function."
       },
-      reviewQueue: {
-        length: this.reviewQ.length,
-        dequeueCount: this.reviewQ.dequeueCount,
-        items: extractQueueItems(this.reviewQ)
-      },
-      newQueue: {
-        length: this.newQ.length,
-        dequeueCount: this.newQ.dequeueCount,
-        items: extractQueueItems(this.newQ)
+      supplyQueue: {
+        length: this.supplyQ.length,
+        dequeueCount: this.supplyQ.dequeueCount,
+        items: extractQueueItems(this.supplyQ)
       },
       failedQueue: {
         length: this.failedQ.length,
@@ -14484,30 +14670,29 @@ var SessionController = class _SessionController extends Loggable {
     };
   }
   /**
-   * Fetch content using the getWeightedCards API and mix across sources.
+   * Fetch weighted content from all sources, mix across sources, and populate
+   * the single supply queue in pipeline rank order.
    *
-   * This method:
-   * 1. Fetches weighted cards from each source
-   * 2. Fetches full review data (we need ScheduledCard fields for queue)
-   * 3. Uses SourceMixer to balance content across sources
-   * 4. Populates review and new card queues with mixed results
-   */
-  /**
-   * Fetch weighted content from all sources and populate session queues.
+   * Reviews and new cards compete on one cross-comparable scale (SRS 0.5–1.0
+   * w/ backlog pressure vs ELO 0.0–1.0) — there is no origin split and no
+   * second mixer. The working set is `supplyLimit` cards (the top of the mixed
+   * ranking, plus any `+INF` required cards floated to the front); replans
+   * re-pull and re-rank the whole supply, so a heavy review backlog surfaces as
+   * a refreshed top-ranked working set rather than a frozen 200-card snapshot.
    *
    * @param options.replan - If true, this is a mid-session replan rather than
-   *   initial session setup. Skips review queue population (avoiding duplicates),
-   *   atomically replaces newQ contents, and treats empty results as non-fatal.
-   * @param options.additive - If true (replan only), merge new high-quality
-   *   candidates into the front of the existing newQ instead of replacing it.
+   *   initial session setup. Atomically replaces supplyQ contents and treats
+   *   empty results as non-fatal.
+   * @param options.additive - If true (replan only), merge high-quality
+   *   candidates into the front of the existing supplyQ instead of replacing it.
    * @returns Number of "well-indicated" cards (passed all hierarchy filters)
    *   in the new content. Returns -1 if no content was loaded.
    */
   async getWeightedContent(options) {
     const replan = options?.replan ?? false;
     const additive = options?.additive ?? false;
-    const newLimit = options?.limit ?? this._defaultBatchLimit;
-    const fetchLimit = replan ? newLimit : newLimit + this._initialReviewCap;
+    const supplyLimit = options?.limit ?? this._defaultBatchLimit;
+    const fetchLimit = supplyLimit;
     if (!replan) {
       this._applyHintsToSources();
     }
@@ -14529,7 +14714,7 @@ var SessionController = class _SessionController extends Loggable {
     }
     if (batches.length === 0) {
       if (replan) {
-        this.log("Replan: no content from any source, keeping existing newQ");
+        this.log("Replan: no content from any source, keeping existing supplyQ");
         return -1;
       }
       throw new Error(
@@ -14563,64 +14748,59 @@ var SessionController = class _SessionController extends Loggable {
       quotaPerSource,
       mixedWeighted
     );
-    const reviewWeighted = mixedWeighted.filter((w) => getCardOrigin(w) === "review").slice(0, this._initialReviewCap);
-    const newCandidates = mixedWeighted.filter(
-      (w) => getCardOrigin(w) === "new" && !this._servedCardIds.has(w.cardId)
-    );
-    const mandatoryWeighted = newCandidates.filter((w) => w.score === Number.POSITIVE_INFINITY);
-    const optionalWeighted = newCandidates.filter((w) => w.score !== Number.POSITIVE_INFINITY);
-    const newWeighted = [
+    const candidates = mixedWeighted.filter((w) => !this._servedCardIds.has(w.cardId));
+    const mandatoryWeighted = candidates.filter((w) => w.score === Number.POSITIVE_INFINITY);
+    const optionalWeighted = candidates.filter((w) => w.score !== Number.POSITIVE_INFINITY);
+    const supplyWeighted = [
       ...mandatoryWeighted,
-      ...optionalWeighted.slice(0, Math.max(0, newLimit - mandatoryWeighted.length))
+      ...optionalWeighted.slice(0, Math.max(0, supplyLimit - mandatoryWeighted.length))
     ];
     const mandatoryIds = new Set(mandatoryWeighted.map((w) => w.cardId));
-    logger.debug(`[reviews] got ${reviewWeighted.length} reviews from mixer`);
-    let report = replan ? "Replan content:\n" : "Mixed content session created with:\n";
-    if (!replan) {
-      for (const w of reviewWeighted) {
-        const reviewItem = {
-          cardID: w.cardId,
-          courseID: w.courseId,
-          contentSourceType: "course",
-          contentSourceID: w.courseId,
-          reviewID: w.reviewID,
-          status: "review"
-        };
-        this.reviewQ.add(reviewItem, reviewItem.cardID);
-        report += `Review: ${w.courseId}::${w.cardId} (score: ${w.score.toFixed(2)})
-`;
-      }
-    }
-    const wellIndicated = newWeighted.filter(
+    const wellIndicated = supplyWeighted.filter(
       (w) => w.score >= _SessionController.WELL_INDICATED_SCORE
     ).length;
-    const newItems = [];
-    for (const w of newWeighted) {
-      const newItem = {
-        cardID: w.cardId,
-        courseID: w.courseId,
-        contentSourceType: "course",
-        contentSourceID: w.courseId,
-        status: "new"
-      };
-      newItems.push(newItem);
-      report += `New: ${w.courseId}::${w.cardId} (score: ${w.score.toFixed(2)})
+    let report = replan ? "Replan content:\n" : "Mixed content session created with:\n";
+    const supplyItems = supplyWeighted.map((w) => {
+      const origin = getCardOrigin(w);
+      const scoreStr = Number.isFinite(w.score) ? w.score.toFixed(2) : "+INF";
+      report += `${origin === "review" ? "Review" : "New"}: ${w.courseId}::${w.cardId} (score: ${scoreStr})
 `;
-    }
+      return this._buildSupplyItem(w, origin);
+    });
     if (additive) {
-      const added = this.newQ.mergeToFront(newItems, (item) => item.cardID, mandatoryIds);
-      report += `Additive merge: ${added} new cards added to front of newQ
+      const added = this.supplyQ.mergeToFront(supplyItems, (item) => item.cardID, mandatoryIds);
+      report += `Additive merge: ${added} cards added to front of supplyQ
 `;
     } else if (replan) {
-      this.newQ.replaceAll(newItems, (item) => item.cardID);
+      this.supplyQ.replaceAll(supplyItems, (item) => item.cardID);
     } else {
-      for (const item of newItems) {
-        this.newQ.add(item, item.cardID);
+      for (const item of supplyItems) {
+        this.supplyQ.add(item, item.cardID);
       }
     }
     this.log(report);
     return wellIndicated;
   }
+  /**
+   * Build a supply item from a weighted candidate. Review-origin cards carry
+   * their `reviewID` so SRS outcome tracking and re-presentation work; new
+   * cards do not. `score` is carried on both for the debug overlay.
+   */
+  _buildSupplyItem(w, origin = getCardOrigin(w)) {
+    const base = {
+      cardID: w.cardId,
+      courseID: w.courseId,
+      contentSourceType: "course",
+      contentSourceID: w.courseId,
+      score: w.score
+    };
+    if (origin === "review") {
+      const reviewItem = { ...base, status: "review", reviewID: w.reviewID };
+      return reviewItem;
+    }
+    const newItem = { ...base, status: "new" };
+    return newItem;
+  }
   /**
    * Returns items that should be pre-hydrated.
    * Deterministic: top N items from each queue to ensure coverage.
@@ -14628,71 +14808,73 @@ var SessionController = class _SessionController extends Loggable {
    */
   _getItemsToHydrate() {
     const items = [];
-    const ITEMS_PER_QUEUE = 2;
-    for (let i = 0; i < Math.min(ITEMS_PER_QUEUE, this.reviewQ.length); i++) {
-      items.push(this.reviewQ.peek(i));
-    }
-    for (let i = 0; i < Math.min(ITEMS_PER_QUEUE, this.newQ.length); i++) {
-      items.push(this.newQ.peek(i));
+    const SUPPLY_PREFETCH = 3;
+    const FAILED_PREFETCH = 2;
+    for (let i = 0; i < Math.min(SUPPLY_PREFETCH, this.supplyQ.length); i++) {
+      items.push(this.supplyQ.peek(i));
     }
-    for (let i = 0; i < Math.min(ITEMS_PER_QUEUE, this.failedQ.length); i++) {
+    for (let i = 0; i < Math.min(FAILED_PREFETCH, this.failedQ.length); i++) {
       items.push(this.failedQ.peek(i));
     }
     return items;
   }
   /**
    * Selects the next item to present to the user.
-   * Nondeterministic: uses probability to balance between queues based on session state.
+   *
+   * The supplyQ is already rank-ordered (the pipeline + mixer did the mixing,
+   * with `+INF` required cards floated to the front), so the primary path is a
+   * deterministic front-to-back draw — no second new-vs-review mixer. The only
+   * remaining decisions are (a) when the session ends and (b) when to interleave
+   * a remediation card from failedQ. See decision doc §2/§3/§7.
    */
   _selectNextItemToHydrate() {
-    const choice = Math.random();
-    let newBound = 0.1;
-    let reviewBound = 0.75;
-    if (this.reviewQ.length === 0 && this.failedQ.length === 0 && this.newQ.length === 0) {
+    if (this.supplyQ.length === 0 && this.failedQ.length === 0) {
       return null;
     }
     if (this._secondsRemaining < 2 && this.failedQ.length === 0 && this._minCardsGuarantee <= 0) {
       return null;
     }
     if (this._secondsRemaining <= 0 && this._minCardsGuarantee <= 0) {
-      if (this.failedQ.length > 0) {
-        return this.failedQ.peek(0);
-      } else {
-        return null;
-      }
+      return this.failedQ.length > 0 ? this.failedQ.peek(0) : null;
     }
-    if (this.newQ.dequeueCount < this.sources.length && this.newQ.length) {
-      return this.newQ.peek(0);
+    const supplyTop = this.supplyQ.length > 0 ? this.supplyQ.peek(0) : null;
+    if (this._minCardsGuarantee > 0 && supplyTop) {
+      return supplyTop;
     }
-    const cleanupTime = this.estimateCleanupTime();
-    const reviewTime = this.estimateReviewTime();
-    const availableTime = this._secondsRemaining - (cleanupTime + reviewTime);
-    if (availableTime > 20) {
-      newBound = 0.5;
-      reviewBound = 0.9;
-    } else if (this._secondsRemaining - cleanupTime > 20) {
-      newBound = 0.05;
-      reviewBound = 0.9;
-    } else {
-      newBound = 0.01;
-      reviewBound = 0.1;
-    }
-    if (this.failedQ.length === 0) {
-      reviewBound = 1;
+    if (this.failedQ.length > 0 && this._shouldInterleaveFailed(supplyTop !== null)) {
+      return this.failedQ.peek(0);
     }
-    if (this.reviewQ.length === 0) {
-      newBound = reviewBound;
+    if (supplyTop) {
+      return supplyTop;
     }
-    if (choice < newBound && this.newQ.length) {
-      return this.newQ.peek(0);
-    } else if (choice < reviewBound && this.reviewQ.length) {
-      return this.reviewQ.peek(0);
-    } else if (this.failedQ.length) {
+    if (this.failedQ.length > 0) {
       return this.failedQ.peek(0);
-    } else {
-      this.log(`No more cards available for the session!`);
-      return null;
     }
+    this.log(`No more cards available for the session!`);
+    return null;
+  }
+  /** Supply draws between forced failed-queue interleaves (light steady cadence). */
+  static FAILED_INTERLEAVE_EVERY = 4;
+  /**
+   * Slack (seconds) below which the endgame failed-pressure kicks in: when the
+   * time left after clearing remediation drops under this, bias hard to failed
+   * so the session doesn't end with un-cleared remediation. Mirrors the old
+   * `availableTime > 20` ladder thresholds.
+   */
+  static FAILED_ENDGAME_SLACK_SECONDS = 20;
+  /**
+   * Whether to interleave a failed (remediation) card now instead of drawing
+   * the supply head. Replaces the old `newBound`/`reviewBound` probability
+   * ladder's failed path (decision doc §7).
+   *
+   * @param supplyAvailable - whether supplyQ has a card to draw instead.
+   */
+  _shouldInterleaveFailed(supplyAvailable) {
+    if (this.failedQ.length === 0) return false;
+    if (!supplyAvailable) return true;
+    const availableTime = this._secondsRemaining - this.estimateCleanupTime();
+    if (availableTime <= _SessionController.FAILED_ENDGAME_SLACK_SECONDS) return true;
+    return this._supplyDrawsSinceFailed >= _SessionController.FAILED_INTERLEAVE_EVERY;
   }
   async nextCard(action = "dismiss-success") {
     this.dismissCurrentCard(action);
@@ -14700,22 +14882,21 @@ var SessionController = class _SessionController extends Loggable {
       this._minCardsGuarantee--;
       this.log(`[CardGuarantee] ${this._minCardsGuarantee} guaranteed cards remaining`);
     }
-    if (this._replanPromise && this.newQ.length === 0 && this.reviewQ.length === 0 && this.failedQ.length === 0) {
+    if (this._replanPromise && this.supplyQ.length === 0 && this.failedQ.length === 0) {
       this.log("nextCard: queues empty, awaiting in-flight replan before drawing");
       await this._replanPromise;
     }
-    if (this.newQ.length <= _SessionController.DEPLETION_PREFETCH_THRESHOLD && this._secondsRemaining > 0 && !this._replanPromise) {
+    if (this.supplyQ.length <= _SessionController.DEPLETION_PREFETCH_THRESHOLD && this._secondsRemaining > 0 && !this._replanPromise) {
       this._suppressQualityReplan = false;
-      const otherContent = this.reviewQ.length + this.failedQ.length;
       this.log(
-        `[AutoReplan:depletion] newQ has ${this.newQ.length} card(s) (${otherContent} in other queues) with ${this._secondsRemaining}s remaining. Triggering background replan.`
+        `[AutoReplan:depletion] supplyQ has ${this.supplyQ.length} card(s) (${this.failedQ.length} failed pending) with ${this._secondsRemaining}s remaining. Triggering background replan.`
       );
       void this.requestReplan({ label: "auto:depletion", mode: "merge" });
     }
     const REPLAN_BUFFER = 3;
-    if (!this._suppressQualityReplan && this._wellIndicatedRemaining <= REPLAN_BUFFER && this.newQ.length > 0 && !this._replanPromise) {
+    if (!this._suppressQualityReplan && this._wellIndicatedRemaining <= REPLAN_BUFFER && this.supplyQ.length > 0 && !this._replanPromise) {
       this.log(
-        `[AutoReplan:quality] ${this._wellIndicatedRemaining} well-indicated cards remaining (newQ: ${this.newQ.length}). Triggering background replan.`
+        `[AutoReplan:quality] ${this._wellIndicatedRemaining} well-indicated cards remaining (supplyQ: ${this.supplyQ.length}). Triggering background replan.`
       );
       void this.requestReplan({ label: "auto:quality" });
     }
@@ -14727,12 +14908,12 @@ var SessionController = class _SessionController extends Loggable {
     const WEDGE_MAX_EMPTY_STREAK = 3;
     const WEDGE_BACKOFF_MS = 250;
     let wedgeEmptyStreak = 0;
-    while (this._secondsRemaining > 0 && this.newQ.length === 0 && this.reviewQ.length === 0 && this.failedQ.length === 0) {
+    while (this._secondsRemaining > 0 && this.supplyQ.length === 0 && this.failedQ.length === 0) {
       this.log(
         `[WedgeBreaker] All queues empty with ${this._secondsRemaining}s remaining. Running pipeline (attempt ${wedgeEmptyStreak + 1}/${WEDGE_MAX_EMPTY_STREAK}).`
       );
       await this._replanUncoalesced({ label: "wedge-breaker" });
-      if (this.newQ.length === 0 && this.reviewQ.length === 0 && this.failedQ.length === 0) {
+      if (this.supplyQ.length === 0 && this.failedQ.length === 0) {
         wedgeEmptyStreak++;
         if (wedgeEmptyStreak >= WEDGE_MAX_EMPTY_STREAK) {
           this.log(
@@ -14762,15 +14943,16 @@ var SessionController = class _SessionController extends Loggable {
         await this.hydrationService.ensureHydratedCards();
         this._currentCard = card;
         const origin = nextItem.status === "review" || nextItem.status === "failed-review" ? "review" : nextItem.status === "new" || nextItem.status === "failed-new" ? "new" : "failed";
-        const queueSource = nextItem.status.startsWith("failed") ? "failedQ" : nextItem.status === "review" ? "reviewQ" : "newQ";
+        const queueSource = nextItem.status.startsWith("failed") ? "failedQ" : "supplyQ";
         recordCardPresentation(
           nextItem.cardID,
           nextItem.courseID,
           this.courseNameCache.get(nextItem.courseID),
           origin,
-          queueSource
+          queueSource,
+          nextItem.score
         );
-        snapshotQueues(this.reviewQ.length, this.newQ.length, this.failedQ.length);
+        snapshotQueues(this.supplyQ.length, this.failedQ.length);
         return card;
       }
       this.log(`Skipping card ${nextItem.cardID}: hydration failed, trying next`);
@@ -14840,6 +15022,7 @@ var SessionController = class _SessionController extends Loggable {
           };
         }
         this.failedQ.add(failedItem, failedItem.cardID);
+        this._supplyDrawsSinceFailed = 0;
       } else if (action === "dismiss-error") {
         this.hydrationService.removeCard(this._currentCard.item.cardID);
       } else if (action === "dismiss-failed") {
@@ -14853,15 +15036,15 @@ var SessionController = class _SessionController extends Loggable {
   removeItemFromQueue(item) {
     this._clearDurableRequirement(item.cardID);
     this._servedCardIds.add(item.cardID);
-    if (this.reviewQ.peek(0)?.cardID === item.cardID) {
-      this.reviewQ.dequeue((queueItem) => queueItem.cardID);
-    } else if (this.newQ.peek(0)?.cardID === item.cardID) {
-      this.newQ.dequeue((queueItem) => queueItem.cardID);
+    if (this.failedQ.peek(0)?.cardID === item.cardID) {
+      this.failedQ.dequeue((queueItem) => queueItem.cardID);
+      this._supplyDrawsSinceFailed = 0;
+    } else if (this.supplyQ.peek(0)?.cardID === item.cardID) {
+      this.supplyQ.dequeue((queueItem) => queueItem.cardID);
+      this._supplyDrawsSinceFailed++;
       if (this._wellIndicatedRemaining > 0) {
         this._wellIndicatedRemaining--;
       }
-    } else if (this.failedQ.peek(0)?.cardID === item.cardID) {
-      this.failedQ.dequeue((queueItem) => queueItem.cardID);
     }
   }
   /**
@@ -14960,6 +15143,7 @@ export {
   areQuestionRecords,
   buildStrategyStateId,
   captureMixerRun,
+  clearSrsBacklogDebug,
   computeDeviation,
   computeEffectiveWeight,
   computeOutcomeSignal,
@@ -14970,6 +15154,7 @@ export {
   docIsDeleted,
   endSessionTracking,
   ensureAppDataDirectory,
+  getActivePipeline,
   getAppDataDirectory,
   getCardHistoryID,
   getCardOrigin,
@@ -14979,6 +15164,7 @@ export {
   getRegisteredNavigator,
   getRegisteredNavigatorNames,
   getRegisteredNavigatorRole,
+  getSrsBacklogDebug,
   getStudySource,
   hasRegisteredNavigator,
   importParsedCards,