feat(work): add solution for LeetCode 211 design add and search words data structure

docs(docs): add MDX page for LeetCode 211 design problem
docs(schedule): clarify schedule JSON format, gate problem handling, and update week dates in README
2026-11-02 13:12:44 +00:00 · 2026-09-21 12:50:53 -04:00 · 2026-09-21 12:50:51 -04:00 · 2026-09-21 12:14:37 -04:00 · 2026-09-21 12:14:33 -04:00 · 2026-09-21 12:14:29 -04:00
115 changed files with 5576 additions and 191 deletions
@@ -114,7 +114,12 @@ One issue per curriculum topic; owns the problem sub-issues.
  ```

 `Scheduled` should come from the calendar of record — `apps/api/data/schedule.json`
-(day → topic issue) — not guessed.
+(`date → { topics: [issue, …] }`; a doubled day lists two) — not guessed.
+
+Gate problems (`gate: [...]` in the same file) must exist in the catalog before their
+Saturday, or the Worker refuses to create the review issue: create each as a
+`set:optional` problem sub-issue of its natural topic. Being named in the plan keeps it
+out of the drill pool, so it stays unseen until the gate.

 ## Reference tables

@@ -23,6 +23,7 @@ flowchart LR
  D1 -->|Sat midnight ET| Review[Review — Week N issue]
  PI -->|"spaced-repetition.yml (6 AM ET cron, closed +3d/+7d)"| SR[Spaced Repetition — Month D issue]
  D1 --> Charts[SVG charts + /api/stats]
+  Charts -->|bun run stats| TUI[terminal dashboard]
 ```

 - **Reconcile, don't react.** `close-solved.ts`, `close-topics.ts`, and the Worker's catalog sync recompute desired state from scratch each run: re-runs are no-ops, backfills need no special casing, closing is one-directional. `close-solved` posts its *whole* implemented set to `/admin/solved`, not just the issues it closed this run.
@@ -32,6 +33,7 @@ flowchart LR
 - **The picker owns the local review loop; the buckets are its state.** `work/` holds three buckets (`1` = first solve, `3`/`7` = blind re-solves, named after the ladder rungs) and `bun run pick` has three sections — Tab cycles them. Pools are reconciled from the filesystem plus one `git log` (`apps/cli/work.ts`): a first solve dates from the ET date of the commit that added its `work/1` file — the same push that closes the problem issue and starts the +3/+7 windows — and a window stops being owed the moment its bucket holds a file. Uncapped, unlike the review issue's `WINDOW_CAP`: that issue is one day's assignment, the picker is everything still owed. An empty scaffold under `work/1` owes nothing (it is unsolved), which is why `isImplemented()` lives in `apps/cli/source.ts` and is shared with `close-solved.ts`. leetcode-cli reads its output directory from `~/.leetcode/workspaces/<active>/config.json` and nowhere else — no flag, no env var — so `pick.ts` MERGES `workDir` into that file around the child (never replays saved bytes: the CLI owns the file too) and leaves it pointed at `work/1`, then treats the scaffold's existence as the acceptance test, since leetcode-cli exits 0 even when an expired session made it write nothing. The picker itself writes no state: pushing the re-solve is what moves the ladder, via `close-solved` → `/admin/solved` with that file's bucket.
 - **The README charts are live, never committed.** They are Worker endpoints reading D1 per request (`Cache-Control: max-age=300`, honored by GitHub Camo), so a solved push moves them within ~5 minutes with no commit and no workflow of their own.
 - **D1 owns SRS state; GitHub issues own the catalog; `apps/api/data/schedule.json` owns the calendar.** The catalog reconcile never invents rows and never overwrites SRS columns (`stage`, `next_review`). `Target Date` is the *only* Project field the Worker mirrors (`apps/api/src/mirror.ts`): failures are warnings, never lost D1 writes; topic rows' `Target Date` is never written. SRS stage and first-attempt result live **only** in D1 — do not re-add them as Project fields. The Project's `Set`/`Difficulty` single-selects are a projection of the issue labels, reconciled by `bun run sync-project-fields` — a best-effort final step of `close-solved.yml`, never the Worker.
+- **The plan names days; the samplers fill the gaps.** `apps/api/data/schedule.json` maps a date to a `ScheduledDay` (`apps/api/src/srs.ts`): `topics` (one or more topic issues — a doubled day lists two, and the digest renders each with its core list then the optional "if time" list), `problems` (a set day: fixed numbers, rendered like a topic), `gate` (Saturday's blind set, verbatim — `createReviewIssue` refuses to create the issue if any number is not a catalog row, so gate problems must exist as `set:optional` sub-issues of their topic first), or `sweep` (every problem whose last attempt failed, taps to re-log, no drills). Every number a `gate` or `problems` entry names is in `RESERVED`, and the drill/gate samplers never draw it — that is what keeps a planned gate problem unseen until its Saturday. Dates absent from the plan still get the ladder's reviews and drills; a Saturday without a `gate` entry falls back to sampling this week's optional pools.
 - **Determinism = idempotency.** Drill/gate sampling uses a seeded PRNG (`rng()` in `apps/api/src/srs.ts`, FNV-1a → mulberry32, seed = date / ISO week); the digest is keyed by ET date in `email_log`; one-tap links are unique on (problem, date, kind).
 - **DST-proof crons:** each event has two UTC crons; code fires only on the computed ET hour (`etHour`), unit-checked in `apps/api/src/srs.test.ts`.
 - **Chained workflows:** `GITHUB_TOKEN`-driven issue closes fire no `issues` events, so `close-topics.yml` chains off `workflow_run` of Close Solved instead. The Worker's webhook uses its own `GH_PAT`, so its events flow normally.
@@ -43,7 +45,7 @@ flowchart LR
 | `work/<1\|3\|7>/<Difficulty>/<Category>/<num>.<slug>.{js,py}` | Solutions, e.g. `work/1/Easy/Array/1.two-sum.py`. The top directory is the spaced-repetition bucket: `1` = first solve, `3`/`7` = the blind re-solves of that problem 3 and 7 days later. Machine-parsed header comment (title / `Difficulty:` / URL / `─` rule / statement) — preserve its exact shape |
 | `apps/cli/` | Flat Bun TS workspace: automation entries (shebang + top-level await) and libraries (no shebang, side-effect-free on import). Root `bun run` scripts delegate here |
 | `apps/docs/` | Blume site (`blume.config.ts`, `content/`, `islands/`, `public/`). `content/(<category>)/<num>-<slug>.mdx` generated by sync |
-| `apps/api/` | Cloudflare Worker workspace: `src/` modules, `data/schedule.json` (day → topic issue, human-edited, bundled at deploy), `migrations/` (append-only; `0002` is the +3/+7 ladder rebuild) |
+| `apps/api/` | Cloudflare Worker workspace: `src/` modules, `data/schedule.json` (the plan: `date → { topics | problems | gate | sweep }`, human-edited, bundled at deploy), `migrations/` (append-only; `0002` is the +3/+7 ladder rebuild) |
 | `.github/workflows/` | deploy (docs → Pages, Worker → Cloudflare, on every main push), close-solved (issues + `/admin/solved` + Project `Set`/`Difficulty`, needs `SRS_ADMIN_KEY` and `PROJECT_PAT`), close-topics, sync-d1 (issue edits → `/admin/reconcile`), spaced-repetition (daily 06:00 ET cron → today's review issue; `GITHUB_TOKEN` only, no secrets) |

 ## Development Commands
@@ -56,6 +58,10 @@ bun run pick            # scaffold a solution via leetcode-cli (fuzzy picker; Ta
                        # re-solves → work/3, work/7. Each section hides what its own bucket
                        # already holds; index+descriptions cached in
                        # ~/.local/share/leetcode/data.db — see apps/cli/db.ts)
+bun run stats           # terminal dashboard over GET /api/stats — four panes (Overview,
+                        # Ladder, Concepts, Activity); Tab/1-4 switches, ↑↓ scrolls,
+                        # r refetches, q quits. Outside a TTY it prints every pane once.
+                        # SRS_API points it at a local Worker like close-solved does.
 bun run test            # run ONE solution against LeetCode's judge (not a test suite;
                        # most recently tested first, stamped in the db on exit 0)
 bun run submit          # submit ONE solution to LeetCode (newest scaffold first, nothing
@@ -92,12 +98,13 @@ curl -X POST -H "Authorization: Bearer $LINK_KEY" \

 ## Important Files

- `apps/api/src/srs.ts` — SRS domain: the ladder (`new → +3 → +7 → retired`; fail resets to `+3`; first-ever log enters at `+3`), `WINDOWS`/`STAGES` (the one vocabulary shared by the charts, the `work/<n>` buckets and the review issues), ET date math, `workingDay()` (no scheduled date is ever a Sunday), seeded sampling, `logAttempt()` (the ONE write path — email taps, webhook, gate scoring all converge here), and overload leveling: at most `REVIEW_CAP` (3) reviews surface per day — `levelReviews()` (run by `sendDigest` on real sends only, never dry) gives everything past the cap a concrete future WORKING day, ≤ 3 per day, oldest first, instead of letting the due pile grow.
+- `apps/api/src/srs.ts` — SRS domain: the ladder (`new → +3 → +7 → retired`; fail resets to `+3`; first-ever log enters at `+3`), `WINDOWS`/`STAGES`/`TEMPERATURES`/`DIFFICULTIES`/`SETS` (the one vocabulary shared by the charts, the `work/<n>` buckets, the review issues and the stats dashboard), ET date math, `workingDay()` (no scheduled date is ever a Sunday), `temperatureOf()` (days since a concept was last exercised → `hot`/`fresh`/`fading`/`cold`, bands derived from `WINDOWS` so they cannot drift; read-side only, nothing is scheduled off it), seeded sampling, `logAttempt()` (the ONE write path — email taps, webhook, gate scoring all converge here), and overload leveling: at most `REVIEW_CAP` (3) reviews surface per day — `levelReviews()` (run by `sendDigest` on real sends only, never dry) gives everything past the cap a concrete future WORKING day, ≤ 3 per day, oldest first, instead of letting the due pile grow.
 - `apps/api/src/index.ts` — router + cron dispatch; `apps/api/wrangler.jsonc` — bindings (`DB`, `EMAIL`), crons, vars; secrets `GH_PAT`/`WEBHOOK_SECRET`/`LINK_KEY` via `wrangler secret put`.
 - `apps/api/src/digest.ts` / `apps/api/src/email.tsx` — the daily digest, split data/presentation. `digest.ts` reads D1 into a `DigestData`; `email.tsx` owns every colour and every sentence, and renders both the HTML and (via its own `plainDigest`, not React Email's `plainText` mode, which flattens the tables) the text alternative. The retrieval rules hold by construction: `DigestRow` has no title and no issue field, so a review or drill line *cannot* leak the topic or a solution link. Subject is `(Day N/56) LeetCode Daily Digest`.
 - `apps/api/src/png.ts` — hand-rolled PNG encoder (RGB8, one IDAT, zlib via `CompressionStream("deflate")`, CRC32, 5×7 bitmap font). It exists because every major email client refuses remote SVG, so `/chart/heatmap.png` rasters the heatmap for the digest while `/chart/heatmap.svg` keeps serving the README byte-for-byte. Both come from one `heatmapCells()` so the two pictures cannot drift.
- `apps/cli/sync.ts` — work→docs contract: only `## Solution` onward is script-owned on existing pages; human prose is never touched; never hand-write solution pages or edit inside `## Solution`.
- `apps/cli/work.ts` — the `work/` layout: bucket paths, `firstSolved()` (one `git log`, ET dates, keyed by LC number so past layout moves don't matter), and `reviewQueues()` (what each window still owes). Everything that needs to know where a solution file lives, or when it was solved, goes through here.
+- `apps/cli/sync.ts` — work→docs contract: on existing pages only the `## Solution` section itself is script-owned, bounded by `solutionEnd()` at the next unfenced top-level heading; human prose before it and any sections after it (`## Approach`, `## Explanation`) are never touched. Never hand-write solution pages or edit inside `## Solution`.
+- `apps/cli/work.ts` — the `work/` layout: bucket paths, `isSolution()`/`solvedInBucket()` (the stub test, shared with `close-solved.ts`), `firstSolved()` (one `git log`, ET dates, keyed by LC number so past layout moves don't matter), and `reviewQueues()` (what each window still owes). Everything that needs to know where a solution file lives, or when it was solved, goes through here.
+- `apps/api/src/stats.ts` / `apps/cli/stats.ts` / `apps/cli/tui.ts` / `apps/cli/api.ts` — the read side. `buildStats()` is the ONE aggregation: phases, ladder, difficulty, per-topic temperature, gates, the 14-day due queue, and `heat` (every campaign day, zeros and future days included — the docs page windows the tail off it rather than asking a second question). Two readers consume it, the docs island and `bun run stats`, so its shape is both their contract: change all three together. `tui.ts` is hand-rolled ANSI (bars, sparklines, heat cells, alternate screen) on charts.ts's palette, and every chart differs by GLYPH as well as by colour so a piped or `NO_COLOR` dashboard still reads. The TUI recomputes nothing: the only local fact it shows is the `work/` solution count, which is inventory, not schedule.
 - `README.md` live charts are Worker endpoints (`/chart/*.svg`, `/badge/gate.svg`, 5-min Camo cache); the docs `/progress` page fetches `/api/stats` client-side (`apps/docs/islands/ProgressDashboard.tsx`).
 - `apps/docs/blume.config.ts` — site base `/leetcode`; `README.md` campaign table doubles as topic-map input to `sync.ts` (`readmeTopics()`, `TOPIC_ALIASES`).
 - Old `.github/srs/` JSON state, its `srs-*` Actions, and the one-shot `import-srs.ts` importer are RETIRED and deleted — do not resurrect; git history is the record.
@@ -105,8 +112,7 @@ curl -X POST -H "Authorization: Bearer $LINK_KEY" \
 ## Runtime/Tooling Preferences

 - **Bun only**: run scripts with `bun apps/cli/<name>.ts` (or the root `bun run` aliases), install with `bun install --frozen-lockfile`. One workspace (`apps/*`), one root `bun.lock`. Node 22 appears only in `deploy.yml` because Blume requires it.
- **No root tsconfig, no ESLint, no Prettier** — match surrounding style by hand. `apps/api/` has a strict `tsconfig.json`; `Env` types are generated (`bunx wrangler types`), never hand-written.
- **Near-zero runtime npm dependencies** — SVG, PNG, HMAC (WebCrypto), GraphQL are hand-rolled; Actions scripts use Bun builtins + `fetch` only. The **one** exception is the digest email: `apps/api/src/email.tsx` renders React Email (`react`, `react-dom`, `@react-email/components`, `@react-email/render`) inside the Worker, because hand-rolling table-based email HTML that survives Gmail *and* Outlook is not worth owning. It costs ~235 KB gzipped of a 3 MB budget, needs no `nodejs_compat` (it resolves to `renderToReadableStream`), and requires `"jsx": "react-jsx"` in `apps/api/tsconfig.json`. Do not extend this exception to any other module.
+- **Near-zero runtime npm dependencies** — SVG, PNG, terminal ANSI, HMAC (WebCrypto), GraphQL are hand-rolled; Actions scripts use Bun builtins + `fetch` only. The **one** exception is the digest email: `apps/api/src/email.tsx` renders React Email (`react`, `react-dom`, `@react-email/components`, `@react-email/render`) inside the Worker, because hand-rolling table-based email HTML that survives Gmail *and* Outlook is not worth owning. It costs ~235 KB gzipped of a 3 MB budget, needs no `nodejs_compat` (it resolves to `renderToReadableStream`), and requires `"jsx": "react-jsx"` in `apps/api/tsconfig.json`. Do not extend this exception to any other module.
 - Local GitHub auth falls back to `gh auth token`; scripts run fine outside Actions.

 ## Testing & QA
@@ -212,7 +212,7 @@
    <tr><td align="center"><code>B</code> ⭐</td><td align="center">295</td><td><a href="https://leetcode.com/problems/find-median-from-data-stream/">Find Median from Data Stream</a></td></tr>
    <tr><td align="center"><code>B</code> ⭐</td><td align="center">502</td><td><a href="https://leetcode.com/problems/ipo/">IPO</a></td></tr>
    <tr>
-      <td rowspan="3"><a href="https://github.com/prdlk/leetcode/issues/17"><strong>15. Trie</strong></a><br><sub>Wk 4 · Wed Sep 9</sub><br><sub>builds on 11</sub></td>
+      <td rowspan="3"><a href="https://github.com/prdlk/leetcode/issues/17"><strong>15. Trie</strong></a><br><sub>Wk 6 · Mon Sep 21</sub><br><sub>builds on 11</sub></td>
      <td align="center"><code>A</code></td><td align="center">208</td><td><a href="https://leetcode.com/problems/implement-trie-prefix-tree/">Implement Trie</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">211</td><td><a href="https://leetcode.com/problems/design-add-and-search-words-data-structure/">Add &amp; Search Words</a></td></tr>
@@ -234,7 +234,7 @@
  </thead>
  <tbody>
    <tr>
-      <td rowspan="7"><a href="https://github.com/prdlk/leetcode/issues/18"><strong>16. Graph DFS</strong></a><br><sub>Wk 4 · Thu Sep 10</sub><br><sub>builds on 11 + visited set</sub></td>
+      <td rowspan="7"><a href="https://github.com/prdlk/leetcode/issues/18"><strong>16. Graph DFS</strong></a><br><sub>Wk 6 · Mon Sep 21</sub><br><sub>builds on 11 + visited set</sub></td>
      <td align="center"><code>A</code></td><td align="center">200</td><td><a href="https://leetcode.com/problems/number-of-islands/">Number of Islands</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">695</td><td><a href="https://leetcode.com/problems/max-area-of-island/">Max Area of Island</a></td></tr>
@@ -244,7 +244,7 @@
    <tr><td align="center"><code>B</code></td><td align="center">399</td><td><a href="https://leetcode.com/problems/evaluate-division/">Evaluate Division</a></td></tr>
    <tr><td align="center"><code>B</code></td><td align="center">261</td><td><a href="https://leetcode.com/problems/graph-valid-tree/">Graph Valid Tree</a></td></tr>
    <tr>
-      <td rowspan="5"><a href="https://github.com/prdlk/leetcode/issues/19"><strong>17. Graph BFS</strong></a><br><sub>Wk 4 · Fri Sep 11</sub><br><sub>builds on 12 + visited set — shortest path unweighted</sub></td>
+      <td rowspan="5"><a href="https://github.com/prdlk/leetcode/issues/19"><strong>17. Graph BFS</strong></a><br><sub>Wk 6 · Tue Sep 22</sub><br><sub>builds on 12 + visited set — shortest path unweighted</sub></td>
      <td align="center"><code>A</code></td><td align="center">994</td><td><a href="https://leetcode.com/problems/rotting-oranges/">Rotting Oranges</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">127</td><td><a href="https://leetcode.com/problems/word-ladder/">Word Ladder</a></td></tr>
@@ -252,14 +252,14 @@
    <tr><td align="center"><code>B</code></td><td align="center">433</td><td><a href="https://leetcode.com/problems/minimum-genetic-mutation/">Minimum Genetic Mutation</a></td></tr>
    <tr><td align="center"><code>B</code></td><td align="center">286</td><td><a href="https://leetcode.com/problems/walls-and-gates/">Walls and Gates</a></td></tr>
    <tr>
-      <td rowspan="4"><a href="https://github.com/prdlk/leetcode/issues/20"><strong>18. Topological Sort</strong></a><br><sub>Wk 5 · Mon Sep 14</sub><br><sub>builds on 16</sub></td>
+      <td rowspan="4"><a href="https://github.com/prdlk/leetcode/issues/20"><strong>18. Topological Sort</strong></a><br><sub>Wk 6 · Tue Sep 22</sub><br><sub>builds on 16</sub></td>
      <td align="center"><code>A</code></td><td align="center">207</td><td><a href="https://leetcode.com/problems/course-schedule/">Course Schedule</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">210</td><td><a href="https://leetcode.com/problems/course-schedule-ii/">Course Schedule II</a></td></tr>
    <tr><td align="center"><code>B</code> ⭐</td><td align="center">269</td><td><a href="https://leetcode.com/problems/alien-dictionary/">Alien Dictionary</a></td></tr>
    <tr><td align="center"><code>B</code></td><td align="center">1462</td><td><a href="https://leetcode.com/problems/course-schedule-iv/">Course Schedule IV</a></td></tr>
    <tr>
-      <td rowspan="4"><a href="https://github.com/prdlk/leetcode/issues/21"><strong>19. Union-Find</strong></a><br><sub>Wk 5 · Tue Sep 15</sub><br><sub>builds on 16's problem class</sub></td>
+      <td rowspan="4"><a href="https://github.com/prdlk/leetcode/issues/21"><strong>19. Union-Find</strong></a><br><sub>Wk 6 · Wed Sep 23</sub><br><sub>builds on 16's problem class</sub></td>
      <td align="center"><code>A</code></td><td align="center">684</td><td><a href="https://leetcode.com/problems/redundant-connection/">Redundant Connection</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">323</td><td><a href="https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/">Number of Connected Components</a></td></tr>
@@ -282,7 +282,7 @@
  </thead>
  <tbody>
    <tr>
-      <td rowspan="8"><a href="https://github.com/prdlk/leetcode/issues/22"><strong>20. Backtracking</strong></a><br><sub>Wk 5 · Wed Sep 16</sub><br><sub>builds on 16 — then unlock LC 212 from topic 15</sub></td>
+      <td rowspan="8"><a href="https://github.com/prdlk/leetcode/issues/22"><strong>20. Backtracking</strong></a><br><sub>Wk 6 · Thu Sep 24</sub><br><sub>builds on 16 — then unlock LC 212 from topic 15</sub></td>
      <td align="center"><code>A</code></td><td align="center">78</td><td><a href="https://leetcode.com/problems/subsets/">Subsets</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">39</td><td><a href="https://leetcode.com/problems/combination-sum/">Combination Sum</a></td></tr>
@@ -293,7 +293,7 @@
    <tr><td align="center"><code>B</code></td><td align="center">22</td><td><a href="https://leetcode.com/problems/generate-parentheses/">Generate Parentheses</a></td></tr>
    <tr><td align="center"><code>B</code> ⭐</td><td align="center">52</td><td><a href="https://leetcode.com/problems/n-queens-ii/">N-Queens II</a></td></tr>
    <tr>
-      <td rowspan="9"><a href="https://github.com/prdlk/leetcode/issues/23"><strong>21. 1-D Dynamic Programming</strong></a><br><sub>Wk 5 · Thu Sep 17</sub><br><sub>builds on 20</sub></td>
+      <td rowspan="9"><a href="https://github.com/prdlk/leetcode/issues/23"><strong>21. 1-D Dynamic Programming</strong></a><br><sub>Wk 6 · Fri Sep 25</sub><br><sub>builds on 20</sub></td>
      <td align="center"><code>A</code></td><td align="center">70</td><td><a href="https://leetcode.com/problems/climbing-stairs/">Climbing Stairs</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">746</td><td><a href="https://leetcode.com/problems/min-cost-climbing-stairs/">Min Cost Climbing Stairs</a></td></tr>
@@ -305,7 +305,7 @@
    <tr><td align="center"><code>B</code></td><td align="center">91</td><td><a href="https://leetcode.com/problems/decode-ways/">Decode Ways</a></td></tr>
    <tr><td align="center"><code>B</code></td><td align="center">647</td><td><a href="https://leetcode.com/problems/palindromic-substrings/">Palindromic Substrings</a></td></tr>
    <tr>
-      <td rowspan="8"><a href="https://github.com/prdlk/leetcode/issues/24"><strong>22. Multi-D / Grid DP</strong></a><br><sub>Wk 5 · Fri Sep 18</sub><br><sub>builds on 21</sub></td>
+      <td rowspan="8"><a href="https://github.com/prdlk/leetcode/issues/24"><strong>22. Multi-D / Grid DP</strong></a><br><sub>Wk 7 · Mon Sep 28</sub><br><sub>builds on 21</sub></td>
      <td align="center"><code>A</code></td><td align="center">62</td><td><a href="https://leetcode.com/problems/unique-paths/">Unique Paths</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">64</td><td><a href="https://leetcode.com/problems/minimum-path-sum/">Minimum Path Sum</a></td></tr>
@@ -316,7 +316,7 @@
    <tr><td align="center"><code>B</code></td><td align="center">221</td><td><a href="https://leetcode.com/problems/maximal-square/">Maximal Square</a></td></tr>
    <tr><td align="center"><code>B</code> ⭐</td><td align="center">97</td><td><a href="https://leetcode.com/problems/interleaving-string/">Interleaving String</a></td></tr>
    <tr>
-      <td rowspan="7"><a href="https://github.com/prdlk/leetcode/issues/25"><strong>23. Greedy</strong></a><br><sub>Wk 6 · Mon Sep 21</sub><br><sub>builds on 21 — includes Kadane's</sub></td>
+      <td rowspan="7"><a href="https://github.com/prdlk/leetcode/issues/25"><strong>23. Greedy</strong></a><br><sub>Wk 7 · Tue Sep 29</sub><br><sub>builds on 21 — includes Kadane's</sub></td>
      <td align="center"><code>A</code></td><td align="center">53</td><td><a href="https://leetcode.com/problems/maximum-subarray/">Maximum Subarray</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">55</td><td><a href="https://leetcode.com/problems/jump-game/">Jump Game</a></td></tr>
@@ -326,7 +326,7 @@
    <tr><td align="center"><code>B</code></td><td align="center">918</td><td><a href="https://leetcode.com/problems/maximum-sum-circular-subarray/">Maximum Sum Circular Subarray</a></td></tr>
    <tr><td align="center"><code>B</code></td><td align="center">763</td><td><a href="https://leetcode.com/problems/partition-labels/">Partition Labels</a></td></tr>
    <tr>
-      <td rowspan="7"><a href="https://github.com/prdlk/leetcode/issues/26"><strong>24. Intervals</strong></a><br><sub>Wk 6 · Tue Sep 22</sub><br><sub>builds on 23</sub></td>
+      <td rowspan="7"><a href="https://github.com/prdlk/leetcode/issues/26"><strong>24. Intervals</strong></a><br><sub>Wk 7 · Wed Sep 30</sub><br><sub>builds on 23</sub></td>
      <td align="center"><code>A</code></td><td align="center">57</td><td><a href="https://leetcode.com/problems/insert-interval/">Insert Interval</a></td>
    </tr>
    <tr><td align="center"><code>A</code></td><td align="center">56</td><td><a href="https://leetcode.com/problems/merge-intervals/">Merge Intervals</a></td></tr>
@@ -14,8 +14,12 @@ Live at `https://srs-api.prdlk.workers.dev`.
  labels, milestones. `catalog.ts` reconciles them into D1 nightly (and via
  `/admin/reconcile`); it recomputes from scratch, never invents rows, and
  never overwrites SRS-owned columns (`stage`, `next_review`).
- **The repo owns the schedule** — `data/schedule.json`, human-edited,
-  bundled at deploy. Git history is its audit log.
+- **The repo owns the plan** — `data/schedule.json`, human-edited,
+  bundled at deploy. Git history is its audit log. Each date is a
+  `ScheduledDay`: `topics` (one or more topic issues), `problems` (a set day,
+  fixed numbers), `gate` (Saturday's blind set, verbatim), or `sweep` (redo
+  every miss, nothing new). Numbers a `gate` or `problems` entry names are
+  `RESERVED`: the drill and gate samplers never draw them.
 - The GitHub Project mirror writes `Target Date` and nothing else: it is
  best-effort, so failures log warnings and never block a D1 write, and topic
  rows are never written. SRS stage and first-attempt result stay in D1 only —
@@ -47,7 +51,10 @@ raw `Date` math.
 Blind drills draw only from topics **already learned**: scheduled in an
 earlier week (the current week's optional pool is reserved for Saturday's
 gate) and with at least one core problem on the ladder — a skipped learning
-day never feeds drills just because its calendar week lapsed.
+day never feeds drills just because its calendar week lapsed. A Saturday
+whose plan fixes the `gate` set uses that list as-is; every number must be a
+catalog row (a `set:optional` sub-issue of its topic), or the review issue is
+not created — a `/done` on an uncatalogued number could never be logged.

 ## Routes

@@ -1,26 +1,28 @@
 {
-  "2026-08-17": 3,
-  "2026-08-18": 4,
-  "2026-08-24": 5,
-  "2026-08-25": 6,
-  "2026-08-26": 7,
-  "2026-08-27": 8,
-  "2026-08-28": 9,
-  "2026-08-31": 10,
-  "2026-09-01": 11,
-  "2026-09-02": 12,
-  "2026-09-03": 13,
-  "2026-09-04": 14,
-  "2026-09-07": 15,
-  "2026-09-08": 16,
-  "2026-09-09": 17,
-  "2026-09-10": 18,
-  "2026-09-11": 19,
-  "2026-09-14": 20,
-  "2026-09-15": 21,
-  "2026-09-16": 22,
-  "2026-09-17": 23,
-  "2026-09-18": 24,
-  "2026-09-21": 25,
-  "2026-09-22": 26
+  "2026-08-17": { "topics": [3] },
+  "2026-08-18": { "topics": [4] },
+  "2026-08-24": { "topics": [5] },
+  "2026-08-25": { "topics": [6] },
+  "2026-08-26": { "topics": [7] },
+  "2026-08-27": { "topics": [8] },
+  "2026-08-28": { "topics": [9] },
+  "2026-08-31": { "topics": [10] },
+  "2026-09-01": { "topics": [11] },
+  "2026-09-02": { "topics": [12] },
+  "2026-09-03": { "topics": [13] },
+  "2026-09-04": { "topics": [14] },
+  "2026-09-07": { "topics": [15] },
+  "2026-09-08": { "topics": [16] },
+  "2026-09-21": { "topics": [17, 18] },
+  "2026-09-22": { "topics": [19, 20] },
+  "2026-09-23": { "topics": [21] },
+  "2026-09-24": { "topics": [22] },
+  "2026-09-25": { "topics": [23] },
+  "2026-09-26": { "gate": [648, 1091, 802, 547, 90] },
+  "2026-09-28": { "topics": [24] },
+  "2026-09-29": { "topics": [25] },
+  "2026-09-30": { "topics": [26] },
+  "2026-10-01": { "problems": [399, 261, 909, 77, 52] },
+  "2026-10-02": { "sweep": true },
+  "2026-10-03": { "gate": [347, 1254, 1971, 131, 494, 986] }
 }
@@ -10,14 +10,11 @@
 * so relabelling a problem is enough to move it and titles stay readable.
 * The `problem` label is what marks a sub-issue as curriculum.
 */
-import { workingDay } from "./srs.ts";
+import { DIFFICULTIES, SETS, workingDay } from "./srs.ts";
 import type { GitHub } from "./github.ts";

 const TITLE_RE = /^LC (\d+) · (.+)$/;

-const DIFFICULTIES = ["easy", "medium", "hard"] as const;
-const SETS = ["core", "optional", "deferred"] as const;
-
 /** Deferred Hards enter the queue from this date, two per working day. */
 const DEFER_FROM = "2026-09-28";

@@ -5,14 +5,16 @@
 * the HTML and the plain-text alternative from that single tree (React Email
 * `render`), so the two can never drift.
 *
- * Retrieval rules: review and drill rows carry number + difficulty only —
- * never the topic, never a solution link. `DigestRow` has no field for
- * either, so the rule holds by construction. The learning day's core list is
- * the only labeled section. At most REVIEW_CAP (3) reviews per day; drills
- * fill toward DAILY_CAP (6) only when the due queue is light. Overflow is
- * levelled, not stacked: sendDigest gives every review past the cap a
- * concrete future date, ≤ REVIEW_CAP per day, oldest first. Sunday is a
- * two-line rest note.
+ * Retrieval rules: review, drill and sweep rows carry number + difficulty
+ * only — never the topic, never a solution link. `DigestRow` has no field for
+ * either, so the rule holds by construction. The plan's own sections — a
+ * learning day's topics (core, then the optional "if time" list) and a set
+ * day's problems — are the only labeled, linked ones. At most REVIEW_CAP (3)
+ * reviews per day; drills fill toward DAILY_CAP (6) only when the due queue
+ * is light, and never on a sweep day, which assigns every open miss and
+ * nothing new. Overflow is levelled, not stacked: sendDigest gives every
+ * review past the cap a concrete future date, ≤ REVIEW_CAP per day, oldest
+ * first. Sunday is a two-line rest note.
 *
 * Idempotency: email_log keys sends by ET date — a same-day re-send is a
 * no-op unless forced; the body itself is deterministic (drill picks are
@@ -22,20 +24,23 @@
 import {
  CAMPAIGN_DAYS,
  type ProblemRow,
+  RESERVED,
  REVIEW_CAP,
  SCHEDULE,
+  type ScheduledDay,
  addDays,
  campaignDay,
  campaignWeek,
  dueReviews,
  isoWeek,
  levelReviews,
+  lookupProblems,
  pickDrills,
  prettyDate,
  streak,
  weekdayOf,
 } from "./srs.ts";
-import { type DigestData, type DigestRow, renderDigest } from "./email.tsx";
+import { type DigestData, type DigestRow, type TopicRow, renderDigest } from "./email.tsx";
 import { signLink } from "./links.ts";

 /** Total daily ceiling: drills only fill what the whole due queue leaves. */
@@ -63,23 +68,50 @@ async function tapRow(env: Env, p: ProblemRow, date: string, staged: boolean): P
  };
 }

+/** A plan-named problem: linked to its issue, ticked once it has entered the ladder. */
+function topicRow(env: Env, p: ProblemRow): TopicRow {
+  return {
+    lc: p.lc_number,
+    difficulty: p.difficulty,
+    url: `https://github.com/${env.REPO}/issues/${p.issue}`,
+    solved: p.stage !== "new",
+  };
+}
+
+/** Problems whose most recent attempt failed — the miss log a sweep day works through. */
+async function openMisses(db: D1Database): Promise<ProblemRow[]> {
+  const { results } = await db
+    .prepare(
+      `SELECT p.* FROM problems p
+       JOIN attempts a ON a.lc_number = p.lc_number
+       WHERE a.id = (SELECT MAX(id) FROM attempts WHERE lc_number = p.lc_number)
+         AND a.result = 'fail' AND p.stage != 'retired'
+       ORDER BY a.date, p.lc_number`,
+    )
+    .all<ProblemRow>();
+  return results;
+}
+
 /** Everything the email needs, read straight out of D1 and the schedule. */
 export async function collectDigest(env: Env, date: string): Promise<DigestData> {
  const db = env.DB;
  const rest = weekdayOf(date) === 0;
+  const plan: ScheduledDay = rest ? {} : (SCHEDULE[date] ?? {});

  // Reviews surface at most REVIEW_CAP; drills fill toward DAILY_CAP only
  // when the WHOLE due queue is light — a heavy backlog must never trade
-  // review slots for brand-new drill problems.
+  // review slots for brand-new drill problems — and never on a sweep day.
  const due = rest ? [] : await dueReviews(db, date);
  const capped = due.slice(0, REVIEW_CAP);
-  const drills = rest ? [] : await pickDrills(db, date, DAILY_CAP - Math.min(due.length, DAILY_CAP));
+  const drills =
+    rest || plan.sweep ? [] : await pickDrills(db, date, DAILY_CAP - Math.min(due.length, DAILY_CAP));

  const data: DigestData = {
    day: prettyDate(date),
    progress: `Day ${campaignDay(date)} of ${CAMPAIGN_DAYS} · Week ${campaignWeek(date)}`,
    streak: await streak(db, date),
    rest,
+    topics: [],
    reviews: await Promise.all(capped.map((p) => tapRow(env, p, date, true))),
    carried: due.length - capped.length,
    drills: await Promise.all(drills.map((p) => tapRow(env, p, date, false))),
@@ -88,28 +120,42 @@ export async function collectDigest(env: Env, date: string): Promise<DigestData>
    progressUrl: `${env.DOCS_URL}/progress`,
  };

-  // New topic — the only section allowed to name problems and link them.
-  const topicIssue = rest ? undefined : SCHEDULE[date];
-  if (topicIssue !== undefined) {
+  // New topics — the plan's sections, the only ones allowed to name problems
+  // and link them. Core first; the optional set is "if time", minus anything
+  // the plan has reserved for a gate or a set day.
+  for (const topicIssue of plan.topics ?? []) {
    const topic = await db
      .prepare("SELECT name FROM topics WHERE issue = ?")
      .bind(topicIssue)
      .first<{ name: string }>();
-    const { results: core } = await db
+    const { results } = await db
      .prepare(
-        "SELECT * FROM problems WHERE topic_issue = ? AND set_label = 'core' ORDER BY lc_number",
+        "SELECT * FROM problems WHERE topic_issue = ? AND set_label IN ('core', 'optional') ORDER BY lc_number",
      )
      .bind(topicIssue)
      .all<ProblemRow>();
-    data.topic = {
+    data.topics.push({
      name: topic?.name ?? `#${topicIssue}`,
-      core: core.map((p) => ({
-        lc: p.lc_number,
-        difficulty: p.difficulty,
-        url: `https://github.com/${env.REPO}/issues/${p.issue}`,
-        solved: p.stage !== "new",
-      })),
-    };
+      core: results.filter((p) => p.set_label === "core").map((p) => topicRow(env, p)),
+      ifTime: results
+        .filter((p) => p.set_label === "optional" && !RESERVED.has(p.lc_number))
+        .map((p) => topicRow(env, p)),
+    });
+  }
+
+  // A set day assigns problems by number rather than by topic.
+  if (plan.problems) {
+    const { rows, missing } = await lookupProblems(db, plan.problems);
+    if (missing.length) console.warn(`digest ${date}: planned problems not in the catalog: ${missing.join(", ")}`);
+    data.assigned = rows.map((p) => topicRow(env, p));
+  }
+
+  // A sweep day works the miss log: every problem still standing on a
+  // failure, minus the ones today's review list already carries.
+  if (plan.sweep) {
+    const reviewed = new Set(capped.map((p) => p.lc_number));
+    const misses = (await openMisses(db)).filter((p) => !reviewed.has(p.lc_number));
+    data.sweep = await Promise.all(misses.map((p) => tapRow(env, p, date, true)));
  }

  // Saturday: the review issue already exists (created at midnight ET).
@@ -83,7 +83,7 @@ export interface DigestRow {
  failUrl: string;
 }

-/** A learning-day core problem — the only rows allowed a link. */
+/** A plan-named problem — the only rows allowed a link. */
 export interface TopicRow {
  lc: number;
  difficulty: string;
@@ -91,6 +91,13 @@ export interface TopicRow {
  solved: boolean;
 }

+/** One learning-day topic: the core list, then the optional "if time" list. */
+export interface TopicSection {
+  name: string;
+  core: TopicRow[];
+  ifTime: TopicRow[];
+}
+
 export interface DigestData {
  /** "Tuesday, August 25" */
  day: string;
@@ -98,11 +105,16 @@ export interface DigestData {
  progress: string;
  streak: number;
  rest: boolean;
-  topic?: { name: string; core: TopicRow[] };
+  /** Topics taught today, in plan order — empty on every other day. */
+  topics: TopicSection[];
+  /** A set day's problems, assigned by number rather than by topic. */
+  assigned?: TopicRow[];
  reviews: DigestRow[];
  /** Reviews past the daily cap; levelled onto the coming days. */
  carried: number;
  drills: DigestRow[];
+  /** A sweep day's miss log: present (even empty) only on a sweep day. */
+  sweep?: DigestRow[];
  gate?: { week: number; url: string };
  yesterday: { total: number; failed: number[] };
  gateRate?: number;
@@ -278,10 +290,15 @@ function Block({
 // ── email ────────────────────────────────────────────────────────

 function DigestEmail({ data }: { data: DigestData }) {
-  const load = data.reviews.length + data.drills.length;
-  const preview = data.rest
-    ? "Rest day — nothing to do but rest."
-    : `${load} to work through today${data.topic ? `, starting with ${data.topic.name}` : ""}.`;
+  const load = data.reviews.length + data.drills.length + (data.sweep?.length ?? 0);
+  const lead = data.topics[0]
+    ? `, starting with ${data.topics[0].name}`
+    : data.assigned
+      ? ", starting with today's set"
+      : data.sweep
+        ? " — sweep day, nothing new"
+        : "";
+  const preview = data.rest ? "Rest day — nothing to do but rest." : `${load} to work through today${lead}.`;

  const passed = data.yesterday.total - data.yesterday.failed.length;
  const missed = data.yesterday.failed.map((lc) => `LC ${lc}`).join(", ");
@@ -310,15 +327,47 @@ function DigestEmail({ data }: { data: DigestData }) {

            {data.rest ? null : (
              <>
-                {data.topic ? (
-                  <Section style={{ marginTop: "28px" }}>
-                    <Text style={label}>Something new today</Text>
+                {data.topics.map((topic, i) => (
+                  <Section key={topic.name} style={{ marginTop: i === 0 ? "28px" : "20px" }}>
+                    {i === 0 ? (
+                      <Text style={label}>
+                        {data.topics.length === 1 ? "Something new today" : "Two new things today"}
+                      </Text>
+                    ) : null}
                    <Text style={{ color: INK, fontSize: "16px", fontWeight: 600, margin: "0 0 8px" }}>
-                      {data.topic.name}
+                      {topic.name}
                    </Text>
                    <Text style={hint}>Work through these from the top — a tick means it is already solved.</Text>
-                    <TopicTable rows={data.topic.core} />
+                    <TopicTable rows={topic.core} />
+                    {topic.ifTime.length > 0 ? (
+                      <>
+                        <Text style={{ ...hint, margin: "12px 0 8px" }}>
+                          If time — only once the core is done inside the clock.
+                        </Text>
+                        <TopicTable rows={topic.ifTime} />
+                      </>
+                    ) : null}
                  </Section>
+                ))}
+
+                {data.assigned ? (
+                  <Section style={{ marginTop: "28px" }}>
+                    <Text style={label}>Today's set</Text>
+                    <Text style={hint}>
+                      Picked by number, not by topic — all of them, in order, inside the clock.
+                    </Text>
+                    <TopicTable rows={data.assigned} />
+                  </Section>
+                ) : null}
+
+                {data.sweep ? (
+                  <Block
+                    title="Sweep — redo every red"
+                    note="Every problem still standing on a miss. Nothing new today; clear these first."
+                    rows={data.sweep}
+                    staged
+                    empty="The miss log is clear — nothing is standing on a fail."
+                  />
                ) : null}

                <Block
@@ -409,16 +458,27 @@ function plainDigest(data: DigestData): string {
          : ` · ${data.streak} day${data.streak === 1 ? "" : "s"} in a row, keep it going.`),
  ];

+  const linked = (p: TopicRow) =>
+    `  LC ${p.lc} — ${DIFFICULTY[p.difficulty]?.label ?? p.difficulty}${p.solved ? " (done)" : ""} — ${p.url}`;
+
  if (!data.rest) {
-    if (data.topic) {
+    for (const topic of data.topics) {
      out.push(
        "",
-        `SOMETHING NEW TODAY — ${data.topic.name}`,
+        `SOMETHING NEW TODAY — ${topic.name}`,
        "Work through these from the top; the ones marked done you have already solved.",
-        ...data.topic.core.map(
-          (p) =>
-            `  LC ${p.lc} — ${DIFFICULTY[p.difficulty]?.label ?? p.difficulty}${p.solved ? " (done)" : ""} — ${p.url}`,
-        ),
+        ...topic.core.map(linked),
+      );
+      if (topic.ifTime.length > 0) {
+        out.push("  If time — only once the core is done inside the clock:", ...topic.ifTime.map(linked));
+      }
+    }
+    if (data.assigned) {
+      out.push(
+        "",
+        "TODAY'S SET",
+        "Picked by number, not by topic — all of them, in order, inside the clock.",
+        ...data.assigned.map(linked),
      );
    }

@@ -436,6 +496,14 @@ function plainDigest(data: DigestData): string {
        "No cold starts today.",
      ],
    ];
+    if (data.sweep) {
+      lists.unshift([
+        "SWEEP — REDO EVERY RED",
+        "Every problem still standing on a miss. Nothing new today; clear these first.",
+        data.sweep,
+        "The miss log is clear — nothing is standing on a fail.",
+      ]);
+    }
    for (const [title, note, rows, empty] of lists) {
      out.push("", title);
      if (rows.length === 0) {
@@ -2,21 +2,27 @@
 * Saturday review issue: created at midnight ET so the 8 AM digest can link
 * to it; scored when the issue closes (webhook).
 *
- * The gate half is a topic-blind quiz — one unsolved optional problem per
- * topic scheduled this week (which is why daily drills only draw from
- * earlier weeks). The recap half is generated data, deliberately NOT a task
- * list: the week's solved problems are already scheduled by the +3/+7 ladder,
- * and re-assigning them on Saturday would be massed practice.
+ * The gate half is a topic-blind quiz. When the plan fixes the set
+ * (`gate` in data/schedule.json) that list IS the gate, verbatim — every
+ * number must be a catalog problem, or the issue is not created, because a
+ * `/done` on an uncatalogued number can never be logged. Otherwise the set
+ * is sampled: one unsolved optional problem per topic scheduled this week
+ * (which is why daily drills only draw from earlier weeks), never one the
+ * plan has reserved. The recap half is generated data, deliberately NOT a
+ * task list: the week's solved problems are already scheduled by the +3/+7
+ * ladder, and re-assigning them on Saturday would be massed practice.
 *
 * Label is `review` (the retired Actions system owned `gate`). Creation is
- * idempotent by week; deferred Hards never appear.
+ * idempotent by week; deferred Hards never appear in a sampled set.
 */
 import {
  type ProblemRow,
+  RESERVED,
  type Result,
  SCHEDULE,
  campaignWeek,
  isoWeek,
+  lookupProblems,
  rng,
  sample,
  streak,
@@ -32,7 +38,7 @@ function capitalized(difficulty: string): string {
  return difficulty[0]!.toUpperCase() + difficulty.slice(1);
 }

-/** Unsolved problems of a topic in a set — never attempted, never drilled. */
+/** Unsolved problems of a topic in a set — never attempted, drilled, or reserved. */
 async function freshPool(db: D1Database, topic: number, set: string): Promise<ProblemRow[]> {
  const { results } = await db
    .prepare(
@@ -44,7 +50,7 @@ async function freshPool(db: D1Database, topic: number, set: string): Promise<Pr
    )
    .bind(topic, set)
    .all<ProblemRow>();
-  return results;
+  return results.filter((p) => !RESERVED.has(p.lc_number));
 }

 export interface CreateReport {
@@ -67,40 +73,52 @@ export async function createReviewIssue(env: Env, gh: GitHub, date: string): Pro
    return { created: false, issue: existing.issue, reason: `${title} exists (#${existing.issue})` };
  }

-  // Topics scheduled this week; review-only weeks (Sep 23 onward) sample
-  // across every topic that still has unsolved optional problems.
-  let topics = Object.entries(SCHEDULE)
-    .filter(([d]) => campaignWeek(d) === week)
-    .sort(([a], [b]) => (a < b ? -1 : 1))
-    .map(([, t]) => t);
-  if (topics.length === 0) {
-    const { results } = await db
-      .prepare(
-        `SELECT DISTINCT topic_issue AS t FROM problems
-         WHERE set_label = 'optional' AND stage = 'new'
-           AND lc_number NOT IN (SELECT lc_number FROM drill_pool_used)
-         ORDER BY topic_issue`,
-      )
-      .all<{ t: number }>();
-    topics = sample(results.map((r) => r.t), MAX_GATE_PROBLEMS, rng(`gate-topics-${iso}`)).sort(
-      (a, b) => a - b,
-    );
-  }
-  if (topics.length === 0) return { created: false, reason: "no topics with unsolved pools" };
-
-  const random = rng(`gate-${iso}`);
+  // The plan's fixed set wins; otherwise sample this week's topics, and in a
+  // week without topics, across every topic that still has an unsolved pool.
  const picks: { p: ProblemRow; fallback: boolean }[] = [];
-  for (const topic of topics) {
-    const optional = await freshPool(db, topic, "optional");
-    if (optional.length > 0) {
-      picks.push({ p: sample(optional, 1, random)[0]!, fallback: false });
-      continue;
+  const planned = SCHEDULE[date]?.gate;
+  if (planned) {
+    const { rows, missing } = await lookupProblems(db, planned);
+    if (missing.length) {
+      return {
+        created: false,
+        reason: `planned gate names problems outside the catalog: LC ${missing.join(", LC ")}`,
+      };
    }
-    const core = await freshPool(db, topic, "core");
-    if (core.length > 0) picks.push({ p: sample(core, 1, random)[0]!, fallback: true });
-    // Both pools exhausted: the topic is fully solved; nothing to quiz.
+    picks.push(...rows.map((p) => ({ p, fallback: false })));
+  } else {
+    let topics = Object.entries(SCHEDULE)
+      .filter(([d]) => campaignWeek(d) === week)
+      .sort(([a], [b]) => (a < b ? -1 : 1))
+      .flatMap(([, day]) => day.topics ?? []);
+    if (topics.length === 0) {
+      const { results } = await db
+        .prepare(
+          `SELECT DISTINCT topic_issue AS t FROM problems
+           WHERE set_label = 'optional' AND stage = 'new'
+             AND lc_number NOT IN (SELECT lc_number FROM drill_pool_used)
+           ORDER BY topic_issue`,
+        )
+        .all<{ t: number }>();
+      topics = sample(results.map((r) => r.t), MAX_GATE_PROBLEMS, rng(`gate-topics-${iso}`)).sort(
+        (a, b) => a - b,
+      );
+    }
+    if (topics.length === 0) return { created: false, reason: "no topics with unsolved pools" };
+
+    const random = rng(`gate-${iso}`);
+    for (const topic of topics) {
+      const optional = await freshPool(db, topic, "optional");
+      if (optional.length > 0) {
+        picks.push({ p: sample(optional, 1, random)[0]!, fallback: false });
+        continue;
+      }
+      const core = await freshPool(db, topic, "core");
+      if (core.length > 0) picks.push({ p: sample(core, 1, random)[0]!, fallback: true });
+      // Both pools exhausted: the topic is fully solved; nothing to quiz.
+    }
+    if (picks.length === 0) return { created: false, reason: `every pool for week ${week} is exhausted` };
  }
-  if (picks.length === 0) return { created: false, reason: `every pool for week ${week} is exhausted` };

  // Recap: everything attempted this week, plus streak — data, not tasks.
  const monday = weekMonday(date);
@@ -154,7 +172,7 @@ export async function createReviewIssue(env: Env, gh: GitHub, date: string): Pro

  const milestone = await db
    .prepare("SELECT milestone FROM topics WHERE issue = ? AND milestone IS NOT NULL")
-    .bind(topics[0])
+    .bind(picks[0]!.p.topic_issue)
    .first<{ milestone: number }>();

  const created = (await gh.rest(`/repos/${gh.repo}/issues`, {
@@ -8,6 +8,8 @@ import { describe, expect, test } from "bun:test";

 import {
  INTERVAL,
+  RESERVED,
+  SCHEDULE,
  STAGES,
  WINDOWS,
  addDays,
@@ -19,6 +21,9 @@ import {
  isoWeek,
  rng,
  sample,
+  TEMPERATURES,
+  temperatureOf,
+  topicDate,
  weekdayOf,
  workingDay,
 } from "./srs.ts";
@@ -123,6 +128,38 @@ describe("the rest day", () => {
  });
 });

+describe("the plan", () => {
+  test("never books the rest day, and gates only on Saturday", () => {
+    for (const [date, day] of Object.entries(SCHEDULE)) {
+      expect(isRestDay(date)).toBe(false);
+      if (day.gate) expect(weekdayOf(date)).toBe(6);
+      if (day.topics) expect(weekdayOf(date)).toBeLessThan(6);
+    }
+  });
+
+  test("a topic is taught once; a doubled day answers for both", () => {
+    const seen = new Set<number>();
+    for (const day of Object.values(SCHEDULE)) {
+      for (const topic of day.topics ?? []) {
+        expect(seen.has(topic)).toBe(false);
+        seen.add(topic);
+      }
+    }
+    expect(topicDate(17)).toBe("2026-09-21");
+    expect(topicDate(18)).toBe("2026-09-21");
+    expect(topicDate(999)).toBeUndefined();
+  });
+
+  test("every gate and set problem is reserved from the samplers", () => {
+    for (const day of Object.values(SCHEDULE)) {
+      for (const lc of [...(day.gate ?? []), ...(day.problems ?? [])]) {
+        expect(RESERVED.has(lc)).toBe(true);
+      }
+    }
+    expect(RESERVED.size).toBeGreaterThan(0);
+  });
+});
+
 describe("the ladder", () => {
  test("two rungs, named after the windows", () => {
    expect(STAGES).toEqual(["new", "+3", "+7", "retired"]);
@@ -132,6 +169,31 @@ describe("the ladder", () => {
  });
 });

+describe("concept temperature", () => {
+  test("the bands are the ladder's own windows", () => {
+    // Boundaries are inclusive, and the bands tile the whole age axis with no
+    // gap: whatever the windows become, every age still lands in exactly one.
+    expect(TEMPERATURES).toEqual(["hot", "fresh", "fading", "cold"]);
+    expect(temperatureOf(0)).toBe("hot");
+    expect(temperatureOf(WINDOWS[0])).toBe("hot");
+    expect(temperatureOf(WINDOWS[0] + 1)).toBe("fresh");
+    expect(temperatureOf(WINDOWS[1])).toBe("fresh");
+    expect(temperatureOf(WINDOWS[1] + 1)).toBe("fading");
+    expect(temperatureOf(WINDOWS[1] * 2)).toBe("fading");
+    expect(temperatureOf(WINDOWS[1] * 2 + 1)).toBe("cold");
+  });
+
+  test("never attempted is cold, not unknown", () => {
+    expect(temperatureOf(null)).toBe("cold");
+  });
+
+  test("every age of the campaign has exactly one band", () => {
+    for (let age = 0; age <= CALENDAR.length; age++) {
+      expect(TEMPERATURES).toContain(temperatureOf(age));
+    }
+  });
+});
+
 describe("deterministic sampling", () => {
  test("same seed, same picks", () => {
    const pool = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
@@ -1,6 +1,6 @@
 /**
- * SRS domain: ET dates, the work week, the interval ladder, deterministic
- * sampling, and the one write path for attempts.
+ * SRS domain: ET dates, the work week, the interval ladder, concept
+ * temperature, deterministic sampling, and the one write path for attempts.
 *
 * D1 is the single source of truth. The stage names the review a problem must
 * pass NEXT (`+3` = due 3 working days after the last clean solve). Passing
@@ -126,16 +126,50 @@ export function prettyDate(date: string): string {

 // ── the schedule (bundled; humans edit apps/api/data/schedule.json) ───

-export const SCHEDULE: Record<string, number> = scheduleJson;
+/**
+ * One calendar day of the plan. Most days teach topics (one, or two when the
+ * plan doubles up); the rest are named by what they assign instead: a fixed
+ * gate set for Saturday's review issue, a fixed problem set (a "B-set" day),
+ * or a sweep — redo every miss, nothing new. Absent dates are unplanned:
+ * the ladder still runs, the digest just has nothing new to say.
+ */
+export interface ScheduledDay {
+  /** Topic issues taught that day, in the order the digest presents them. */
+  topics?: number[];
+  /** Problems assigned by number instead of by topic. */
+  problems?: number[];
+  /** Saturday: the blind set, fixed by the plan rather than sampled. */
+  gate?: number[];
+  /** Miss-log sweep: every problem whose last attempt failed, and no new ones. */
+  sweep?: boolean;
+}

-/** Week in which a topic was (or will be) taught. */
-export function topicWeek(topic: number): number | undefined {
-  for (const [date, t] of Object.entries(SCHEDULE)) {
-    if (t === topic) return campaignWeek(date);
+export const SCHEDULE: Record<string, ScheduledDay> = scheduleJson;
+
+/** Date the schedule teaches a topic on, if it teaches it at all. */
+export function topicDate(topic: number): string | undefined {
+  for (const [date, day] of Object.entries(SCHEDULE)) {
+    if (day.topics?.includes(topic)) return date;
  }
  return undefined;
 }

+/** Week in which a topic was (or will be) taught. */
+export function topicWeek(topic: number): number | undefined {
+  const date = topicDate(topic);
+  return date === undefined ? undefined : campaignWeek(date);
+}
+
+/**
+ * Every problem the plan names outright — a gate's blind set or a set day's
+ * list. The plan owns these: the samplers (daily drills, a sampled gate)
+ * never draw them, so a gate problem stays unseen until its Saturday and a
+ * set day's problems wait for their day.
+ */
+export const RESERVED: ReadonlySet<number> = new Set(
+  Object.values(SCHEDULE).flatMap((day) => [...(day.gate ?? []), ...(day.problems ?? [])]),
+);
+
 // ── deterministic sampling ───────────────────────────────────────

 /** FNV-1a → mulberry32: seeded PRNG so re-runs pick identical problems. */
@@ -182,6 +216,45 @@ export const STAGES: Stage[] = ["new", "+3", "+7", "retired"];
 export type Result = "pass" | "fail";
 export type Kind = "first" | "review" | "drill" | "gate";

+/**
+ * Catalog vocabulary, carried by the `diff:*` / `set:*` issue labels and
+ * stored verbatim in `problems`. Listed low to high / most to least required,
+ * which is the order every chart, table and digest section prints them in.
+ */
+export const DIFFICULTIES = ["easy", "medium", "hard"] as const;
+export type Difficulty = (typeof DIFFICULTIES)[number];
+export const SETS = ["core", "optional", "deferred"] as const;
+export type SetLabel = (typeof SETS)[number];
+
+/**
+ * How warm a concept is: the age of a topic's most recent attempt, bucketed by
+ * the ladder's own windows so the two cannot drift. Touched inside the first
+ * window it is `hot`, inside the second `fresh`, inside one more full second
+ * window `fading`; older than that — or never attempted — it is `cold`.
+ *
+ * A read-side label only: nothing is scheduled off it. It answers the question
+ * the ladder cannot, because the ladder tracks problems and a topic can go
+ * quiet for a fortnight while not one of its problems comes due.
+ */
+export const TEMPERATURES = ["hot", "fresh", "fading", "cold"] as const;
+export type Temperature = (typeof TEMPERATURES)[number];
+
+/** Warmest band first, with the age it tolerates. Past the last one is cold. */
+const TEMPERATURE_MAX_AGE: [Temperature, number][] = [
+  ["hot", WINDOWS[0]],
+  ["fresh", WINDOWS[1]],
+  ["fading", WINDOWS[1] * 2],
+];
+
+/** Days since a topic's last attempt → its band; null (never) is cold. */
+export function temperatureOf(age: number | null): Temperature {
+  if (age === null) return "cold";
+  for (const [temperature, max] of TEMPERATURE_MAX_AGE) {
+    if (age <= max) return temperature;
+  }
+  return "cold";
+}
+
 export interface ProblemRow {
  lc_number: number;
  issue: number;
@@ -203,6 +276,31 @@ export async function getProblem(db: D1Database, lc: number): Promise<ProblemRow
  return db.prepare("SELECT * FROM problems WHERE lc_number = ?").bind(lc).first<ProblemRow>();
 }

+/**
+ * Catalog rows for a list of numbers the plan names, in the plan's order,
+ * plus the numbers the catalog does not know — a planned problem without an
+ * issue can never be logged, so callers decide whether that is fatal.
+ */
+export async function lookupProblems(
+  db: D1Database,
+  lcs: number[],
+): Promise<{ rows: ProblemRow[]; missing: number[] }> {
+  if (lcs.length === 0) return { rows: [], missing: [] };
+  const { results } = await db
+    .prepare(`SELECT * FROM problems WHERE lc_number IN (${lcs.map(() => "?").join(",")})`)
+    .bind(...lcs)
+    .all<ProblemRow>();
+  const byNumber = new Map(results.map((p) => [p.lc_number, p]));
+  const rows: ProblemRow[] = [];
+  const missing: number[] = [];
+  for (const lc of lcs) {
+    const row = byNumber.get(lc);
+    if (row) rows.push(row);
+    else missing.push(lc);
+  }
+  return { rows, missing };
+}
+
 /**
 * What "due" means, in one place: not retired, scheduled on/before ?1, and
 * past its deferral if it has one. Every caller that asks "what is open on
@@ -313,8 +411,9 @@ export async function levelReviews(db: D1Database, date: string): Promise<number
 * scheduled in an earlier week (the current week's optional pool is reserved
 * for Saturday's gate) AND showing learning evidence: at least one of the
 * topic's core problems has entered the ladder. A skipped learning day never
- * feeds drills just because its calendar week lapsed. Never repeated,
- * seeded by date. Boosted topics contribute up to 2 extra.
+ * feeds drills just because its calendar week lapsed. Problems the plan names
+ * outright (RESERVED) are never drawn. Never repeated, seeded by date.
+ * Boosted topics contribute up to 2 extra.
 */
 export async function pickDrills(
  db: D1Database,
@@ -337,6 +436,7 @@ export async function pickDrills(
    )
    .all<ProblemRow & { boost: number }>();
  const pool = results.filter((p) => {
+    if (RESERVED.has(p.lc_number)) return false;
    const w = topicWeek(p.topic_issue);
    return w !== undefined && w < week;
  });
@@ -1,19 +1,29 @@
 /**
- * GET /api/stats — the one JSON document behind the docs progress page.
- * Read-only aggregation over D1; shape is the page's contract, change both
- * together. A problem counts as "done" once it entered the ladder
- * (stage != 'new').
+ * GET /api/stats — the one JSON document behind the docs progress page and the
+ * `bun run stats` terminal dashboard. Read-only aggregation over D1; the shape
+ * is both readers' contract, so change all three together. A problem counts as
+ * "done" once it entered the ladder (stage != 'new').
+ *
+ * The temperature block is the one figure here that is not a count of rows:
+ * srs.ts turns a topic's days-since-last-attempt into a band, so "which
+ * concepts have gone cold" has exactly one definition and the dashboard is
+ * free to colour it however it likes.
 */
 import {
  CAMPAIGN_DAYS,
  CAMPAIGN_START,
+  DIFFICULTIES,
  DUE_WHERE,
  addDays,
  campaignDay,
  campaignWeek,
+  daysBetween,
  isoWeek,
  STAGES,
  streak,
+  temperatureOf,
+  topicDate,
+  type Temperature,
 } from "./srs.ts";

 const PHASE_NAMES: Record<number, string> = {
@@ -24,6 +34,91 @@ const PHASE_NAMES: Record<number, string> = {
  5: "V — Decision Space",
 };

+/** One concept: catalog coverage plus how long since it was last exercised. */
+interface TopicStat {
+  issue: number;
+  name: string;
+  milestone: number | null;
+  /** Campaign week the schedule teaches it in; null when unscheduled. */
+  week: number | null;
+  /** False while the schedule has not reached it — temperature is moot. */
+  taught: boolean;
+  total: number;
+  done: number;
+  retired: number;
+  due: number;
+  /** ET date of the most recent attempt on any of its problems. */
+  last: string | null;
+  /** Days since `last`; null when never attempted. */
+  age: number | null;
+  temperature: Temperature;
+}
+
+async function buildTopics(db: D1Database, today: string): Promise<TopicStat[]> {
+  // Three shapes, three statements: batch() carries one row type, and casting
+  // its results apart would cost more than the round trips it saves.
+  const { results: coverage } = await db
+    .prepare(
+      `SELECT t.issue AS issue, t.name AS name, t.milestone AS milestone,
+              COUNT(p.lc_number) AS total,
+              SUM(CASE WHEN p.stage != 'new' THEN 1 ELSE 0 END) AS done,
+              SUM(CASE WHEN p.stage = 'retired' THEN 1 ELSE 0 END) AS retired
+       FROM topics t LEFT JOIN problems p ON p.topic_issue = t.issue
+       GROUP BY t.issue
+       ORDER BY t.issue`,
+    )
+    .all<{
+      issue: number;
+      name: string;
+      milestone: number | null;
+      total: number;
+      done: number | null;
+      retired: number | null;
+    }>();
+
+  const { results: activity } = await db
+    .prepare(
+      `SELECT p.topic_issue AS issue, MAX(a.date) AS last
+       FROM attempts a JOIN problems p ON p.lc_number = a.lc_number
+       GROUP BY p.topic_issue`,
+    )
+    .all<{ issue: number; last: string | null }>();
+  const lastByTopic = new Map<number, string>();
+  for (const row of activity) {
+    if (row.last) lastByTopic.set(row.issue, row.last);
+  }
+
+  const { results: dueRows } = await db
+    .prepare(
+      `SELECT topic_issue AS issue, COUNT(*) AS n
+       FROM problems WHERE ${DUE_WHERE} GROUP BY topic_issue`,
+    )
+    .bind(today)
+    .all<{ issue: number; n: number }>();
+  const dueByTopic = new Map<number, number>();
+  for (const row of dueRows) dueByTopic.set(row.issue, row.n);
+
+  return coverage.map((row) => {
+    const taughtOn = topicDate(row.issue);
+    const last = lastByTopic.get(row.issue) ?? null;
+    const age = last === null ? null : daysBetween(last, today);
+    return {
+      issue: row.issue,
+      name: row.name,
+      milestone: row.milestone,
+      week: taughtOn === undefined ? null : campaignWeek(taughtOn),
+      taught: taughtOn !== undefined && taughtOn <= today,
+      total: row.total,
+      done: row.done ?? 0,
+      retired: row.retired ?? 0,
+      due: dueByTopic.get(row.issue) ?? 0,
+      last,
+      age,
+      temperature: temperatureOf(age),
+    };
+  });
+}
+
 export async function buildStats(db: D1Database, today: string): Promise<object> {
  const { results: phaseRows } = await db
    .prepare(
@@ -65,6 +160,21 @@ export async function buildStats(db: D1Database, today: string): Promise<object>
  const ladder: Record<string, number> = Object.fromEntries(STAGES.map((s) => [s, 0]));
  for (const row of ladderRows) ladder[row.stage] = row.n;

+  // Same shape as `ladder`: every band present, zeros included, in DIFFICULTIES
+  // order so a reader can index it without sorting.
+  const { results: diffRows } = await db
+    .prepare(
+      `SELECT difficulty,
+              COUNT(*) AS total,
+              SUM(CASE WHEN stage != 'new' THEN 1 ELSE 0 END) AS done
+       FROM problems GROUP BY difficulty`,
+    )
+    .all<{ difficulty: string; total: number; done: number }>();
+  const difficulty = DIFFICULTIES.map((name) => {
+    const row = diffRows.find((r) => r.difficulty === name);
+    return { difficulty: name, total: row?.total ?? 0, done: row?.done ?? 0 };
+  });
+
  // gates rows are keyed by ISO week (that's the digest/gate contract), but
  // the page speaks campaign weeks. The campaign never crosses a year
  // boundary, so a plain offset converts safely.
@@ -74,39 +184,47 @@ export async function buildStats(db: D1Database, today: string): Promise<object>
    .all<{ week: number; issue: number | null; pass_rate: number | null; closed_on: string | null }>();
  const gates = gateRows.map((g) => ({ ...g, week: g.week - isoWeekOffset }));

-  // Review-queue depth for the next 14 days: everything due by that day.
-  const queue: { date: string; due: number }[] = [];
-  for (let i = 0; i < 14; i++) {
-    const date = addDays(today, i);
-    const row = await db
-      .prepare(`SELECT COUNT(*) AS n FROM problems WHERE ${DUE_WHERE}`)
-      .bind(date)
-      .first<{ n: number }>();
-    queue.push({ date, due: row?.n ?? 0 });
-  }
+  // Review-queue depth for the next 14 days: everything due by that day. One
+  // statement per day, but DUE_WHERE stays the only definition of "due" — the
+  // batch is a single round trip, not fourteen.
+  const dates = Array.from({ length: 14 }, (_, i) => addDays(today, i));
+  const queueRows = await db.batch<{ n: number }>(
+    dates.map((date) =>
+      db.prepare(`SELECT COUNT(*) AS n FROM problems WHERE ${DUE_WHERE}`).bind(date),
+    ),
+  );
+  const queue = dates.map((date, i) => ({ date, due: queueRows[i]?.results[0]?.n ?? 0 }));

-  const recent: { date: string; attempts: number; passes: number }[] = [];
-  for (let i = 6; i >= 0; i--) {
-    const date = addDays(today, -i);
-    const row = await db
-      .prepare(
-        `SELECT COUNT(*) AS attempts,
-                SUM(CASE WHEN result = 'pass' THEN 1 ELSE 0 END) AS passes
-         FROM attempts WHERE date = ?`,
-      )
-      .bind(date)
-      .first<{ attempts: number; passes: number | null }>();
-    recent.push({ date, attempts: row?.attempts ?? 0, passes: row?.passes ?? 0 });
-  }
+  // Attempts per campaign day, every day present. This is the heatmap's data
+  // model — the docs page reads the tail of it for "last 7 days" rather than
+  // asking a second question that could answer differently.
+  const end = addDays(CAMPAIGN_START, CAMPAIGN_DAYS - 1);
+  const { results: heatRows } = await db
+    .prepare(
+      `SELECT date,
+              COUNT(*) AS attempts,
+              SUM(CASE WHEN result = 'pass' THEN 1 ELSE 0 END) AS passes
+       FROM attempts WHERE date BETWEEN ?1 AND ?2 GROUP BY date`,
+    )
+    .bind(CAMPAIGN_START, end)
+    .all<{ date: string; attempts: number; passes: number | null }>();
+  const byDate = new Map(heatRows.map((r) => [r.date, r]));
+  const heat = Array.from({ length: CAMPAIGN_DAYS }, (_, i) => {
+    const date = addDays(CAMPAIGN_START, i);
+    const row = byDate.get(date);
+    return { date, attempts: row?.attempts ?? 0, passes: row?.passes ?? 0 };
+  });

  return {
    generated: new Date().toISOString(),
    campaign: { day: campaignDay(today), week: campaignWeek(today), start: CAMPAIGN_START, days: CAMPAIGN_DAYS },
    phases: [...phases.values()],
    ladder,
+    difficulty,
+    topics: await buildTopics(db, today),
    gates,
    streak: await streak(db, today),
    queue,
-    recent,
+    heat,
  };
 }
@@ -0,0 +1,87 @@
+/**
+ * The SRS Worker, from the CLI side: one base URL and one read-side payload.
+ *
+ * `SRS_API` points a script at a `wrangler dev` instance instead of production
+ * — the same switch close-solved.ts uses for its `/admin/solved` push, which is
+ * why the default lives here rather than in either script.
+ *
+ * The payload is narrowed with a guard rather than cast: D1 is the only source
+ * of SRS truth, so if the Worker answers something else the caller must say so
+ * out loud, not render half a dashboard off undefined fields.
+ */
+import { STAGES, TEMPERATURES, type Stage, type Temperature } from "../api/src/srs.ts";
+
+export const SRS_API = process.env.SRS_API ?? "https://srs-api.prdlk.workers.dev";
+
+// The rungs and the bands come straight from the Worker's domain module — the
+// same import work.ts makes for WINDOWS — so a change to either vocabulary
+// reaches this dashboard without a second list to remember.
+export { STAGES, TEMPERATURES, type Stage, type Temperature };
+
+export interface Phase {
+  milestone: number;
+  name: string;
+  core_done: number;
+  core_total: number;
+  optional_done: number;
+  optional_total: number;
+  deferred_done: number;
+  deferred_total: number;
+}
+
+export interface Topic {
+  issue: number;
+  name: string;
+  milestone: number | null;
+  week: number | null;
+  taught: boolean;
+  total: number;
+  done: number;
+  retired: number;
+  due: number;
+  last: string | null;
+  age: number | null;
+  temperature: Temperature;
+}
+
+export interface Stats {
+  generated: string;
+  campaign: { day: number; week: number; start: string; days: number };
+  phases: Phase[];
+  ladder: Record<Stage, number>;
+  difficulty: { difficulty: string; total: number; done: number }[];
+  topics: Topic[];
+  /** week is the 1-based campaign week — the Worker converts from ISO. */
+  gates: { week: number; issue: number | null; pass_rate: number | null; closed_on: string | null }[];
+  streak: number;
+  queue: { date: string; due: number }[];
+  /** Every campaign day, zeros and future days included. */
+  heat: { date: string; attempts: number; passes: number }[];
+}
+
+function isStats(value: unknown): value is Stats {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  return (
+    typeof v.campaign === "object" &&
+    v.campaign !== null &&
+    typeof v.ladder === "object" &&
+    v.ladder !== null &&
+    typeof v.streak === "number" &&
+    Array.isArray(v.phases) &&
+    Array.isArray(v.difficulty) &&
+    Array.isArray(v.topics) &&
+    Array.isArray(v.gates) &&
+    Array.isArray(v.queue) &&
+    Array.isArray(v.heat)
+  );
+}
+
+/** GET /api/stats. Throws with the reason; there is no local substitute. */
+export async function fetchStats(signal?: AbortSignal): Promise<Stats> {
+  const res = await fetch(`${SRS_API}/api/stats`, { signal });
+  if (!res.ok) throw new Error(`GET /api/stats -> ${res.status} ${await res.text()}`);
+  const body: unknown = await res.json();
+  if (!isStats(body)) throw new Error("GET /api/stats -> unrecognised payload shape");
+  return body;
+}
@@ -21,6 +21,7 @@
 */
 import { join } from "node:path";

+import { SRS_API } from "./api.ts";
 import { github } from "./github.ts";
 import { markdownTable, printTable, writeStepSummary } from "./report.ts";
 import { isImplemented } from "./source.ts";
@@ -162,7 +163,8 @@ for (const num of [...work.keys()].sort((a, b) => a - b)) {
 // rung named, so the whole implemented set can go over on every push (a total
 // recompute that backfills whatever earlier runs missed) and re-runs write
 // nothing.
-const SRS_API = process.env.SRS_API ?? "https://srs-api.prdlk.workers.dev";
+// SRS_API (apps/cli/api.ts) is the switch that points this at a wrangler dev
+// instance instead of production.
 const solved = [...work.entries()]
  .flatMap(([lc, entry]) => [...entry.solved].sort().map((bucket) => ({ lc, bucket })))
  .sort((a, b) => a.lc - b.lc || a.bucket - b.bucket);
@@ -4,6 +4,7 @@
  "type": "module",
  "scripts": {
    "pick": "bun ./pick.ts",
+    "stats": "bun ./stats.ts",
    "test": "bun ./test.ts",
    "submit": "bun ./submit.ts",
    "sync": "bun ./sync.ts",
@@ -0,0 +1,458 @@
+#!/usr/bin/env bun
+/**
+ * `bun run stats` — the campaign dashboard, in the terminal.
+ *
+ * Four panes over ONE source: GET /api/stats. D1 owns SRS state, so this
+ * fetches the Worker's aggregate rather than recomputing anything from work/
+ * or from git — a second answer to "how far along am I" is exactly the drift
+ * the campaign is built to avoid. The one local fact shown is the work/ file
+ * inventory, which is inventory, not schedule. Unreachable Worker = an error,
+ * never a reconstructed guess.
+ *
+ * The panes:
+ *   Overview  campaign clock, solved counts, phase bars, recent activity
+ *   Ladder    the +3/+7 rungs and the 14-day due queue
+ *   Concepts  every topic by temperature — what has gone cold
+ *   Activity  the campaign heatmap and the weekly gates
+ *
+ * Outside a TTY (a pipe, CI) it prints every pane once and exits, so the same
+ * command works in a scrollback or a file.
+ */
+import {
+  fetchStats,
+  SRS_API,
+  STAGES,
+  TEMPERATURES,
+  type Stats,
+  type Temperature,
+  type Topic,
+} from "./api.ts";
+import {
+  BLUE,
+  FG,
+  GREEN,
+  GREENS,
+  LINE,
+  MUTED,
+  RED,
+  YELLOW,
+  bar,
+  bold,
+  cell,
+  fg,
+  heatCell,
+  openScreen,
+  padTo,
+  rule,
+  sparkline,
+  stackedBar,
+  width,
+} from "./tui.ts";
+import { BUCKETS, WINDOWS, solvedInBucket } from "./work.ts";
+
+// ── shared vocabulary → colour ───────────────────────────────────
+
+// Temperature is an action ramp, not a thermometer: green is warm enough to
+// leave alone, red is the concept that wants revisiting. The band names carry
+// the heat, the colours carry the urgency — and the glyphs carry both again,
+// so a piped or NO_COLOR dashboard still separates the bands.
+const TEMP_COLOR: Record<Temperature, string> = {
+  hot: GREENS[4]!,
+  fresh: GREEN,
+  fading: YELLOW,
+  cold: RED,
+};
+
+const TEMP_GLYPH: Record<Temperature, string> = {
+  hot: "█",
+  fresh: "▓",
+  fading: "▒",
+  cold: "░",
+};
+
+const DIFF_COLOR: Record<string, string> = { easy: GREEN, medium: YELLOW, hard: RED };
+
+const LABEL = 15; // left-hand label column, shared by every pane
+
+/** "2026-08-31" → "Mon 31", read as a plain calendar date, never localised. */
+function dayLabel(iso: string): string {
+  const [y, m, d] = iso.split("-").map(Number);
+  const weekday = new Date(Date.UTC(y!, m! - 1, d!)).getUTCDay();
+  return `${["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][weekday]} ${String(d).padStart(2, "0")}`;
+}
+
+// ── overview ─────────────────────────────────────────────────────
+
+function overview(s: Stats, cols: number): string[] {
+  const bars = Math.max(10, Math.min(48, cols - LABEL - 18));
+  const lines: string[] = [];
+
+  const { day, days, week } = s.campaign;
+  lines.push(rule("campaign", cols));
+  lines.push(
+    `${cell("Day", LABEL)}${bar(day, days, bars)}  ${fg(FG, `${day}/${days}`)}` +
+      fg(MUTED, `  week ${week}`),
+  );
+  const streak = s.streak > 0 ? fg(GREENS[4]!, `${s.streak} day${s.streak === 1 ? "" : "s"}`) : fg(MUTED, "none");
+  lines.push(`${cell("Streak", LABEL)}${streak}`);
+
+  const total = s.difficulty.reduce((n, d) => n + d.total, 0);
+  const done = s.difficulty.reduce((n, d) => n + d.done, 0);
+  lines.push("");
+  lines.push(rule("solved", cols));
+  lines.push(
+    `${cell("All", LABEL)}${bar(done, total, bars)}  ${fg(FG, `${done}/${total}`)}` +
+      fg(MUTED, `  ${total > 0 ? Math.round((done / total) * 100) : 0}%`),
+  );
+  for (const d of s.difficulty) {
+    lines.push(
+      `${cell(d.difficulty, LABEL)}${bar(d.done, d.total, bars, DIFF_COLOR[d.difficulty] ?? GREEN)}` +
+        `  ${fg(MUTED, `${d.done}/${d.total}`)}`,
+    );
+  }
+
+  lines.push("");
+  lines.push(rule("phases", cols));
+  lines.push(
+    `${" ".repeat(LABEL)}${fg(GREEN, "█")} ${fg(MUTED, "core")}  ${fg(BLUE, "█")} ${fg(MUTED, "optional")}  ` +
+      `${fg(RED, "█")} ${fg(MUTED, "deferred")}  ${fg(LINE, "░")} ${fg(MUTED, "remaining")}`,
+  );
+  // Every phase bar is scaled to the LARGEST phase, not to itself: phases are
+  // not the same size, and equal-length bars would hide that.
+  const scale = Math.max(
+    1,
+    ...s.phases.map((p) => p.core_total + p.optional_total + p.deferred_total),
+  );
+  for (const p of s.phases) {
+    const phaseDone = p.core_done + p.optional_done + p.deferred_done;
+    const phaseTotal = p.core_total + p.optional_total + p.deferred_total;
+    const segments = [
+      { value: p.core_done, color: GREEN },
+      { value: p.optional_done, color: BLUE },
+      { value: p.deferred_done, color: RED },
+      { value: phaseTotal - phaseDone, color: LINE, glyph: "░" },
+    ];
+    lines.push(
+      `${cell(p.name, LABEL - 1)} ${stackedBar(segments, scale, bars)}  ${fg(MUTED, `${phaseDone}/${phaseTotal}`)}`,
+    );
+  }
+
+  lines.push("");
+  lines.push(rule("last 14 days", cols));
+  const window = s.heat.slice(Math.max(0, day - 14), day);
+  const attempts = window.reduce((n, h) => n + h.attempts, 0);
+  const passes = window.reduce((n, h) => n + h.passes, 0);
+  lines.push(
+    `${cell("Attempts", LABEL)}${sparkline(window.map((h) => h.attempts))}  ` +
+      fg(MUTED, `${attempts} attempts · ${passes} passed`),
+  );
+
+  // The one local fact on the dashboard: solutions on disk, per
+  // spaced-repetition bucket. Inventory, not schedule — D1's ladder is the
+  // schedule, and the Ladder pane is where it is shown. Empty scaffolds do not
+  // count, the same rule close-solved.ts closes issues by.
+  lines.push("");
+  lines.push(rule("work/ on disk", cols));
+  lines.push(
+    cell("Solutions", LABEL) +
+      BUCKETS.map((b) => `${fg(FG, String(solvedInBucket(b)))} ${fg(MUTED, `in work/${b}`)}`).join(
+        fg(MUTED, " · "),
+      ),
+  );
+
+  return lines;
+}
+
+// ── ladder ───────────────────────────────────────────────────────
+
+function ladder(s: Stats, cols: number): string[] {
+  const bars = Math.max(10, Math.min(48, cols - LABEL - 18));
+  const lines: string[] = [rule("ladder", cols)];
+  lines.push(fg(MUTED, `${" ".repeat(LABEL)}the review each problem owes next`));
+
+  const rungs = STAGES.map((stage) => s.ladder[stage] ?? 0);
+  const peak = Math.max(1, ...rungs);
+  STAGES.forEach((stage, i) => {
+    const n = rungs[i]!;
+    // new is the untouched pile and retired is the finished one; only the
+    // middle rungs are live work, so only they get the live colour.
+    const color = stage === "new" ? LINE : stage === "retired" ? GREENS[4]! : GREEN;
+    lines.push(`${cell(stage, LABEL)}${bar(n, peak, bars, color)}  ${fg(FG, String(n))}`);
+  });
+
+  lines.push("");
+  lines.push(rule("due queue", cols));
+  const today = s.queue[0];
+  lines.push(
+    fg(MUTED, `${" ".repeat(LABEL)}cumulative: everything the ladder wants by that day`) +
+      (today ? fg(FG, `  ·  ${today.due} due today`) : ""),
+  );
+  const depth = Math.max(1, ...s.queue.map((q) => q.due));
+  for (const q of s.queue) {
+    const color = q.due > 3 ? RED : q.due > 0 ? GREEN : LINE;
+    lines.push(
+      `${cell(dayLabel(q.date), LABEL)}${bar(q.due, depth, bars, color)}  ${fg(MUTED, String(q.due))}`,
+    );
+  }
+
+  return lines;
+}
+
+// ── concepts ─────────────────────────────────────────────────────
+
+/** Coldest first, and everything the schedule has not reached yet last. */
+function byUrgency(a: Topic, b: Topic): number {
+  if (a.taught !== b.taught) return a.taught ? -1 : 1;
+  return (
+    TEMPERATURES.indexOf(b.temperature) - TEMPERATURES.indexOf(a.temperature) ||
+    (b.age ?? Infinity) - (a.age ?? Infinity) ||
+    a.issue - b.issue
+  );
+}
+
+// Row layout: "● " + name + temp + coverage bar + done/total + last + due.
+// Everything but the name is fixed, so the name absorbs the terminal width.
+const TEMP_W = 7;
+const COVER_W = 10;
+const COUNT_W = 6;
+const AGE_W = 6;
+const DUE_W = 3;
+const CONCEPT_FIXED = 3 + (TEMP_W + 1) + (COVER_W + 1) + (COUNT_W + 1) + (AGE_W + 1) + DUE_W + 1;
+
+function concepts(s: Stats, cols: number): string[] {
+  const lines: string[] = [rule("concepts by temperature", cols)];
+  // Thresholds are the ladder's windows; print them rather than restate them.
+  const bands: [Temperature, string][] = [
+    ["hot", `≤${WINDOWS[0]}d`],
+    ["fresh", `≤${WINDOWS[1]}d`],
+    ["fading", `≤${WINDOWS[1] * 2}d`],
+    ["cold", "older, or never"],
+  ];
+  lines.push(
+    fg(MUTED, "  last exercised — ") +
+      bands
+        .map(([t, when]) => `${fg(TEMP_COLOR[t], `${TEMP_GLYPH[t]} ${t}`)} ${fg(MUTED, when)}`)
+        .join(fg(MUTED, " · ")),
+  );
+
+  const taught = s.topics.filter((t) => t.taught);
+  const counts = TEMPERATURES.map((t) => ({
+    value: taught.filter((x) => x.temperature === t).length,
+    color: TEMP_COLOR[t],
+    glyph: TEMP_GLYPH[t],
+  }));
+  lines.push("");
+  lines.push(`  ${stackedBar(counts, Math.max(1, taught.length), Math.max(10, Math.min(60, cols - 4)))}`);
+  lines.push(
+    `  ${TEMPERATURES.map((t, i) => `${fg(TEMP_COLOR[t], TEMP_GLYPH[t])} ${counts[i]!.value} ${fg(MUTED, t)}`).join("  ")}` +
+      fg(MUTED, `   of ${taught.length} taught so far`),
+  );
+
+  const nameW = Math.max(12, Math.min(34, cols - CONCEPT_FIXED));
+  lines.push("");
+  lines.push(
+    fg(
+      MUTED,
+      `   ${cell("concept", nameW)} ${cell("temp", TEMP_W)} ` +
+        `${cell("coverage", COVER_W + 1 + COUNT_W)} ${cell("last", AGE_W)} ${cell("due", DUE_W, "right")}`,
+    ),
+  );
+
+  for (const t of s.topics.slice().sort(byUrgency)) {
+    // An unreached concept has no temperature to report — it shows the week
+    // the schedule gets to it instead, so the list stays one list.
+    const color = t.taught ? TEMP_COLOR[t.temperature] : LINE;
+    const age =
+      !t.taught ? "—" : t.age === null ? "never" : t.age <= 0 ? "today" : `${t.age}d`;
+    lines.push(
+      ` ${fg(color, t.taught ? TEMP_GLYPH[t.temperature] : "·")} ${fg(t.taught ? FG : MUTED, cell(t.name, nameW))} ` +
+        `${fg(color, cell(t.taught ? t.temperature : `wk ${t.week ?? "?"}`, TEMP_W))} ` +
+        `${bar(t.done, t.total, COVER_W, t.taught ? GREEN : LINE)} ` +
+        `${fg(MUTED, cell(`${t.done}/${t.total}`, COUNT_W))} ${fg(MUTED, cell(age, AGE_W))} ` +
+        `${t.due > 0 ? fg(GREEN, cell(String(t.due), DUE_W, "right")) : fg(LINE, cell("·", DUE_W, "right"))}`,
+    );
+  }
+
+  return lines;
+}
+
+// ── activity ─────────────────────────────────────────────────────
+
+const WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+
+function activity(s: Stats, cols: number): string[] {
+  const lines: string[] = [rule("attempts per campaign day", cols)];
+  lines.push(fg(MUTED, "  the README heatmap, same ramp — Sunday is the rest day"));
+  lines.push("");
+
+  // CAMPAIGN_START is a Monday, so the grid is simply the series in weeks of
+  // seven: column = week, row = weekday, exactly as the SVG lays it out.
+  const weeks = Math.ceil(s.heat.length / 7);
+  lines.push(
+    `      ${fg(MUTED, Array.from({ length: weeks }, (_, w) => ` ${String(w + 1).padStart(2)}`).join(""))}`,
+  );
+  WEEKDAYS.forEach((name, row) => {
+    const cells = Array.from({ length: weeks }, (_, w) => {
+      const entry = s.heat[w * 7 + row];
+      if (entry === undefined) return "   ";
+      // The marker sits in the gutter, not inside the cell: a foreground
+      // escape within a background run would end the background early.
+      const marker = s.campaign.day - 1 === w * 7 + row ? fg(FG, "▸") : " ";
+      return marker + heatCell(entry.attempts, "  ");
+    }).join("");
+    lines.push(`  ${fg(MUTED, cell(name, 4))}${cells}`);
+  });
+  lines.push("");
+  lines.push(
+    `  ${fg(MUTED, "less ")}${GREENS.map((_, level) => heatCell(level, "  ")).join("")}${fg(MUTED, " more")}` +
+      fg(MUTED, "   · one cell per day, colour = attempts, ▸ marks today"),
+  );
+
+  lines.push("");
+  lines.push(rule("weekly gates", cols));
+  if (s.gates.length === 0) {
+    lines.push(fg(MUTED, "  no gate has been scored yet"));
+  }
+  const gateW = Math.max(10, Math.min(24, cols - 30));
+  for (const g of s.gates) {
+    // Gates were stored as an integer percent before they were stored as a
+    // fraction; both are in the table, so normalise on read.
+    const rate = g.pass_rate === null ? null : g.pass_rate <= 1 ? g.pass_rate : g.pass_rate / 100;
+    const color = rate === null ? LINE : rate >= 0.7 ? GREEN : RED;
+    lines.push(
+      `  ${fg(FG, cell(`Week ${g.week}`, 9))}` +
+        `${bar(rate ?? 0, 1, gateW, color)}` +
+        `  ${fg(color, cell(rate === null ? "open" : `${Math.round(rate * 100)}%`, 5))}` +
+        `  ${fg(MUTED, g.issue === null ? "" : `#${g.issue}`)}${fg(MUTED, g.closed_on ? `  closed ${g.closed_on}` : "")}`,
+    );
+  }
+
+  return lines;
+}
+
+// ── panes ────────────────────────────────────────────────────────
+
+const PANES: { name: string; render: (s: Stats, cols: number) => string[] }[] = [
+  { name: "Overview", render: overview },
+  { name: "Ladder", render: ladder },
+  { name: "Concepts", render: concepts },
+  { name: "Activity", render: activity },
+];
+
+// ── non-interactive: every pane, once ────────────────────────────
+
+let stats: Stats;
+try {
+  stats = await fetchStats();
+} catch (err) {
+  console.error(`stats: ${err instanceof Error ? err.message : String(err)}`);
+  console.error(`stats: D1 is the only source of SRS truth — nothing to fall back to (SRS_API=${SRS_API}).`);
+  process.exit(1);
+}
+
+if (!process.stdout.isTTY) {
+  const cols = 80;
+  for (const pane of PANES) {
+    console.log(bold(pane.name.toUpperCase()));
+    for (const line of pane.render(stats, cols)) console.log(line);
+    console.log("");
+  }
+  process.exit(0);
+}
+
+// ── interactive ──────────────────────────────────────────────────
+
+let pane = 0;
+let offset = 0;
+let note = "";
+
+// Quitting resolves this; the finally below is what restores the terminal, so
+// a thrown render never leaves the shell in raw mode on the alternate screen.
+const { promise: quit, resolve: leave } = Promise.withResolvers<void>();
+const screen = openScreen(onKey, draw);
+
+function frame(): string[] {
+  const cols = screen.columns;
+  const tabs = PANES.map((p, i) =>
+    i === pane ? bold(fg(FG, ` ${p.name} `)) : fg(MUTED, ` ${p.name} `),
+  ).join(fg(LINE, "│"));
+  const clock = fg(MUTED, `day ${stats.campaign.day}/${stats.campaign.days} · streak ${stats.streak}  `);
+  const header = padTo(tabs, Math.max(0, cols - width(clock))) + clock;
+
+  // header + rule + body + footer fills the terminal exactly.
+  const body = PANES[pane]!.render(stats, cols);
+  const height = Math.max(1, screen.rows - 3);
+  offset = Math.max(0, Math.min(offset, Math.max(0, body.length - height)));
+  const scrolled =
+    body.length > height ? ` · ${offset + 1}-${Math.min(offset + height, body.length)}/${body.length}` : "";
+
+  return [
+    header,
+    fg(LINE, "─".repeat(cols)),
+    ...body.slice(offset, offset + height),
+    fg(MUTED, `Tab/←→ pane · ↑↓ scroll · r refresh · q quit${scrolled}`) + (note ? `  ${fg(YELLOW, note)}` : ""),
+  ];
+}
+
+function draw(): void {
+  screen.draw(frame());
+}
+
+function onKey(chunk: string): void {
+  switch (chunk) {
+    // Raw mode delivers Ctrl-C as a byte, not a signal, so it is handled here.
+    case "q":
+    case "\x03":
+    case "\x1b":
+      leave();
+      return;
+    case "\t":
+    case "\x1b[C":
+    case "l":
+      pane = (pane + 1) % PANES.length;
+      offset = 0;
+      break;
+    case "\x1b[Z":
+    case "\x1b[D":
+    case "h":
+      pane = (pane + PANES.length - 1) % PANES.length;
+      offset = 0;
+      break;
+    case "\x1b[A":
+    case "k":
+      offset = Math.max(0, offset - 1);
+      break;
+    case "\x1b[B":
+    case "j":
+      offset += 1;
+      break;
+    case "r":
+      note = "refreshing…";
+      draw();
+      void fetchStats()
+        .then((fresh) => {
+          stats = fresh;
+          note = "";
+        })
+        .catch((err: unknown) => {
+          note = `refresh failed: ${err instanceof Error ? err.message : String(err)}`;
+        })
+        .finally(draw);
+      return;
+    default:
+      if (chunk >= "1" && chunk <= String(PANES.length)) {
+        pane = Number(chunk) - 1;
+        offset = 0;
+        break;
+      }
+      return;
+  }
+  draw();
+}
+
+try {
+  draw();
+  await quit;
+} finally {
+  screen.close();
+}
@@ -359,6 +359,24 @@ function ensureLabel(page: string, h: Header): string {
  return page.replace(/^sidebar:$/m, `sidebar:\n${label}`);
 }

+/**
+ * Offset just past the script-owned `## Solution` section: the next top-level
+ * heading that is not inside a code fence, or end of file. Sections a human
+ * appends after the solution (`## Explanation`, …) survive regeneration.
+ */
+function solutionEnd(page: string, from: number): number {
+  const lines = page.slice(from).split("\n");
+  let offset = from + lines[0]!.length + 1; // past the '## Solution' line itself
+  let fenced = false;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (line.startsWith("```")) fenced = !fenced;
+    else if (!fenced && line.startsWith("## ")) return offset;
+    offset += line.length + 1;
+  }
+  return page.length;
+}
+
 // Existing docs pages, keyed by leetcode number from the frontmatter title.
 const pages = new Map<number, string>(); // num -> path relative to DOCS
 for (const rel of (await Array.fromAsync(new Bun.Glob("**/*.mdx").scan(DOCS))).sort()) {
@@ -386,7 +404,9 @@ for (const sol of ordered) {
      report.push([workRef, existing, "ERROR: no '## Solution' heading"]);
      continue;
    }
-    const next = ensureLabel(page.slice(0, at) + solutionSection(sol), sol.header);
+    const tail = page.slice(solutionEnd(page, at));
+    const body = page.slice(0, at) + solutionSection(sol) + (tail ? `\n${tail}` : "");
+    const next = ensureLabel(body, sol.header);
    const actions: string[] = [];
    if (existing !== name) {
      await rename(join(DOCS, existing), join(DOCS, name));
@@ -0,0 +1,214 @@
+/**
+ * Terminal drawing primitives for the stats dashboard: colour, block-glyph
+ * charts, and the alternate-screen plumbing.
+ *
+ * Hand-rolled for the same reason apps/api/src/charts.ts and png.ts are — the
+ * repo carries near-zero runtime dependencies, and everything a progress
+ * dashboard needs is a bar, a sparkline and a coloured cell. The palette is
+ * charts.ts's, so the terminal, the README SVGs and the digest email are the
+ * same picture in three renderers.
+ *
+ * Side-effect-free on import except for reading the colour environment once;
+ * nothing is written to the terminal until openScreen() is called.
+ */
+
+// ── palette (apps/api/src/charts.ts) ─────────────────────────────
+
+export const FG = "#fafafa"; // zinc-50 text
+export const MUTED = "#a1a1aa"; // zinc-400 secondary text
+export const LINE = "#27272a"; // zinc-800 structure / empty track
+export const GREEN = "#16a34a"; // green-600 (core / pass)
+export const BLUE = "#2563eb"; // blue-600 (optional)
+export const YELLOW = "#eab308"; // yellow-500 (attention)
+export const RED = "#f87171"; // red-400 (fail, on dark)
+
+/** GitHub dark-mode contribution hues; level 0 is the empty cell. */
+export const GREENS = ["#27272a", "#0e4429", "#006d32", "#26a641", "#39d353"];
+
+// ── colour ───────────────────────────────────────────────────────
+
+/**
+ * Honour NO_COLOR and pipes, and let FORCE_COLOR override both — the dashboard
+ * is legible without colour, and `bun run stats | less -R` should still be.
+ */
+export const COLOR =
+  process.env.FORCE_COLOR !== undefined
+    ? process.env.FORCE_COLOR !== "0"
+    : process.env.NO_COLOR === undefined && process.stdout.isTTY === true;
+
+const RESET = "\x1b[0m";
+
+function channels(hex: string): string {
+  return `${parseInt(hex.slice(1, 3), 16)};${parseInt(hex.slice(3, 5), 16)};${parseInt(hex.slice(5, 7), 16)}`;
+}
+
+export function fg(hex: string, text: string): string {
+  return COLOR ? `\x1b[38;2;${channels(hex)}m${text}${RESET}` : text;
+}
+
+export function bg(hex: string, text: string): string {
+  return COLOR ? `\x1b[48;2;${channels(hex)}m${text}${RESET}` : text;
+}
+
+export function bold(text: string): string {
+  return COLOR ? `\x1b[1m${text}${RESET}` : text;
+}
+
+const ANSI = /\x1b\[[0-9;]*m/g;
+
+/** Printable width — every glyph used here is one cell wide. */
+export function width(text: string): number {
+  return text.replace(ANSI, "").length;
+}
+
+/** Pad or cut a *plain* string to exactly n cells; colour it afterwards. */
+export function cell(text: string, n: number, align: "left" | "right" = "left"): string {
+  const clipped = text.length > n ? `${text.slice(0, Math.max(0, n - 1))}…` : text;
+  return align === "left" ? clipped.padEnd(n) : clipped.padStart(n);
+}
+
+/** Pad an already-coloured string to n cells. */
+export function padTo(text: string, n: number): string {
+  return text + " ".repeat(Math.max(0, n - width(text)));
+}
+
+// ── charts ───────────────────────────────────────────────────────
+
+const EIGHTHS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"];
+const SPARKS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+
+/**
+ * Filled and empty. The two differ by GLYPH as well as by colour, so a bar
+ * still reads under NO_COLOR or in a pipe — every chart here has to survive
+ * `bun run stats > notes.txt`.
+ */
+const FILL = "█";
+const TRACK = "░";
+
+/**
+ * One bar over a muted track, `cells` wide. Sub-cell remainders use the
+ * eighth-block glyphs, so one solved problem out of 161 still shows.
+ */
+export function bar(value: number, total: number, cells: number, color = GREEN): string {
+  const units = Math.round(Math.max(0, Math.min(1, total > 0 ? value / total : 0)) * cells * 8);
+  const filled = FILL.repeat(Math.floor(units / 8)) + EIGHTHS[units % 8]!;
+  return fg(color, filled) + fg(LINE, TRACK.repeat(Math.max(0, cells - filled.length)));
+}
+
+export interface Segment {
+  value: number;
+  color: string;
+  /** Defaults to the solid block; pass TRACK-ish glyphs for "not done yet". */
+  glyph?: string;
+}
+
+/**
+ * Segments laid end to end, `total` mapped to `cells`. Anything short of
+ * `total` is left BLANK, not tracked: bars sharing a scale must show their
+ * different lengths. A caller wanting a visible remainder passes it as a
+ * segment of its own.
+ *
+ * Non-zero segments are floored but never vanish; the overshoot that floor
+ * creates is taken back from the widest segment, which can spare it.
+ */
+export function stackedBar(segments: Segment[], total: number, cells: number): string {
+  if (total <= 0) return " ".repeat(cells);
+  const widths = segments.map((s) =>
+    s.value > 0 ? Math.max(1, Math.floor((s.value / total) * cells)) : 0,
+  );
+  let over = widths.reduce((a, b) => a + b, 0) - cells;
+  while (over > 0) {
+    const i = widths.indexOf(Math.max(...widths));
+    if (widths[i]! <= 1) break;
+    widths[i]!--;
+    over--;
+  }
+  const drawn = widths.map((n, i) => fg(segments[i]!.color, (segments[i]!.glyph ?? FILL).repeat(n)));
+  return drawn.join("") + " ".repeat(Math.max(0, cells - widths.reduce((a, b) => a + b, 0)));
+}
+
+/**
+ * One cell of the campaign heatmap. With colour it is the GREENS ramp the
+ * README and the digest use; without it, the same five levels as shading.
+ */
+export function heatCell(attempts: number, body: string): string {
+  const level = Math.min(attempts, GREENS.length - 1);
+  return COLOR ? bg(GREENS[level]!, body) : [" ", "·", "▒", "▓", "█"][level]!.repeat(body.length);
+}
+
+/** One glyph per value, scaled to the largest. All-zero renders as a floor. */
+export function sparkline(values: number[], color = GREEN): string {
+  const peak = Math.max(...values, 0);
+  const line = values
+    .map((v) => (peak === 0 ? SPARKS[0]! : SPARKS[Math.min(7, Math.round((v / peak) * 7))]!))
+    .join("");
+  return fg(color, line);
+}
+
+// ── layout ───────────────────────────────────────────────────────
+
+/** A section rule that fills the width: `── name ────────────`. */
+export function rule(title: string, cells: number): string {
+  const label = ` ${title} `;
+  return (
+    fg(LINE, "──") + fg(MUTED, label) + fg(LINE, "─".repeat(Math.max(0, cells - 2 - label.length)))
+  );
+}
+
+// ── screen ───────────────────────────────────────────────────────
+
+const ALT_ON = "\x1b[?1049h\x1b[?25l";
+const ALT_OFF = "\x1b[?25h\x1b[?1049l";
+
+export interface Screen {
+  readonly rows: number;
+  readonly columns: number;
+  /** Draw a frame, clipped to the terminal height. */
+  draw(lines: string[]): void;
+  close(): void;
+}
+
+/**
+ * Take over the terminal: alternate buffer, hidden cursor, raw keys. `onKey`
+ * receives the raw chunk (`"\t"`, `"\x1b[B"`, `"q"`, …) — decoding belongs to
+ * the app, which is the only thing that knows what a key means.
+ *
+ * The caller MUST close() in a finally: raw mode survives a thrown exception.
+ */
+export function openScreen(onKey: (chunk: string) => void, onResize: () => void): Screen {
+  const out = process.stdout;
+  const input = process.stdin;
+
+  out.write(ALT_ON);
+  input.setRawMode?.(true);
+  input.setEncoding("utf8");
+  input.resume();
+  input.on("data", onKey);
+  out.on("resize", onResize);
+
+  let closed = false;
+  return {
+    get rows() {
+      return out.rows ?? 24;
+    },
+    get columns() {
+      return out.columns ?? 80;
+    },
+    draw(lines: string[]): void {
+      const visible = lines.slice(0, this.rows);
+      // Home, then erase each line as it is rewritten plus everything below the
+      // last one. No full clear, so a redraw does not flash, and no trailing
+      // newline, which would scroll the alternate screen by a row per frame.
+      out.write(`\x1b[H${visible.map((l) => `${l}\x1b[K`).join("\r\n")}\x1b[J`);
+    },
+    close(): void {
+      if (closed) return;
+      closed = true;
+      input.off("data", onKey);
+      out.off("resize", onResize);
+      input.setRawMode?.(false);
+      input.pause();
+      out.write(ALT_OFF);
+    },
+  };
+}
@@ -93,6 +93,25 @@ export function scanBucket(bucket: Bucket): Map<number, WorkFile[]> {
  return files;
 }

+/**
+ * Is this file a real solution rather than an empty scaffold? The same call
+ * close-solved.ts makes before it closes an issue — a stub under work/1 is a
+ * problem still unsolved, and owes no review.
+ */
+export function isSolution(file: WorkFile): boolean {
+  const source = readFileSync(join(WORK, file.rel), "utf8");
+  return isImplemented(source, file.rel.endsWith(".py") ? "py" : "js");
+}
+
+/** Problems in a bucket with a solution on disk; scaffolds do not count. */
+export function solvedInBucket(bucket: Bucket): number {
+  let solved = 0;
+  for (const files of scanBucket(bucket).values()) {
+    if (files.some(isSolution)) solved++;
+  }
+  return solved;
+}
+
 /**
 * LC number -> ET date of the commit that first added a work/ file for it.
 *
@@ -153,14 +172,12 @@ export function reviewQueues(today: string): Map<Window, Owed[]> {
  const dates = firstSolved();

  // An empty scaffold under work/1 is a problem still unsolved, not one owing
-  // a review — the same call close-solved.ts makes before it closes an issue.
+  // a review.
  const solved: { file: WorkFile; date: string }[] = [];
  for (const files of scanBucket(1).values()) {
    const date = dates.get(files[0]!.lc);
    if (date === undefined) continue; // uncommitted: you only just solved it
-    const file = files.find((f) =>
-      isImplemented(readFileSync(join(WORK, f.rel), "utf8"), f.rel.endsWith(".py") ? "py" : "js"),
-    );
+    const file = files.find(isSolution);
    if (file) solved.push({ file, date });
  }

@@ -32,6 +32,20 @@ Can you come up with an algorithm that is less than O(n^2) time complexity?
 - `-10^9 <= target <= 10^9`
 - Only one valid answer exists.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["twoSum(nums, target)"]) --> I["seen = {} — value to index"]
+  I --> L{"more (i, num) in nums?"}
+  L -- no --> E(["return []"])
+  L -- yes --> C["complement = target - num"]
+  C --> H{"complement in seen?"}
+  H -- yes --> R(["return [seen[complement], i]"])
+  H -- no --> W["seen[num] = i"]
+  W --> L
+```
+
 ## Solution

 ```py
@@ -45,3 +59,7 @@ class Solution:
            seen[num] = i
        return []
 ```
+
+## Explanation
+
+<YouTube id="KLlXCFG5TnA" title="Two Sum - Leetcode 1 - HashMap - Python" />
@@ -27,6 +27,22 @@ Notice that you may not slant the container.
 - `2 <= n <= 10^5`
 - `0 <= height[i] <= 10^4`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["maxArea(height)"]) --> I["res = 0, left = 0, right = len - 1"]
+  I --> W{"left < right?"}
+  W -- no --> E(["return res"])
+  W -- yes --> A["area = (right - left) * min(height[left], height[right])"]
+  A --> M["res = max(res, area)"]
+  M --> C{"height[left] < height[right]?"}
+  C -- yes --> L["left += 1 — drop the shorter wall"]
+  C -- no --> R["right -= 1 — drop the shorter wall"]
+  L --> W
+  R --> W
+```
+
 ## Solution

 ```py
@@ -46,3 +62,7 @@ class Solution:

        return res
 ```
+
+## Explanation
+
+<YouTube id="UuiTKBwPgAo" title="Container with Most Water - Leetcode 11 - Python" />
@@ -23,6 +23,24 @@ sidebar:
 - `1 <= prices.length <= 10^5`
 - `0 <= prices[i] <= 10^4`

+## Approach
+
+::::warning
+The diagram traces the code below literally. That code does not run: `curr` and `ans` are never initialised, so the first `curr > left` test raises `NameError`, and `left` holds a price rather than an index, so `prices[left]` indexes by value.
+::::
+
+```mermaid
+flowchart TD
+  S(["maxProfit(prices)"]) --> I["left = min(prices)"]
+  I --> F{"more right in range(len(prices))?"}
+  F -- no --> E(["return ans"])
+  F -- yes --> W{"curr > left?"}
+  W -- yes --> P["curr -= prices[left]; left += 1"]
+  P --> W
+  W -- no --> M["ans = max(ans, curr)"]
+  M --> F
+```
+
 ## Solution

 ```py
@@ -36,3 +54,7 @@ class Solution:
            ans = max(ans, curr)
        return ans
 ```
+
+## Explanation
+
+<YouTube id="1pkOgXD63yU" title="Sliding Window: Best Time to Buy and Sell Stock - Leetcode 121 - Python" />
@@ -26,6 +26,20 @@ sidebar:
 - `2 <= nums.length <= 500`
 - `0 <= nums[i] <= 100`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["smallerNumbersThanCurrent(nums)"]) --> F["freq: count every value in nums"]
+  F --> O["sorted = keys of freq, ascending"]
+  O --> I["count = 0, smaller = {}"]
+  I --> L{"more num in sorted?"}
+  L -- yes --> A["smaller[num] = count — everything already passed is smaller"]
+  A --> B["count += freq[num]"]
+  B --> L
+  L -- no --> M(["return nums.map(n => smaller[n])"])
+```
+
 ## Solution

 ```js
@@ -37,6 +37,18 @@ startValue = 4 | startValue = 5 | nums
 - `1 <= nums.length <= 100`
 - `-100 <= nums[i] <= 100`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["minStartValue(nums)"]) --> I["prefix = [nums[0]]"]
+  I --> L{"more i in 1..n-1?"}
+  L -- yes --> P["prefix.push(prefix[i-1] + nums[i])"]
+  P --> L
+  L -- no --> M["min = smallest running total"]
+  M --> R(["return max(1, 1 - min) — lift the dip to 1"])
+```
+
 ## Solution

 ```js
@@ -23,6 +23,19 @@ sidebar:
 - `1 <= arr.length <= 1000`
 - `0 <= arr[i] <= 1000`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["countElements(arr)"]) --> I["arrSet = Set(arr), count = 0"]
+  I --> L{"more n in arr?"}
+  L -- no --> E(["return count"])
+  L -- yes --> H{"arrSet has n + 1?"}
+  H -- yes --> C["count++"]
+  C --> L
+  H -- no --> L
+```
+
 ## Solution

 ```js
@@ -27,6 +27,17 @@ sidebar:
 - `1 <= nums.length <= 1000`
 - `-10^6 <= nums[i] <= 10^6`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["runningSum(nums)"]) --> I["prefix = [nums[0]]"]
+  I --> L{"more i in 1..n-1?"}
+  L -- yes --> P["prefix.push(prefix[i-1] + nums[i])"]
+  P --> L
+  L -- no --> E(["return prefix"])
+```
+
 ## Solution

 ```js
@@ -32,6 +32,28 @@ Notice that the solution set must not contain duplicate triplets.
 - `3 <= nums.length <= 3000`
 - `-10^5 <= nums[i] <= 10^5`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["threeSum(nums)"]) --> O["nums.sort() — duplicates become adjacent"]
+  O --> F{"more i in 0..n-1?"}
+  F -- no --> E(["return result"])
+  F -- yes --> D{"nums[i] == nums[i-1]?"}
+  D -- yes --> F
+  D -- no --> P["left = i+1, right = n-1, target = -nums[i]"]
+  P --> W{"left < right?"}
+  W -- no --> F
+  W -- yes --> C["current = nums[left] + nums[right]"]
+  C --> Q{"current vs target"}
+  Q -- equal --> A["append triplet, skip equal neighbours, left += 1, right -= 1"]
+  A --> W
+  Q -- "current < target" --> L["left += 1 — need a bigger sum"]
+  L --> W
+  Q -- "current > target" --> R["right -= 1 — need a smaller sum"]
+  R --> W
+```
+
 ## Solution

 ```py
@@ -76,3 +98,7 @@ class Solution:

        return result
 ```
+
+## Explanation
+
+<YouTube id="jzZsG8n2R9A" title="3Sum - Leetcode 15 - Python" />
@@ -28,6 +28,21 @@ sidebar:
 - `1 <= tokens.length <= 10^4`
 - `tokens[i]` is either an operator: "+", "-", "*", or "/", or an integer in the range [-200, 200].

+## Approach
+
+```mermaid
+flowchart TD
+  S(["evalRPN(tokens)"]) --> I["stack = [], operations = + - * /"]
+  I --> L{"more token c?"}
+  L -- no --> E(["return stack[0]"])
+  L -- yes --> Q{"c is an operator?"}
+  Q -- no --> N["stack.append(int(c))"]
+  N --> L
+  Q -- yes --> P["y = stack.pop(), x = stack.pop() — order matters"]
+  P --> C["stack.append(operations[c](x, y))"]
+  C --> L
+```
+
 ## Solution

 ```py
@@ -53,3 +68,7 @@ class Solution:

        return stack[0]
 ```
+
+## Explanation
+
+<YouTube id="iu0082c4HDE" title="Evaluate Reverse Polish Notation - Leetcode 150 - Python" />
@@ -35,6 +35,21 @@ Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in
 - All the integers of `nums` are unique.
 - `nums` is sorted and rotated between 1 and `n` times.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["findMin(nums)"]) --> I["l = 0, r = n-1, lowest_index = -1"]
+  I --> W{"l <= r?"}
+  W -- no --> E(["return nums[lowest_index]"])
+  W -- yes --> M["m = (l + r) // 2"]
+  M --> C{"nums[m] <= nums[-1]?"}
+  C -- yes --> A["in the right sorted run: record lowest_index = m, r = m - 1"]
+  A --> W
+  C -- no --> B["still in the left sorted run: l = m + 1"]
+  B --> W
+```
+
 ## Solution

 ```py
@@ -53,3 +68,7 @@ class Solution:

        return nums[lowest_index]
 ```
+
+## Explanation
+
+<YouTube id="nIVW4P8b1VA" title="Find Minimum in Rotated Sorted Array - Binary Search - Leetcode 153 - Python" />
@@ -27,6 +27,18 @@ sidebar:
 - `1 <= nums.length <= 100`
 - `-100 <= nums[i] <= 100`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["frequencySort(nums)"]) --> F["freq: count every value in nums"]
+  F --> C["sort nums with a two-key comparator"]
+  C --> K1["primary: freq[a] - freq[b] — rarer first"]
+  C --> K2["tie-break: b - a — larger value first"]
+  K1 --> R(["return nums"])
+  K2 --> R
+```
+
 ## Solution

 ```js
@@ -40,3 +52,7 @@ var frequencySort = function (nums) {
  return nums.sort((a, b) => freq[a] - freq[b] || b - a);
 };
 ```
+
+## Explanation
+
+<YouTube id="Evq1SfUbhBg" title="Sort Array by Increasing Frequency - Leetcode 1636 - Python" />
@@ -35,6 +35,22 @@ Your solution must use only constant extra space.
 - `-1000 <= target <= 1000`
 - The tests are generated such that there is exactly one solution.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["twoSum(numbers, target)"]) --> I["i = 0, j = len - 1"]
+  I --> W{"i < j?"}
+  W -- no --> E(["return []"])
+  W -- yes --> C["c = numbers[i] + numbers[j]"]
+  C --> Q{"c vs target"}
+  Q -- equal --> R(["return [i+1, j+1] — 1-indexed"])
+  Q -- "c < target" --> L["i += 1 — grow the sum"]
+  L --> W
+  Q -- "c > target" --> H["j -= 1 — shrink the sum"]
+  H --> W
+```
+
 ## Solution

 ```py
@@ -53,3 +69,7 @@ class Solution:
                j-=1
        return []
 ```
+
+## Explanation
+
+<YouTube id="cQ1Oz4ckceM" title="TWO SUM II - Amazon Coding Interview Question - Leetcode 167 - Python" />
@@ -0,0 +1,41 @@
+---
+title: '215. Kth Largest Element in an Array'
+description: Given an integer array nums and an integer k, return the k^th largest element in the array
+sidebar:
+  label: 'Kth Largest Element in an Array'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Heap / Priority Queue</Badge>
+
+### Example 1:
+- Input: `nums = [3,2,1,5,6,4], k = 2`
+- Output: `5`
+
+### Example 2:
+- Input: `nums = [3,2,3,1,2,4,5,5,6], k = 4`
+- Output: `4`
+
+### Constraints:
+
+- `1 <= k <= nums.length <= 10^5`
+- `-10^4 <= nums[i] <= 10^4`
+
+## Solution
+
+```py
+import heapq
+
+
+class Solution:
+    def findKthLargest(self, nums: List[int], k: int) -> int:
+        for i in range(len(nums)):
+            nums[i] = -nums[i]
+
+        heapq.heapify(nums)
+
+        for _ in range(k - 1):
+            heapq.heappop(nums)
+
+        return -heapq.heappop(nums)
+```
@@ -27,9 +27,29 @@ sidebar:
 - `1 <= nums.length <= 10^5`
 - `-10^9 <= nums[i] <= 10^9`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["containsDuplicate(nums)"]) --> I["freq = {}"]
+  I --> L{"more n in nums?"}
+  L -- no --> E(["return false"])
+  L -- yes --> C["freq[n] = (freq[n] or 0) + 1"]
+  C --> Q{"freq[n] >= 2?"}
+  Q -- yes --> R(["return true"])
+  Q -- no --> L
+```
+
 ## Solution

-```js
+<CodeGroup>
+
+```py Python
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+```
+
+```js JavaScript
 /**
 * @param {number[]} nums
 * @return {boolean}
@@ -45,3 +65,9 @@ var containsDuplicate = function(nums) {
  return false;
 };
 ```
+
+</CodeGroup>
+
+## Explanation
+
+<YouTube id="3OamzN90kPg" title="Contains Duplicate - Leetcode 217 - Python" />
@@ -27,6 +27,17 @@ Can you solve the problem in O(1) extra space complexity? (The output array does
 - `-30 <= nums[i] <= 30`
 - The input is generated such that `answer[i]` is guaranteed to fit in a 32-bit integer.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["productExceptSelf(nums)"]) --> I["answer = ones(n), rightArr = ones(n)"]
+  I --> P1["Pass 1 — left to right: answer[i] = nums[i-1] * answer[i-1]"]
+  P1 --> P2["Pass 2 — right to left: rightArr[i] = nums[i+1] * rightArr[i+1]"]
+  P2 --> P3["Pass 3: answer[i] *= rightArr[i]"]
+  P3 --> E(["return answer — no division needed"])
+```
+
 ## Solution

 ```js
@@ -51,3 +62,7 @@ var productExceptSelf = function(nums) {
  return answer;
 };
 ```
+
+## Explanation
+
+<YouTube id="bNvIQI2wAjk" title="Product of Array Except Self - Leetcode 238 - Python" />
@@ -34,6 +34,18 @@ Could you implement a solution using only O(1) extra space complexity and O(n) r
 - `0 <= nums[i] <= n`
 - All the numbers of `nums` are unique.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["missingNumber(nums)"]) --> I["numSet = Set(nums), expectedCount = n + 1"]
+  I --> L{"more i in 0..expectedCount-1?"}
+  L -- yes --> Q{"numSet has i?"}
+  Q -- no --> R(["return i"])
+  Q -- yes --> L
+  L -- no --> E(["return -1"])
+```
+
 ## Solution

 ```js
@@ -53,3 +65,7 @@ var missingNumber = function(nums) {
  return -1;
 };
 ```
+
+## Explanation
+
+<YouTube id="WnPLSRLSANE" title="Missing Number - Blind 75 - Leetcode 268 - Python" />
@@ -0,0 +1,48 @@
+---
+title: '271. Encode and Decode Strings'
+description: Design an algorithm to encode a list of strings to a string. The encoded string is then sent over the network and is decoded back to the original list of strings
+sidebar:
+  label: 'Encode and Decode Strings'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Array</Badge>
+
+::::warning
+Could you write a generalized algorithm to work on any possible set of characters?
+::::
+
+### Example 1:
+- Input: `dummy_input = ["Hello","World"]`
+- Output: `["Hello","World"]`
+- Explanation: Machine `1`: Codec encoder = new Codec(); String msg = encoder.encode(strs); Machine `1` ---msg---> Machine `2` Machine `2`: Codec decoder = new Codec(); `String[] strs` = decoder.decode(msg);
+
+### Example 2:
+- Input: `dummy_input = [""]`
+- Output: `[""]`
+
+### Constraints:
+
+- `1 <= strs.length <= 200`
+- `0 <= strs[i].length <= 200`
+- `strs[i]` contains any possible characters out of 256 valid ASCII characters.
+
+## Solution
+
+```py
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        """Encodes a list of strings to a single string.
+        """
+        
+
+    def decode(self, s: str) -> List[str]:
+        """Decodes a single string to a list of strings.
+        """
+        
+
+
+# Your Codec object will be instantiated and called as such:
+# codec = Codec()
+# codec.decode(codec.encode(strs))
+```
@@ -20,6 +20,21 @@ sidebar:
 - `0 <= left <= right < nums.length`
 - At most `10^4` calls will be made to `sumRange`.

+## Approach
+
+```mermaid
+flowchart TD
+  subgraph build["constructor(nums) — O(n) once"]
+    A["prefix = [0]"] --> B{"more n in nums?"}
+    B -- yes --> C["prefix.push(last + n)"]
+    C --> B
+  end
+  build --> Q
+  subgraph Q["sumRange(left, right) — O(1) per call"]
+    D(["return prefix[right + 1] - prefix[left]"])
+  end
+```
+
 ## Solution

 ```js
@@ -50,3 +65,7 @@ class NumArray {
 * var param_1 = obj.sumRange(left,right)
 */
 ```
+
+## Explanation
+
+<YouTube id="2pndAmo_sMA" title="Range Sum Query Immutable - Leetcode 303 - Python" />
@@ -32,6 +32,29 @@ You must write an algorithm with O(log n) runtime complexity.
 - `nums` is an ascending array that is possibly rotated.
 - `-10^4 <= target <= 10^4`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["search(nums, target)"]) --> I["l = 0, r = n - 1"]
+  I --> W{"l <= r?"}
+  W -- no --> E(["return -1"])
+  W -- yes --> M["mid = floor((l + r) / 2)"]
+  M --> F{"nums[mid] == target?"}
+  F -- yes --> R(["return mid"])
+  F -- no --> H{"nums[l] <= nums[mid]? — left half sorted"}
+  H -- yes --> A{"target outside [nums[l], nums[mid]]?"}
+  A -- yes --> A1["l = mid + 1 — search the right half"]
+  A -- no --> A2["r = mid - 1"]
+  H -- no --> B{"target outside [nums[mid], nums[r]]?"}
+  B -- yes --> B1["r = mid - 1 — search the left half"]
+  B -- no --> B2["l = mid + 1"]
+  A1 --> W
+  A2 --> W
+  B1 --> W
+  B2 --> W
+```
+
 ## Solution

 ```js
@@ -69,3 +92,7 @@ var search = function(nums, target) {
  return -1;
 };
 ```
+
+## Explanation
+
+<YouTube id="U8XENwh8Oy8" title="Search in rotated sorted array - Leetcode 33 - Python" />
@@ -31,6 +31,16 @@ Your algorithm's time complexity must be better than O(n log n), where n is the
 - `k` is in the range `[1, the number of unique elements in the array]`.
 - It is guaranteed that the answer is unique.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["topKFrequent(nums, k)"]) --> F["freq: count every value in nums"]
+  F --> K["keys of freq, cast to Number"]
+  K --> O["sort by freq[b] - freq[a] — most frequent first"]
+  O --> R(["return slice(0, k)"])
+```
+
 ## Solution

 ```js
@@ -49,3 +59,7 @@ var topKFrequent = function (nums, k) {
    .slice(0, k);
 };
 ```
+
+## Explanation
+
+<YouTube id="YPTqKIgVk-k" title="Top K Frequent Elements - Bucket Sort - Leetcode 347 - Python" />
@@ -31,6 +31,22 @@ You must write an algorithm with O(log n) runtime complexity.
 - `nums` contains distinct values sorted in ascending order.
 - `-10^4 <= target <= 10^4`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["searchInsert(nums, target)"]) --> I["l = 0, r = n - 1"]
+  I --> W{"l <= r?"}
+  W -- yes --> M["m = (l + r) // 2"]
+  M --> Q{"nums[m] vs target"}
+  Q -- equal --> R(["return m"])
+  Q -- "nums[m] < target" --> L["l = m + 1"]
+  L --> W
+  Q -- "nums[m] > target" --> H["r = m - 1"]
+  H --> W
+  W -- no --> E(["return (l + r) // 2 + 1 — the insert slot"])
+```
+
 ## Solution

 ```py
@@ -49,3 +65,7 @@ class Solution:

        return (l + r) // 2 + 1
 ```
+
+## Explanation
+
+<YouTube id="K-RYzDZkzCI" title="Search Insert Position - Binary Search - Leetcode 35 - Python" />
@@ -0,0 +1,37 @@
+---
+title: '48. Rotate Image'
+description: You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise)
+sidebar:
+  label: 'Rotate Image'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Matrix Index Math</Badge>
+
+### Example 1:
+- Input: `matrix = [[1,2,3],[4,5,6],[7,8,9]]`
+- Output: `[[7,4,1],[8,5,2],[9,6,3]]`
+
+### Example 2:
+- Input: `matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]`
+- Output: `[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]`
+
+### Constraints:
+
+- `n == matrix.length == matrix[i].length`
+- `1 <= n <= 20`
+- `-1000 <= matrix[i][j] <= 1000`
+
+## Solution
+
+```py
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        n = len(matrix)
+        for r in range(n):
+            for c in range(r + 1, n):
+                matrix[r][c], matrix[c][r] = matrix[c][r], matrix[r][c]
+
+        for r in range(n):
+            matrix[r].reverse()
+```
@@ -27,6 +27,21 @@ sidebar:
 - `0 <= strs[i].length <= 100`
 - `strs[i]` consists of lowercase English letters.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["groupAnagrams(strs)"]) --> K["sorted[i] = letters of strs[i], sorted — the anagram key"]
+  K --> I["anagrams = {}"]
+  I --> L{"more i in 0..n-1?"}
+  L -- no --> E(["return Object.values(anagrams)"])
+  L -- yes --> Q{"anagrams has sorted[i]?"}
+  Q -- no --> N["anagrams[sorted[i]] = [strs[i]]"]
+  Q -- yes --> P["anagrams[sorted[i]].push(strs[i])"]
+  N --> L
+  P --> L
+```
+
 ## Solution

 ```js
@@ -49,3 +64,7 @@ var groupAnagrams = function(strs) {
  return Object.values(anagrams);
 };
 ```
+
+## Explanation
+
+<YouTube id="vzdNOK2oB2E" title="Group Anagrams - Categorize Strings by Count - Leetcode 49" />
@@ -0,0 +1,59 @@
+---
+title: '54. Spiral Matrix'
+description: Given an m x n matrix, return all elements of the matrix in spiral order
+sidebar:
+  label: 'Spiral Matrix'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Matrix Index Math</Badge>
+
+### Example 1:
+- Input: `matrix = [[1,2,3],[4,5,6],[7,8,9]]`
+- Output: `[1,2,3,6,9,8,7,4,5]`
+
+### Example 2:
+- Input: `matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]`
+- Output: `[1,2,3,4,8,12,11,10,9,5,6,7]`
+
+### Constraints:
+
+- `m == matrix.length`
+- `n == matrix[i].length`
+- `1 <= m, n <= 10`
+- `-100 <= matrix[i][j] <= 100`
+
+## Solution
+
+```py
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        res = []
+        top, bottom = 0, len(matrix) - 1
+        left, right = 0, len(matrix[0]) - 1
+
+        while top <= bottom and left <= right:
+            # 1. Top Row
+            for c in range(left, right + 1):
+                res.append(matrix[top][c])
+            top += 1
+
+            # 2. Right Column
+            for r in range(top, bottom + 1):
+                res.append(matrix[r][right])
+            right -= 1
+
+            # 3. Bottom Row
+            if top <= bottom:
+                for c in range(right, left - 1, -1):
+                    res.append(matrix[bottom][c])
+                bottom -= 1
+
+            # 4. Left Column
+            if left <= right:
+                for r in range(bottom, top - 1, -1):
+                    res.append(matrix[r][left])
+                left += 1
+
+        return res
+```
@@ -22,6 +22,21 @@ sidebar:
 - `-1000 <= nums[i] <= 1000`
 - `-10^7 <= k <= 10^7`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["subarraySum(nums, k)"]) --> I["map = {0: 1} — the empty prefix; sum = 0, count = 0"]
+  I --> L{"more n in nums?"}
+  L -- no --> E(["return count"])
+  L -- yes --> A["sum += n"]
+  A --> Q{"map has sum - k?"}
+  Q -- yes --> C["count += map.get(sum - k) — every earlier prefix that closes a window"]
+  Q -- no --> W["map.set(sum, count of sum + 1)"]
+  C --> W
+  W --> L
+```
+
 ## Solution

 ```js
@@ -49,3 +64,7 @@ var subarraySum = function(nums, k) {
  return count
 };
 ```
+
+## Explanation
+
+<YouTube id="fFVZt-6sgyo" title="Subarray Sum Equals K - Prefix Sums - Leetcode 560 - Python" />
@@ -29,6 +29,22 @@ You must write an algorithm with O(log n) runtime complexity.
 - All the integers in `nums` are unique.
 - `nums` is sorted in ascending order.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["search(nums, target)"]) --> I["left = 0, right = n - 1"]
+  I --> W{"left <= right?"}
+  W -- no --> E(["return -1"])
+  W -- yes --> M["mid = left + floor((right - left) / 2)"]
+  M --> Q{"nums[mid] vs target"}
+  Q -- equal --> R(["return mid"])
+  Q -- "nums[mid] < target" --> L["left = mid + 1"]
+  L --> W
+  Q -- "nums[mid] > target" --> H["right = mid - 1"]
+  H --> W
+```
+
 ## Solution

 ```js
@@ -54,3 +70,7 @@ var search = function(nums, target) {
    return -1;
 };
 ```
+
+## Explanation
+
+<YouTube id="s4DPM8ct1pI" title="Binary Search - Leetcode 704 - Python" />
@@ -0,0 +1,67 @@
+---
+title: '73. Set Matrix Zeroes'
+description: Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's
+sidebar:
+  label: 'Set Matrix Zeroes'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Matrix Index Math</Badge>
+
+::::warning
+You must do it in place.
+::::
+
+### Example 1:
+- Input: `matrix = [[1,1,1],[1,0,1],[1,1,1]]`
+- Output: `[[1,0,1],[0,0,0],[1,0,1]]`
+
+### Example 2:
+- Input: `matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]`
+- Output: `[[0,0,0,0],[0,4,5,0],[0,3,1,0]]`
+
+### Constraints:
+
+- `m == matrix.length`
+- `n == matrix[0].length`
+- `1 <= m, n <= 200`
+- `-2^31 <= matrix[i][j] <= 2^31 - 1`
+- A straightforward solution using O(mn) space is probably a bad idea.
+- A simple improvement uses O(m + n) space, but still not the best solution.
+- Could you devise a constant space solution?
+
+## Solution
+
+```py
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        m, n = len(matrix), len(matrix[0])
+
+        # 1. remember if row 0 or column 0 have their own zeros
+        row0_zero = any(matrix[0][c] == 0 for c in range(n))
+        col0_zero = any(matrix[r][0] == 0 for r in range(m))
+
+        # 2. use row 0 and column 0 as marker lists
+        for r in range(1, m):
+            for c in range(1, n):
+                if matrix[r][c] == 0:
+                    matrix[r][0] = 0
+                    matrix[0][c] = 0
+
+        # 3. zero the inner cells from the markers
+        for r in range(1, m):
+            for c in range(1, n):
+                if matrix[r][0] == 0 or matrix[0][c] == 0:
+                    matrix[r][c] = 0
+
+        # 4. handle row 0 and column 0 last
+        if row0_zero:
+            for c in range(n):
+                matrix[0][c] = 0
+        if col0_zero:
+            for r in range(m):
+                matrix[r][0] = 0
+```
@@ -25,6 +25,20 @@ sidebar:
 - `1 <= temperatures.length <= 10^5`
 - `30 <= temperatures[i] <= 100`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["dailyTemperatures(temperatures)"]) --> I["ans = zeros(n), stack = [] — indices of days still waiting"]
+  I --> L{"more (i, temp)?"}
+  L -- no --> E(["return ans"])
+  L -- yes --> W{"stack non-empty and temperatures[stack[-1]] < temp?"}
+  W -- yes --> P["prev = stack.pop(); ans[prev] = i - prev — today resolves that day"]
+  P --> W
+  W -- no --> A["stack.append(i)"]
+  A --> L
+```
+
 ## Solution

 ```py
@@ -39,3 +53,7 @@ class Solution:
            stack.append(i)
        return ans
 ```
+
+## Explanation
+
+<YouTube id="cTBiBSnjO3c" title="Daily Temperatures - Monotonic Stack - Leetcode 739 - Python" />
@@ -27,6 +27,32 @@ You must write a solution in O(log(m * n)) time complexity.
 - `1 <= m, n <= 100`
 - `-10^4 <= matrix[i][j], target <= 10^4`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["searchMatrix(matrix, target)"]) --> I["top = 0, bot = ROWS - 1"]
+  I --> W1{"top <= bot?"}
+  W1 -- yes --> R1["row = (top + bot) // 2"]
+  R1 --> C1{"target vs that row's range"}
+  C1 -- "above matrix[row][-1]" --> U["top = row + 1"]
+  C1 -- "below matrix[row][0]" --> V["bot = row - 1"]
+  C1 -- inside --> B(["break — row found"])
+  U --> W1
+  V --> W1
+  W1 -- no --> F(["return False — no row can hold it"])
+  B --> P["row = (top + bot) // 2; l = 0, r = COLS - 1"]
+  P --> W2{"l <= r?"}
+  W2 -- no --> G(["return False"])
+  W2 -- yes --> M["m = (l + r) // 2"]
+  M --> C2{"target vs matrix[row][m]"}
+  C2 -- greater --> X["l = m + 1"]
+  C2 -- smaller --> Y["r = m - 1"]
+  C2 -- equal --> T(["return True"])
+  X --> W2
+  Y --> W2
+```
+
 ## Solution

 ```py
@@ -59,3 +85,7 @@ class Solution:
                return True
        return False
 ```
+
+## Explanation
+
+<YouTube id="Ber2pi2C0j0" title="Search a 2D Matrix - Leetcode 74 - Python" />
@@ -32,6 +32,22 @@ sidebar:
 - All the values of `position` are unique.
 - `0 < speed[i] <= 10^6`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["carFleet(target, position, speed)"]) --> O["zip and sort by position, descending — nearest the target first"]
+  O --> I["stack = [] — arrival time of each fleet's leader"]
+  I --> L{"more (pos, spd)?"}
+  L -- no --> E(["return len(stack) — one entry per fleet"])
+  L -- yes --> T["time = (target - pos) / spd"]
+  T --> Q{"stack empty or time > stack[-1]?"}
+  Q -- yes --> A["stack.append(time) — slower, so it starts a new fleet"]
+  Q -- no --> B["discard — it catches the car ahead and joins that fleet"]
+  A --> L
+  B --> L
+```
+
 ## Solution

 ```py
@@ -45,3 +61,7 @@ class Solution:

        return len(stack)
 ```
+
+## Explanation
+
+<YouTube id="Pr6T-3yB9RM" title="Car Fleet - Leetcode 853 - Python" />
@@ -26,6 +26,22 @@ sidebar:
 - `piles.length <= h <= 10^9`
 - `1 <= piles[i] <= 10^9`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["minEatingSpeed(piles, h)"]) --> I["l = 1, r = max(piles)"]
+  I --> W{"l < r?"}
+  W -- no --> E(["return l — the smallest workable speed"])
+  W -- yes --> M["mid = floor((l + r) / 2)"]
+  M --> K["kWorks(mid): hours = sum of ceil(p / mid)"]
+  K --> Q{"hours <= h?"}
+  Q -- yes --> A["r = mid — keep mid, try slower"]
+  Q -- no --> B["l = mid + 1 — too slow, speed up"]
+  A --> W
+  B --> W
+```
+
 ## Solution

 ```js
@@ -60,3 +76,7 @@ var minEatingSpeed = function(piles, h) {
  return l;
 };
 ```
+
+## Explanation
+
+<YouTube id="U2SozAs9RzA" title="Koko Eating Bananas - Binary Search - Leetcode 875 - Python" />
@@ -0,0 +1,48 @@
+---
+title: '973. K Closest Points to Origin'
+description: Given an array of points where points[i] = [xi, yi] represents a point on the X-Y plane and an integer k, return the k closest points to the origin (0, 0)
+sidebar:
+  label: 'K Closest Points to Origin'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Heap / Priority Queue</Badge>
+
+### Example 1:
+- Input: `points = [[1,3],[-2,2]], k = 1`
+- Output: `[[-2,2]]`
+- Explanation: The distance between `(1`, `3`) and the origin is sqrt(10). The distance between `(-2`, `2`) and the origin is sqrt(8). Since sqrt(8) < sqrt(10), `(-2`, `2`) is closer to the origin. We only want the closest `k = 1 points` from the origin, so the answer is just [[-2,2]].
+
+### Example 2:
+- Input: `points = [[3,3],[5,-1],[-2,4]], k = 2`
+- Output: `[[3,3],[-2,4]]`
+- Explanation: The answer [[-2,4],[3,3]] would also be accepted.
+
+### Constraints:
+
+- `1 <= k <= points.length <= 10^4`
+- `-10^4 <= xi, yi <= 10^4`
+
+## Solution
+
+```py
+import heapq
+
+
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        minHeap = []
+        for x, y in points:
+            dist = (x**2) + (y**2)
+            minHeap.append([dist, x, y])
+
+        heapq.heapify(minHeap)
+        res = []
+
+        while k > 0:
+            dist, x, y = heapq.heappop(minHeap)
+            res.append([x, y])
+            k -= 1
+
+        return res
+```
@@ -27,6 +27,21 @@ Squaring each element and sorting the new array is very trivial, could you find
 - `-10^4 <= nums[i] <= 10^4`
 - `nums` is sorted in non-decreasing order.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["sortedSquares(nums)"]) --> I["ans = Array(n), left = 0, right = n - 1"]
+  I --> L{"more i from n-1 down to 0?"}
+  L -- no --> E(["return ans"])
+  L -- yes --> C{"abs(nums[left]) < abs(nums[right])?"}
+  C -- yes --> R["square = nums[right]; right--"]
+  C -- no --> F["square = nums[left]; left++"]
+  R --> W["ans[i] = square * square — fill from the back, largest first"]
+  F --> W
+  W --> L
+```
+
 ## Solution

 ```js
@@ -53,3 +68,7 @@ var sortedSquares = function(nums) {
  return ans;
 };
 ```
+
+## Explanation
+
+<YouTube id="FPCZsG_AkUg" title="Squares of a Sorted Array - Leetcode 977 - Python" />
@@ -33,6 +33,20 @@ Can you solve it using O(1) (i.e. constant) memory?
 - `-10^5 <= Node.val <= 10^5`
 - pos is -1 or a valid index in the linked-list.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["hasCycle(head)"]) --> I["fast = slow = head"]
+  I --> W{"fast and fast.next?"}
+  W -- no --> E(["return False — ran off the end, no cycle"])
+  W -- yes --> A["fast = fast.next.next — two steps"]
+  A --> B["slow = slow.next — one step"]
+  B --> Q{"fast is slow?"}
+  Q -- yes --> R(["return True — the gap closed, so it loops"])
+  Q -- no --> W
+```
+
 ## Solution

 ```py
@@ -54,3 +68,7 @@ class Solution:
                return True
        return False
 ```
+
+## Explanation
+
+<YouTube id="gBTe7lFR3vc" title="Linked List Cycle - Floyd's Tortoise and Hare - Leetcode 141 - Python" />
@@ -0,0 +1,115 @@
+---
+title: '146. LRU Cache'
+description: Design a data structure that follows the constraints of a Least Recently Used (LRU) cache
+sidebar:
+  label: 'LRU Cache'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Hybrid Structures</Badge>
+
+### Example 1:
+- Input: ``
+- Output: ``
+- Explanation: Input ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"] `[[2]`, [1, 1], [2, 2], `[1]`, [3, 3], `[2]`, [4, 4], `[1]`, `[3]`, [4]] Output [null, null, null, `1`, null, `-1`, null, `-1`, `3`, 4] Explanation LRUCache lRUCache = new LRUCache(2); lRUCache.put(1, `1`); // cache is {1=1} lRUCache.put(2, `2`); // cache is {1=1, 2=2} lRUCache.get(1);    // return `1` lRUCache.put(3, `3`); // LRU `key` was `2`, evicts `key 2`, cache is {1=1, 3=3} lRUCache.get(2);    // returns `-1` (not found) lRUCache.put(4, `4`); // LRU `key` was `1`, evicts `key 1`, cache is {4=4, 3=3} lRUCache.get(1);    // return `-1` (not found) lRUCache.get(3);    // return `3` lRUCache.get(4);    // return `4`
+
+### Constraints:
+
+- `1 <= capacity <= 3000`
+- `0 <= key <= 10^4`
+- `0 <= value <= 10^5`
+- At most 2 * 10^5 calls will be made to get and put.
+
+## Approach
+
+```mermaid
+flowchart TD
+  subgraph state["state — dict for O(1) lookup, doubly linked list for O(1) reorder"]
+    H["head — least recent"] --- N["... nodes ..."] --- T["tail — most recent"]
+  end
+  subgraph get["get(key)"]
+    G1{"key in cache?"} -- no --> G2(["return -1"])
+    G1 -- yes --> G3["_remove_node then _add_node — move it beside the tail"]
+    G3 --> G4(["return node.value"])
+  end
+  subgraph put["put(key, value)"]
+    P1{"key in cache?"} -- yes --> P2["update value, _remove_node then _add_node"]
+    P1 -- no --> P3["new Node, cache[key] = node, _add_node"]
+    P3 --> P4{"len(cache) > capacity?"}
+    P4 -- yes --> P5["evict head.next — the least recent — and del cache[lru.key]"]
+    P4 -- no --> P6(["done"])
+    P2 --> P6
+    P5 --> P6
+  end
+  state --> get
+  state --> put
+```
+
+## Solution
+
+```py
+class Node:
+    def __init__(self, key=0, value=0):
+        self.key = key
+        self.value = value
+        self.prev = None
+        self.next = None
+
+
+class LRUCache:
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.cache = {}
+        self.head = Node()
+        self.tail = Node()
+        self.head.next = self.tail  # pyright: ignore[reportAttributeAccessIssue]
+        self.tail.prev = self.head  # pyright: ignore[reportAttributeAccessIssue]
+
+    def _remove_node(self, node):
+        prev_node = node.prev
+        next_node = node.next
+        prev_node.next = next_node
+        next_node.prev = prev_node
+
+    def _add_node(self, node):
+        # Insert just before the tail (most recent at end)
+        node.next = self.tail
+        node.prev = self.tail.prev
+        self.tail.prev.next = node  # pyright: ignore[reportAttributeAccessIssue]
+        self.tail.prev = node
+
+    def get(self, key: int) -> int:
+        if key not in self.cache:
+            return -1
+
+        node = self.cache[key]
+        self._remove_node(node)
+        self._add_node(node)
+        return node.value
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            node = self.cache[key]
+            node.value = value
+            self._remove_node(node)
+            self._add_node(node)
+        else:
+            new_node = Node(key, value)
+            self.cache[key] = new_node
+            self._add_node(new_node)
+
+            if len(self.cache) > self.capacity:
+                lru = self.head.next  # Oldest node is next to the head
+                self._remove_node(lru)
+                del self.cache[lru.key]  # pyright: ignore[reportAttributeAccessIssue]
+
+
+# Your LRUCache object will be instantiated and called as such:
+# obj = LRUCache(capacity)
+# param_1 = obj.get(key)
+# obj.put(key,value)
+```
+
+## Explanation
+
+<YouTube id="7ABFKPK2hD4" title="LRU Cache - Twitch Interview Question - Leetcode 146" />
@@ -22,6 +22,19 @@ sidebar:
 - `1 <= sentence.length <= 1000`
 - `sentence` consists of lowercase English letters.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["checkIfPangram(sentence)"]) --> I["freq = {}"]
+  I --> L{"more char c?"}
+  L -- yes --> C["freq[c] = (freq[c] or 0) + 1"]
+  C --> L
+  L -- no --> Q{"distinct keys in freq == 26?"}
+  Q -- yes --> R(["return true"])
+  Q -- no --> F(["return false"])
+```
+
 ## Solution

 ```js
@@ -0,0 +1,70 @@
+---
+title: '208. Implement Trie (Prefix Tree)'
+description: A trie (pronounced as "try") or prefix tree is a tree data structure used to efficiently store and retrieve keys in a dataset of strings. There are various applications of this data structure, such as autocomplete and spellchecker
+sidebar:
+  label: 'Implement Trie (Prefix Tree)'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Trie</Badge>
+
+### Example 1:
+- Input: ``
+- Output: ``
+- Explanation: Input ["Trie", "insert", "search", "search", "startsWith", "insert", "search"] `[[]`, `["apple"]`, `["apple"]`, `["app"]`, `["app"]`, `["app"]`, ["app"]] Output [null, null, true, false, true, null, true] Explanation Trie trie = new Trie(); trie.insert("apple"); trie.search("apple");   // return True trie.search("app");     // return False trie.startsWith("app"); // return True trie.insert("app"); trie.search("app");     // return True
+
+### Constraints:
+
+- `1 <= word.length, prefix.length <= 2000`
+- `word` and `prefix` consist only of lowercase English letters.
+- At most 3 * 10^4 calls in total will be made to insert, search, and startsWith.
+
+## Solution
+
+```py
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.endOfWord = False
+
+
+class Trie:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def insert(self, word: str) -> None:
+        cur = self.root
+
+        for c in word:
+            if c not in cur.children:
+                cur.children[c] = TrieNode()
+            cur = cur.children[c]
+        cur.endOfWord = True
+
+    def search(self, word: str) -> bool:
+        cur = self.root
+
+        for c in word:
+            if c not in cur.children:
+                return False
+            cur = cur.children[c]
+
+        return cur.endOfWord
+
+    def startsWith(self, prefix: str) -> bool:
+        cur = self.root
+
+        for c in prefix:
+            if c not in cur.children:
+                return False
+            cur = cur.children[c]
+
+        return True
+
+
+# Your Trie object will be instantiated and called as such:
+# obj = Trie()
+# obj.insert(word)
+# param_2 = obj.search(word)
+# param_3 = obj.startsWith(prefix)
+```
@@ -25,6 +25,19 @@ What if the inputs contain Unicode characters? How would you adapt your solution
 - `1 <= s.length, t.length <= 5 * 10^4`
 - `s` and `t` consist of lowercase English letters.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["isAnagram(s, t)"]) --> I["freq: count every char of s"]
+  I --> L{"more char c in t?"}
+  L -- no --> E(["return true"])
+  L -- yes --> Q{"freq[c] missing or 0?"}
+  Q -- yes --> R(["return false — t has a char s cannot cover"])
+  Q -- no --> D["freq[c] -= 1"]
+  D --> L
+```
+
 ## Solution

 ```js
@@ -46,3 +59,7 @@ var isAnagram = function(s, t) {
  return true;
 };
 ```
+
+## Explanation
+
+<YouTube id="9UtInBqnCgA" title="Valid Anagram - Leetcode 242 - Python" />
@@ -28,6 +28,21 @@ sidebar:
 - `0 <= s.length <= 10^5`
 - `s` consists of English letters, digits, symbols and spaces.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["lengthOfLongestSubstring(s)"]) --> I["left = 0, ans = 0, window = set()"]
+  I --> L{"more (right, c) in s?"}
+  L -- no --> E(["return ans"])
+  L -- yes --> W{"c already in window?"}
+  W -- yes --> P["window.remove(s[left]); left += 1 — shrink until c is free"]
+  P --> W
+  W -- no --> A["window.add(c)"]
+  A --> M["ans = max(ans, right - left + 1)"]
+  M --> L
+```
+
 ## Solution

 ```py
@@ -45,3 +60,7 @@ class Solution:

        return ans
 ```
+
+## Explanation
+
+<YouTube id="wiGpQwVHdE0" title="Longest Substring Without Repeating Characters - Leetcode 3 - Python" />
@@ -26,6 +26,18 @@ sidebar:
 - `1 <= s.length <= 10^5`
 - `s` consists of only lowercase English letters.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["firstUniqChar(s)"]) --> F["Pass 1 — freq: count every char of s"]
+  F --> L{"Pass 2 — more i in 0..len-1?"}
+  L -- no --> E(["return -1"])
+  L -- yes --> Q{"freq[s[i]] == 1?"}
+  Q -- yes --> R(["return i — leftmost wins because the scan is in order"])
+  Q -- no --> L
+```
+
 ## Solution

 ```js
@@ -45,3 +57,7 @@ var firstUniqChar = function (s) {
  return -1;
 };
 ```
+
+## Explanation
+
+<YouTube id="rBENYgWy3xU" title="First Unique Character in a String - Leetcode 387 - Python" />
@@ -24,6 +24,21 @@ sidebar:
 - `s` consists of only uppercase English letters.
 - `0 <= k <= s.length`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["characterReplacement(s, k)"]) --> I["count = {}, res = 0, l = 0, maxF = 0"]
+  I --> L{"more (r, c) in s?"}
+  L -- no --> E(["return res"])
+  L -- yes --> A["count[c] += 1; maxF = max(maxF, count[c])"]
+  A --> W{"(r - l + 1) - maxF > k? — too many chars to replace"}
+  W -- yes --> P["count[s[l]] -= 1; l += 1 — shrink from the left"]
+  P --> W
+  W -- no --> M["res = max(res, r - l + 1)"]
+  M --> L
+```
+
 ## Solution

 ```py
@@ -45,3 +60,7 @@ class Solution:
            res = max(res, r - l + 1)
        return res
 ```
+
+## Explanation
+
+<YouTube id="gqXU1UyA8pk" title="Longest Repeating Character Replacement - Leetcode 424 - Python" />
@@ -28,6 +28,18 @@ sidebar:
 - `1 <= s.length <= 5 * 10^5`
 - `s` consists of uppercase and lowercase English letters and digits.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["frequencySort(s)"]) --> F["freq: count every char of s"]
+  F --> C["split s and sort with a two-key comparator"]
+  C --> K1["primary: freq[b] - freq[a] — most frequent first"]
+  C --> K2["tie-break: a.localeCompare(b) — alphabetical"]
+  K1 --> R(["join and return"])
+  K2 --> R
+```
+
 ## Solution

 ```js
@@ -47,3 +59,7 @@ var frequencySort = function (s) {
    .join("");
 };
 ```
+
+## Explanation
+
+<YouTube id="OXdXc9HTrIg" title="Sort Characters By Frequency - Leetcode 451 - Python" />
@@ -22,6 +22,24 @@ sidebar:
 - `1 <= s1.length, s2.length <= 10^4`
 - `s1` and `s2` consist of lowercase English letters.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["checkInclusion(s1, s2)"]) --> G{"k = len(s1) > len(s2)?"}
+  G -- yes --> X(["return False"])
+  G -- no --> I["need = Counter(s1), window = Counter()"]
+  I --> L{"more (right, c) in s2?"}
+  L -- no --> E(["return False"])
+  L -- yes --> A["window[c] += 1"]
+  A --> B{"right >= k? — window is now longer than k"}
+  B -- yes --> C["drop s2[right - k] from window, deleting the key at 0"]
+  B -- no --> Q
+  C --> Q{"window == need?"}
+  Q -- yes --> R(["return True"])
+  Q -- no --> L
+```
+
 ## Solution

 ```py
@@ -49,3 +67,7 @@ class Solution:

        return False
 ```
+
+## Explanation
+
+<YouTube id="UbyhOgBN834" title="Permutation in String - Leetcode 567 - Python" />
@@ -0,0 +1,57 @@
+---
+title: '2. Add Two Numbers'
+description: You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list
+sidebar:
+  label: 'Add Two Numbers'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Hybrid Structures</Badge>
+
+### Example 1:
+- Input: `l1 = [2,4,3], l2 = [5,6,4]`
+- Output: `[7,0,8]`
+- Explanation: `342 + 465 = 807`.
+
+### Example 2:
+- Input: `l1 = [0], l2 = [0]`
+- Output: `[0]`
+
+### Example 3:
+- Input: `l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]`
+- Output: `[8,9,9,9,0,0,0,1]`
+
+### Constraints:
+
+- The number of nodes in each linked list is in the range [1, 100].
+- `0 <= Node.val <= 9`
+- It is guaranteed that the list represents a number that does not have leading zeros.
+
+## Solution
+
+```py
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def addTwoNumbers(
+        self, l1: Optional[ListNode], l2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+
+        dummy = ListNode()
+        carry = 0
+        curr = dummy
+        while l1 or l2 or carry:
+            s = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
+            carry, val = divmod(s, 10)
+
+            curr.next = ListNode(val)
+            curr = curr.next
+
+            l1 = l1.next if l1 else None
+            l2 = l2.next if l2 else None
+
+        return dummy.next
+```
@@ -29,6 +29,19 @@ A linked list can be reversed either iteratively or recursively. Could you imple
 - The number of nodes in the list is the range [0, 5000].
 - `-5000 <= Node.val <= 5000`

+## Approach
+
+```mermaid
+flowchart TD
+  S(["reverseList(head)"]) --> I["prev = None, curr = head"]
+  I --> W{"curr?"}
+  W -- no --> E(["return prev — the old tail is the new head"])
+  W -- yes --> A["next_ = curr.next — save it before overwriting"]
+  A --> B["curr.next = prev — flip the link"]
+  B --> C["prev = curr; curr = next_ — step forward"]
+  C --> W
+```
+
 ## Solution

 ```py
@@ -48,3 +61,7 @@ class Solution:
            curr = next_
        return prev
 ```
+
+## Explanation
+
+<YouTube id="G0_I-ZF0S38" title="Reverse Linked List - Iterative AND Recursive - Leetcode 206 - Python" />
@@ -26,6 +26,23 @@ sidebar:
 - `-100 <= Node.val <= 100`
 - Both list1 and list2 are sorted in non-decreasing order.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["mergeTwoLists(list1, list2)"]) --> G1{"list1 empty?"}
+  G1 -- yes --> X1(["return list2"])
+  G1 -- no --> G2{"list2 empty?"}
+  G2 -- yes --> X2(["return list1"])
+  G2 -- no --> H["head = the smaller first node; advance that list"]
+  H --> C["current = head"]
+  C --> W{"list1 and list2 both non-empty?"}
+  W -- yes --> P["current.next = the smaller node; advance that list; current = current.next"]
+  P --> W
+  W -- no --> T["current.next = list1 or list2 — append the leftover tail"]
+  T --> E(["return head"])
+```
+
 ## Solution

 ```py
@@ -64,3 +81,7 @@ class Solution:
        current.next = list1 or list2
        return head
 ```
+
+## Explanation
+
+<YouTube id="XIdigk956u0" title="Merge Two Sorted Lists - Leetcode 21 - Python" />
@@ -0,0 +1,69 @@
+---
+title: '23. Merge k Sorted Lists'
+description: You are given an array of k linked-lists lists, each linked-list is sorted in ascending order
+sidebar:
+  label: 'Merge k Sorted Lists'
+  badge: 'Hard'
+---
+
+<Badge variant="accent">Heap / Priority Queue</Badge>
+
+### Example 1:
+- Input: `lists = [[1,4,5],[1,3,4],[2,6]]`
+- Output: `[1,1,2,3,4,4,5,6]`
+- Explanation: The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted linked list: 1->1->2->3->4->4->5->6
+
+### Example 2:
+- Input: `lists = []`
+- Output: `[]`
+
+### Example 3:
+- Input: `lists = [[]]`
+- Output: `[]`
+
+### Constraints:
+
+- `k == lists.length`
+- `0 <= k <= 10^4`
+- `0 <= lists[i].length <= 500`
+- `-10^4 <= lists[i][j] <= 10^4`
+- `lists[i]` is sorted in ascending order.
+- The sum of lists[i].length will not exceed 10^4.
+
+## Solution
+
+```py
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+import heapq
+
+
+class Solution:
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        heap = []
+
+        # K log K
+        for i, node in enumerate(lists):
+            if node:
+                heapq.heappush(heap, (node.val, i, node))
+
+        D = ListNode()
+        cur = D
+
+        # n log k
+        while heap:
+            val, i, node = heapq.heappop(heap)
+            cur.next = node
+            cur = node
+            node = node.next
+
+            if node:
+                heapq.heappush(heap, (node.val, i, node))
+
+        # Time: O(N log k)
+        # Space: O(n)
+        return D.next
+```
@@ -23,6 +23,28 @@ You must implement a solution with O(1) time complexity for each function.
 - Methods pop, top and getMin operations will always be called on non-empty stacks.
 - At most 3 * 10^4 calls will be made to push, pop, top, and getMin.

+## Approach
+
+```mermaid
+flowchart TD
+  subgraph state["two parallel stacks — same depth, always"]
+    A["stack — the values"]
+    B["minStack — the minimum as of that depth"]
+  end
+  state --> P
+  subgraph P["push(value)"]
+    P1["stack.append(value)"] --> P2["minStack.append(min(value, minStack[-1]))"]
+  end
+  state --> O
+  subgraph O["pop()"]
+    O1["pop both stacks together"]
+  end
+  state --> R
+  subgraph R["top() / getMin() — O(1)"]
+    R1(["stack[-1] / minStack[-1]"])
+  end
+```
+
 ## Solution

 ```py
@@ -54,3 +76,7 @@ class MinStack:
 # param_3 = obj.top()
 # param_4 = obj.getMin()
 ```
+
+## Explanation
+
+<YouTube id="qkLl7nAwDPo" title="Design Min Stack - Amazon Interview Question - Leetcode 155 - Python" />
@@ -33,6 +33,24 @@ sidebar:
 - `1 <= s.length <= 10^4`
 - `s` consists of parentheses only '()[]{}'.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["isValid(s)"]) --> I["stack = [], pairs = closer to opener"]
+  I --> L{"more char c?"}
+  L -- no --> Z{"stack empty?"}
+  Z -- yes --> T(["return True"])
+  Z -- no --> U(["return False — unclosed openers left"])
+  L -- yes --> Q{"c is a closer?"}
+  Q -- no --> A["stack.append(c) — it is an opener"]
+  A --> L
+  Q -- yes --> M{"stack non-empty and pairs[c] == stack[-1]?"}
+  M -- yes --> P["stack.pop() — matched"]
+  P --> L
+  M -- no --> F(["return False — mismatch"])
+```
+
 ## Solution

 ```py
@@ -52,3 +70,7 @@ class Solution:

        return True if not stack else False
 ```
+
+## Explanation
+
+<YouTube id="WTzjTskDFMg" title="Valid Parentheses - Stack - Leetcode 20 - Python" />
@@ -0,0 +1,65 @@
+---
+title: '211. Design Add and Search Words Data Structure'
+description: Design a data structure that supports adding new words and finding if a string matches any previously added string
+sidebar:
+  label: 'Design Add and Search Words Data Structure'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Trie</Badge>
+
+### Constraints:
+
+- `1 <= word.length <= 25`
+- `word` in addWord consists of lowercase English letters.
+- `word` in search consist of '.' or lowercase English letters.
+- There will be at most 2 dots in `word` for search queries.
+- At most 10^4 calls will be made to addWord and search.
+
+## Solution
+
+```py
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.endOfWord = False
+
+
+class WordDictionary:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def addWord(self, word: str) -> None:
+        cur = self.root
+        for c in word:
+            if c not in cur.children:
+                cur.children[c] = TrieNode()
+            cur = cur.children[c]
+        cur.endOfWord = True
+
+    # Leverage Recursion
+    def search(self, word: str) -> bool:
+        def dfs(j, root):
+            cur = root
+            for i in range(j, len(word)):
+                c = word[i]
+
+                if c == ".":
+                    for child in cur.children.values():
+                        if dfs(i + 1, child):
+                            return True
+                    return False
+                else:
+                    if c not in cur.children:
+                        return False
+                    cur = cur.children[c]
+            return cur.endOfWord
+
+        return dfs(0, self.root)
+
+
+# Your WordDictionary object will be instantiated and called as such:
+# obj = WordDictionary()
+# obj.addWord(word)
+# param_2 = obj.search(word)
+```
@@ -0,0 +1,61 @@
+---
+title: '102. Binary Tree Level Order Traversal'
+description: Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level)
+sidebar:
+  label: 'Binary Tree Level Order Traversal'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Tree BFS</Badge>
+
+### Example 1:
+- Input: `root = [3,9,20,null,null,15,7]`
+- Output: `[[3],[9,20],[15,7]]`
+
+### Example 2:
+- Input: `root = [1]`
+- Output: `[[1]]`
+
+### Example 3:
+- Input: `root = []`
+- Output: `[]`
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [0, 2000].
+- `-1000 <= Node.val <= 1000`
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+
+
+class Solution:
+    # T: O(n) S: O(n)
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        res = []
+
+        q = deque()
+        q.append(root)
+
+        while q:
+            qLen = len(q)
+            level = []
+            for i in range(qLen):
+                node = q.popleft()
+                if node:
+                    level.append(node.val)
+                    q.append(node.left)
+                    q.append(node.right)
+            if level:
+                res.append(level)
+
+        return res
+```
@@ -0,0 +1,39 @@
+---
+title: '104. Maximum Depth of Binary Tree'
+description: Given the root of a binary tree, return its maximum depth
+sidebar:
+  label: 'Maximum Depth of Binary Tree'
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Tree DFS</Badge>
+
+### Example 1:
+- Input: `root = [3,9,20,null,null,15,7]`
+- Output: `3`
+
+### Example 2:
+- Input: `root = [1,null,2]`
+- Output: `2`
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [0, 10^4].
+- `-100 <= Node.val <= 100`
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
+```
@@ -0,0 +1,52 @@
+---
+title: '1448. Count Good Nodes in Binary Tree'
+description: Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X
+sidebar:
+  label: 'Count Good Nodes in Binary Tree'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Tree BFS</Badge>
+
+### Example 1:
+- Input: `root = [3,1,4,3,null,1,5]`
+- Output: `4`
+- Explanation: Nodes in blue are good. Root Node `(3`) is always a good node. Node `4` -> (3,4) is the maximum value in the path starting from the `root`. Node `5` -> (3,4,5) is the maximum value in the path Node `3` -> (3,1,3) is the maximum value in the path.
+
+### Example 2:
+- Input: `root = [3,3,null,4,2]`
+- Output: `3`
+- Explanation: Node `2` -> `(3`, `3`, `2`) is not good, because `"3`" is higher than it.
+
+### Example 3:
+- Input: `root = [1]`
+- Output: `1`
+- Explanation: Root is considered as good.
+
+### Constraints:
+
+- The number of nodes in the binary tree is in the range [1, 10^5].
+- Each node's value is between [-10^4, 10^4].
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def goodNodes(self, root: TreeNode) -> int:
+        def dfs(node, max_val):
+            if not node:
+                return 0
+
+            is_good = 1 if node.val >= max_val else 0
+            new_max = max(max_val, node.val)
+
+            return is_good + dfs(node.left, new_max) + dfs(node.right, new_max)
+
+        return dfs(root, root.val)
+```
@@ -0,0 +1,64 @@
+---
+title: '199. Binary Tree Right Side View'
+description: Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom
+sidebar:
+  label: 'Binary Tree Right Side View'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Tree BFS</Badge>
+
+### Example 1:
+- Input: `root = [1,2,3,null,5,null,4]`
+- Output: `[1,3,4]`
+
+### Example 2:
+- Input: `root = [1,2,3,4,null,null,null,5]`
+- Output: `[1,3,4,5]`
+
+### Example 3:
+- Input: `root = [1,null,3]`
+- Output: `[1,3]`
+
+### Example 4:
+- Input: `root = []`
+- Output: `[]`
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [0, 100].
+- `-100 <= Node.val <= 100`
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from collections import deque
+
+
+class Solution:
+    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
+        res = []
+        q = deque([root])
+
+        while q:
+            rightSide = None
+            qLen = len(q)
+
+            for i in range(qLen):
+                node = q.popleft()
+                if node:
+                    rightSide = node
+                    q.append(node.left)
+                    q.append(node.right)
+
+            if rightSide:
+                res.append(rightSide.val)
+
+        return res
+```
@@ -0,0 +1,49 @@
+---
+title: '226. Invert Binary Tree'
+description: Given the root of a binary tree, invert the tree, and return its root
+sidebar:
+  label: 'Invert Binary Tree'
+  badge: 'Easy'
+---
+
+<Badge variant="accent">Tree DFS</Badge>
+
+### Example 1:
+- Input: `root = [4,2,7,1,3,6,9]`
+- Output: `[4,7,2,9,6,3,1]`
+
+### Example 2:
+- Input: `root = [2,1,3]`
+- Output: `[2,3,1]`
+
+### Example 3:
+- Input: `root = []`
+- Output: `[]`
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [0, 100].
+- `-100 <= Node.val <= 100`
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root:
+            return None
+
+        left = self.invertTree(root.left)
+        right = self.invertTree(root.right)
+
+        root.left = right
+        root.right = left
+
+        return root
+```
@@ -0,0 +1,54 @@
+---
+title: '230. Kth Smallest Element in a BST'
+description: Given the root of a binary search tree, and an integer k, return the k^th smallest value (1-indexed) of all the values of the nodes in the tree
+sidebar:
+  label: 'Kth Smallest Element in a BST'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Binary Search Tree</Badge>
+
+::::warning
+If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?
+::::
+
+### Example 1:
+- Input: `root = [3,1,4,null,2], k = 1`
+- Output: `1`
+
+### Example 2:
+- Input: `root = [5,3,6,2,4,null,null,1], k = 3`
+- Output: `3`
+
+### Constraints:
+
+- The number of nodes in the tree is n.
+- `1 <= k <= n <= 10^4`
+- `0 <= Node.val <= 10^4`
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        n = 0
+        stack = []
+        cur = root
+
+        while cur or stack:
+            while cur:
+                stack.append(cur)
+                cur = cur.left
+
+            cur = stack.pop()
+            n += 1
+            if n == k:
+                return cur.val
+            cur = cur.right
+```
@@ -0,0 +1,56 @@
+---
+title: '235. Lowest Common Ancestor of a Binary Search Tree'
+description: Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST
+sidebar:
+  label: 'Lowest Common Ancestor of a Binary Search Tree'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Binary Search Tree</Badge>
+
+### Example 1:
+- Input: `root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8`
+- Output: `6`
+- Explanation: The LCA of nodes `2` and `8` is `6`.
+
+### Example 2:
+- Input: `root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4`
+- Output: `2`
+- Explanation: The LCA of nodes `2` and `4` is `2`, since a node can be a descendant of itself according to the LCA definition.
+
+### Example 3:
+- Input: `root = [2,1], p = 2, q = 1`
+- Output: `2`
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [2, 10^5].
+- `-10^9 <= Node.val <= 10^9`
+- All Node.val are unique.
+- `p != q`
+- p and q will exist in the BST.
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+
+class Solution:
+    def lowestCommonAncestor(
+        self, root: "TreeNode", p: "TreeNode", q: "TreeNode"
+    ) -> "TreeNode":
+        cur = root
+        while cur:
+            if p.val < cur.val and q.val < cur.val:
+                cur = cur.left
+            elif p.val > cur.val and q.val > cur.val:
+                cur = cur.right
+            else:
+                return cur
+```
@@ -0,0 +1,62 @@
+---
+title: '236. Lowest Common Ancestor of a Binary Tree'
+description: Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree
+sidebar:
+  label: 'Lowest Common Ancestor of a Binary Tree'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Tree DFS</Badge>
+
+### Example 1:
+- Input: `root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1`
+- Output: `3`
+- Explanation: The LCA of nodes `5` and `1` is `3`.
+
+### Example 2:
+- Input: `root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4`
+- Output: `5`
+- Explanation: The LCA of nodes `5` and `4` is `5`, since a node can be a descendant of itself according to the LCA definition.
+
+### Example 3:
+- Input: `root = [1,2], p = 1, q = 2`
+- Output: `1`
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [2, 10^5].
+- `-10^9 <= Node.val <= 10^9`
+- All Node.val are unique.
+- `p != q`
+- p and q will exist in the tree.
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+
+class Solution:
+    def lowestCommonAncestor(
+        self, root: "TreeNode", p: "TreeNode", q: "TreeNode"
+    ) -> "TreeNode":
+
+        if not root:
+            return None
+
+        if root == p or root == q:
+            return root
+
+        l = self.lowestCommonAncestor(root.left, p, q)
+        r = self.lowestCommonAncestor(root.right, p, q)
+
+        if l and r:
+            return root
+        else:
+            return l or r
+```
@@ -0,0 +1,46 @@
+---
+title: '98. Validate Binary Search Tree'
+description: Given the root of a binary tree, determine if it is a valid binary search tree (BST)
+sidebar:
+  label: 'Validate Binary Search Tree'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Binary Search Tree</Badge>
+
+### Example 1:
+- Input: `root = [2,1,3]`
+- Output: `true`
+
+### Example 2:
+- Input: `root = [5,1,4,null,null,3,6]`
+- Output: `false`
+- Explanation: The `root` node's value is `5` but its right child's value is `4`.
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [1, 10^4].
+- `-2^31 <= Node.val <= 2^31 - 1`
+
+## Solution
+
+```py
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        def valid(node, low, high):
+            if not node:
+                return True
+
+            if not (low < node.val < high):
+                return False
+
+            return valid(node.left, low, node.val) and valid(node.right, node.val, high)
+
+        return valid(root, float("-inf"), float("inf"))
+```
@@ -28,6 +28,20 @@ sidebar:
 - `1 <= s.length <= 2 * 10^5`
 - `s` consists only of printable ASCII characters.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["isPalindrome(s)"]) --> N["normal = s stripped of non-alphanumerics, lowercased"]
+  N --> I["i = 0, j = normal.length - 1"]
+  I --> W{"i < j?"}
+  W -- no --> E(["return true — the pointers met in the middle"])
+  W -- yes --> Q{"normal[i] != normal[j]?"}
+  Q -- yes --> F(["return false"])
+  Q -- no --> A["i++; j-- — step both inward"]
+  A --> W
+```
+
 ## Solution

 ```js
@@ -49,3 +63,7 @@ var isPalindrome = function(s) {
  return true;
 };
 ```
+
+## Explanation
+
+<YouTube id="jJXJ16kPFWg" title="Valid Palindrome - Leetcode 125 - Python" />
@@ -25,6 +25,18 @@ You must do this by modifying the input array in-place with O(1) extra memory.
 - `1 <= s.length <= 10^5`
 - `s[i]` is a printable ascii character.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["reverseString(s)"]) --> I["i = 0, j = s.length - 1"]
+  I --> W{"i < j?"}
+  W -- no --> E(["done — s was reversed in place, nothing returned"])
+  W -- yes --> A["swap s[i] and s[j]"]
+  A --> B["i++; j--"]
+  B --> W
+```
+
 ## Solution

 ```js
@@ -43,3 +55,7 @@ var reverseString = function(s) {
    }   
 };
 ```
+
+## Explanation
+
+<YouTube id="_d0T_2Lk2qA" title="Reverse String - 3 Ways - Leetcode 344 - Python" />
@@ -26,6 +26,22 @@ Suppose there are lots of incoming s, say s1, s2, ..., sk where k >= 10^9, and y
 - `0 <= t.length <= 10^4`
 - `s` and `t` consist only of lowercase English letters.

+## Approach
+
+```mermaid
+flowchart TD
+  S(["isSubsequence(s, t)"]) --> G{"len(s) > len(t)?"}
+  G -- yes --> X(["return False"])
+  G -- no --> I["i = 0 into s, j = 0 into t"]
+  I --> W{"i < len(s) and j < len(t)?"}
+  W -- no --> E(["return i == len(s) — every char of s was matched"])
+  W -- yes --> Q{"s[i] == t[j]?"}
+  Q -- yes --> A["i += 1 — consume the match"]
+  Q -- no --> B["j += 1 — always advance t"]
+  A --> B
+  B --> W
+```
+
 ## Solution

 ```py
@@ -42,3 +58,7 @@ class Solution:

        return i == len(s)
 ```
+
+## Explanation
+
+<YouTube id="99RVfqklbCE" title="Is Subsequence - Leetcode 392" />
@@ -1,12 +1,11 @@
 ---
-title: Introduction
-description: Welcome to your new Blume docs.
+title: Overview
+description: Live SRS campaign dashboard — phases, ladder, review queue, gates, and recent attempts, fetched from the SRS Worker.
 ---

-## Getting Started
-
 ![Dependency Map](../public/dependency-spine.svg)

-Welcome to **Blume** — markdown-first docs powered by Astro and Vite.
+Live view of the 56-day campaign. Everything below is fetched client-side
+from the SRS Worker, so it is always current — no rebuild required.

-Edit `docs/index.mdx` to get started, then run `blume dev`.
+<ProgressDashboard />
@@ -1,9 +0,0 @@
---
-title: Progress
-description: Live SRS campaign dashboard — phases, ladder, review queue, gates, and recent attempts, fetched from the SRS Worker.
---
-
-Live view of the 56-day campaign. Everything below is fetched client-side
-from the SRS Worker, so it is always current — no rebuild required.
-
-<ProgressDashboard />
@@ -0,0 +1,181 @@
+---
+hidden: true
+---
+
+# todo — draining the review backlog
+
+every solution in `work/1` owes a blind re-solve at `work/3` and a second one at `work/7`. both buckets are empty, so 36 problems owe 72 re-solves and not one has been started. snapshot: `reviewqueues("2026-08-31")` from `apps/cli/work.ts` — what `bun run pick` shows — cross-checked against `/api/stats`.
+
+at 10 problems a day *including* the campaign's own load, 72 re-solves do not fit in one week: this week absorbs 38, the `+3` rung finishes **sat sep 5** (campaign day 20), the last `+7` clears **fri sep 18** (day 33), and normal srs resumes **sat sep 19** — see [when standard srs resumes](#when-standard-srs-resumes). saturday gates are deliberately left out of the count.
+
+## rules this plan follows
+
+- **≤ 10 problems a day, everything counted.** each day's new core set and the on-time reviews it earns are booked first; the backlog takes what is left — 7 slots on a light day, 2 on a heavy one.
+- **coverage before depth.** all 36 `+3` re-solves come first — one blind pass over everything — before any problem gets its `+7`.
+- **oldest first.** lc 387 and lc 1365 have been sitting 50 days.
+- **≥ 3 days between a problem's own `+3` and `+7`.** two re-solves in one day test nothing.
+- **sunday is not a slot.** `workingday()` never mints one; neither does this list.
+- **re-solve blind, then push.** `bun run pick` (tab cycles to the 3-day and 7-day sections) scaffolds straight into `work/3`/`work/7`. do not open `work/1` first. pushing the file is the log: `close-solved.yml` posts the bucket to `/admin/solved` and d1 moves the problem up the ladder.
+
+## this week
+
+### mon aug 31 — 3 new + 7 backlog = 10/10
+
+*topic 08 — linked list ([#10](https://github.com/prdlk/leetcode/issues/10), closed today)*
+
+| bucket | problem | difficulty | where | why |
+| --- | --- | --- | --- | --- |
+| `work/1` | [lc 21 · merge two sorted lists](https://github.com/prdlk/leetcode/issues/78) | easy | linked list | done today |
+| `work/1` | [lc 206 · reverse linked list](https://github.com/prdlk/leetcode/issues/77) | easy | linked list | done today |
+| `work/1` | [lc 141 · linked list cycle](https://github.com/prdlk/leetcode/issues/79) | easy | hash table | done today |
+| `work/3` | lc 387 · first unique character in a string | easy | hash table | 50d stale — first solved 2026-07-12 |
+| `work/3` | lc 1365 · how many numbers are smaller than the current number | easy | array | 50d stale — first solved 2026-07-12 |
+| `work/3` | lc 268 · missing number | easy | array | 14d stale — first solved 2026-08-17 |
+| `work/3` | lc 344 · reverse string | easy | two pointers | 14d stale — first solved 2026-08-17 |
+| `work/3` | lc 1426 · counting elements | easy | array | 14d stale — first solved 2026-08-17 |
+| `work/3` | lc 1832 · check if the sentence is pangram | easy | hash table | 14d stale — first solved 2026-08-17 |
+| `work/3` | [lc 15 · 3sum](https://github.com/prdlk/leetcode/issues/43) | medium | array | 13d stale — first solved 2026-08-18 |
+
+### tue sep 1 — 2 new + 8 backlog = 10/10
+
+*topic 09 — hybrid structures ([#11](https://github.com/prdlk/leetcode/issues/11))*
+
+| bucket | problem | difficulty | where | why |
+| --- | --- | --- | --- | --- |
+| `work/1` | [lc 146 · lru cache](https://github.com/prdlk/leetcode/issues/87) | medium | topic 09 — hybrid structures | new core problem |
+| `work/1` | [lc 2 · add two numbers](https://github.com/prdlk/leetcode/issues/88) | medium | topic 09 — hybrid structures | new core problem |
+| `work/3` | [lc 49 · group anagrams](https://github.com/prdlk/leetcode/issues/30) | medium | array | 13d stale — first solved 2026-08-18 |
+| `work/3` | [lc 125 · valid palindrome](https://github.com/prdlk/leetcode/issues/41) | easy | two pointers | 13d stale — first solved 2026-08-18 |
+| `work/3` | [lc 167 · two sum ii - input array is sorted](https://github.com/prdlk/leetcode/issues/42) | medium | array | 13d stale — first solved 2026-08-18 |
+| `work/3` | [lc 217 · contains duplicate](https://github.com/prdlk/leetcode/issues/27) | easy | array | 13d stale — first solved 2026-08-18 |
+| `work/3` | [lc 238 · product of array except self](https://github.com/prdlk/leetcode/issues/37) | medium | array | 13d stale — first solved 2026-08-18 |
+| `work/3` | [lc 242 · valid anagram](https://github.com/prdlk/leetcode/issues/28) | easy | hash table | 13d stale — first solved 2026-08-18 |
+| `work/3` | [lc 303 · range sum query - immutable](https://github.com/prdlk/leetcode/issues/36) | easy | array | 13d stale — first solved 2026-08-18 |
+| `work/3` | [lc 560 · subarray sum equals k](https://github.com/prdlk/leetcode/issues/38) | medium | array | 13d stale — first solved 2026-08-18 |
+
+### wed sep 2 — 3 new + 7 backlog = 10/10
+
+*topic 10 — matrix index math ([#12](https://github.com/prdlk/leetcode/issues/12))*
+
+| bucket | problem | difficulty | where | why |
+| --- | --- | --- | --- | --- |
+| `work/1` | [lc 48 · rotate image](https://github.com/prdlk/leetcode/issues/91) | medium | topic 10 — matrix index math | new core problem |
+| `work/1` | [lc 54 · spiral matrix](https://github.com/prdlk/leetcode/issues/92) | medium | topic 10 — matrix index math | new core problem |
+| `work/1` | [lc 73 · set matrix zeroes](https://github.com/prdlk/leetcode/issues/93) | medium | topic 10 — matrix index math | new core problem |
+| `work/3` | lc 1413 · minimum value to get positive step by step sum | easy | array | 13d stale — first solved 2026-08-18 |
+| `work/3` | lc 1480 · running sum of 1d array | easy | array | 13d stale — first solved 2026-08-18 |
+| `work/3` | [lc 33 · search in rotated sorted array](https://github.com/prdlk/leetcode/issues/60) | medium | array | 12d stale — first solved 2026-08-19 |
+| `work/3` | [lc 704 · binary search](https://github.com/prdlk/leetcode/issues/58) | easy | array | 12d stale — first solved 2026-08-19 |
+| `work/3` | [lc 875 · koko eating bananas](https://github.com/prdlk/leetcode/issues/59) | medium | array | 12d stale — first solved 2026-08-19 |
+| `work/3` | [lc 977 · squares of a sorted array](https://github.com/prdlk/leetcode/issues/46) | easy | array | 12d stale — first solved 2026-08-19 |
+| `work/3` | [lc 121 · best time to buy and sell stock](https://github.com/prdlk/leetcode/issues/50) | easy | array | 11d stale — first solved 2026-08-20 |
+
+### thu sep 3 — 3 new + 3 on-time reviews + 4 backlog = 10/10
+
+*topic 11 — tree dfs ([#13](https://github.com/prdlk/leetcode/issues/13))*
+
+| bucket | problem | difficulty | where | why |
+| --- | --- | --- | --- | --- |
+| `work/1` | [lc 226 · invert binary tree](https://github.com/prdlk/leetcode/issues/96) | easy | topic 11 — tree dfs | new core problem |
+| `work/1` | [lc 104 · maximum depth of binary tree](https://github.com/prdlk/leetcode/issues/97) | easy | topic 11 — tree dfs | new core problem |
+| `work/1` | [lc 236 · lowest common ancestor of a binary tree](https://github.com/prdlk/leetcode/issues/98) | medium | topic 11 — tree dfs | new core problem |
+| `work/3` | [lc 21 · merge two sorted lists](https://github.com/prdlk/leetcode/issues/78) | easy | linked list | on time — solved mon aug 31 |
+| `work/3` | [lc 206 · reverse linked list](https://github.com/prdlk/leetcode/issues/77) | easy | linked list | on time — solved mon aug 31 |
+| `work/3` | [lc 141 · linked list cycle](https://github.com/prdlk/leetcode/issues/79) | easy | hash table | on time — solved mon aug 31 |
+| `work/3` | [lc 1 · two sum](https://github.com/prdlk/leetcode/issues/29) | easy | array | 7d stale — first solved 2026-08-24 |
+| `work/3` | [lc 11 · container with most water](https://github.com/prdlk/leetcode/issues/44) | medium | array | 7d stale — first solved 2026-08-24 |
+| `work/3` | [lc 392 · is subsequence](https://github.com/prdlk/leetcode/issues/45) | easy | two pointers | 7d stale — first solved 2026-08-24 |
+| `work/3` | [lc 3 · longest substring without repeating characters](https://github.com/prdlk/leetcode/issues/51) | medium | hash table | 6d stale — first solved 2026-08-25 |
+
+### fri sep 4 — 3 new + 2 on-time reviews + 5 backlog = 10/10
+
+*topic 12 — tree bfs ([#14](https://github.com/prdlk/leetcode/issues/14))*
+
+| bucket | problem | difficulty | where | why |
+| --- | --- | --- | --- | --- |
+| `work/1` | [lc 102 · binary tree level order traversal](https://github.com/prdlk/leetcode/issues/106) | medium | topic 12 — tree bfs | new core problem |
+| `work/1` | [lc 199 · binary tree right side view](https://github.com/prdlk/leetcode/issues/107) | medium | topic 12 — tree bfs | new core problem |
+| `work/1` | [lc 1448 · count good nodes in binary tree](https://github.com/prdlk/leetcode/issues/108) | medium | topic 12 — tree bfs | new core problem |
+| `work/3` | [lc 146 · lru cache](https://github.com/prdlk/leetcode/issues/87) | medium | topic 09 — hybrid structures | on time — solved tue sep 1 |
+| `work/3` | [lc 2 · add two numbers](https://github.com/prdlk/leetcode/issues/88) | medium | topic 09 — hybrid structures | on time — solved tue sep 1 |
+| `work/3` | [lc 424 · longest repeating character replacement](https://github.com/prdlk/leetcode/issues/52) | medium | hash table | 6d stale — first solved 2026-08-25 |
+| `work/3` | [lc 567 · permutation in string](https://github.com/prdlk/leetcode/issues/53) | medium | hash table | 6d stale — first solved 2026-08-25 |
+| `work/3` | [lc 35 · search insert position](https://github.com/prdlk/leetcode/issues/63) | easy | array | 5d stale — first solved 2026-08-26 |
+| `work/3` | [lc 74 · search a 2d matrix](https://github.com/prdlk/leetcode/issues/61) | medium | array | 5d stale — first solved 2026-08-26 |
+| `work/3` | [lc 153 · find minimum in rotated sorted array](https://github.com/prdlk/leetcode/issues/62) | medium | array | 5d stale — first solved 2026-08-26 |
+
+### sat sep 5 — 3 on-time reviews + 7 backlog = 10/10
+
+*no new topic — saturday.*
+
+| bucket | problem | difficulty | where | why |
+| --- | --- | --- | --- | --- |
+| `work/3` | [lc 48 · rotate image](https://github.com/prdlk/leetcode/issues/91) | medium | topic 10 — matrix index math | on time — solved wed sep 2 |
+| `work/3` | [lc 54 · spiral matrix](https://github.com/prdlk/leetcode/issues/92) | medium | topic 10 — matrix index math | on time — solved wed sep 2 |
+| `work/3` | [lc 73 · set matrix zeroes](https://github.com/prdlk/leetcode/issues/93) | medium | topic 10 — matrix index math | on time — solved wed sep 2 |
+| `work/3` | [lc 20 · valid parentheses](https://github.com/prdlk/leetcode/issues/67) | easy | string | 4d stale — first solved 2026-08-27 |
+| `work/3` | [lc 150 · evaluate reverse polish notation](https://github.com/prdlk/leetcode/issues/69) | medium | array | 4d stale — first solved 2026-08-27 |
+| `work/3` | [lc 155 · min stack](https://github.com/prdlk/leetcode/issues/68) | medium | stack | 4d stale — first solved 2026-08-27 |
+| `work/3` | [lc 739 · daily temperatures](https://github.com/prdlk/leetcode/issues/72) | medium | array | 3d stale — first solved 2026-08-28 |
+| `work/3` | [lc 853 · car fleet](https://github.com/prdlk/leetcode/issues/73) | medium | array | 3d stale — first solved 2026-08-28 |
+| `work/7` | lc 387 · first unique character in a string | easy | hash table | `+3` was mon aug 31 |
+| `work/7` | lc 1365 · how many numbers are smaller than the current number | easy | array | `+3` was mon aug 31 |
+
+### sun sep 6 — rest day
+
+nothing. by design.
+
+## carry-over
+
+the 34 re-solves that do not fit this week, at the same cap and the same rules. booked = that day's new core set plus the on-time reviews it owes.
+
+| day | topic | booked | backlog re-solves | load |
+| --- | --- | --- | --- | --- |
+| **mon sep 7** | topic 13 — binary search tree | 10 | *none — the day is already full* | 10/10 |
+| **tue sep 8** | topic 14 — heap / priority queue | 7 | `work/7` — lc 268, lc 344, lc 1426 | 10/10 |
+| **wed sep 9** | topic 15 — trie | 5 | `work/7` — lc 1832, lc 15, lc 49, lc 125, lc 167 | 10/10 |
+| **thu sep 10** | topic 16 — graph dfs | 9 | `work/7` — lc 217 | 10/10 |
+| **fri sep 11** | topic 17 — graph bfs | 8 | `work/7` — lc 238, lc 242 | 10/10 |
+| **sat sep 12** | *none — saturday* | 2 | `work/7` — lc 303, lc 560, lc 1413, lc 1480, lc 33, lc 704, lc 875, lc 977 | 10/10 |
+| **mon sep 14** | topic 18 — topological sort | 10 | *none — the day is already full* | 10/10 |
+| **tue sep 15** | topic 19 — union-find | 5 | `work/7` — lc 121, lc 1, lc 11, lc 392, lc 3 | 10/10 |
+| **wed sep 16** | topic 20 — backtracking | 5 | `work/7` — lc 424, lc 567, lc 35, lc 74, lc 153 | 10/10 |
+| **thu sep 17** | topic 21 — 1-d dynamic programming | 8 | `work/7` — lc 20, lc 150 | 10/10 |
+| **fri sep 18** | topic 22 — multi-d / grid dp | 7 | `work/7` — lc 155, lc 739, lc 853 | 10/10 |
+
+## when standard srs resumes
+
+- **sat sep 5** (campaign day 20) — the `+3` rung is empty. every one of the 36 has been recalled blind once; nothing is unretrieved any more.
+- **fri sep 18** (campaign day 33) — the last backlog `+7` lands. `work/3` and `work/7` hold a file for all 36, so `reviewqueues()` owes nothing; the 28 that have a d1 row are `retired` on the ladder, and the 8 listed at the bottom of this file never had one.
+- **sat sep 19 onward — standard srs.** the only reviews left are the ones the campaign itself minted: solve a problem, its `+3` and `+7` come back on `workingday(solve + 3)` and `workingday(solve + 7)`, the digest asks for ≤ `review_cap` (3) a day, `levelreviews()` pushes any excess forward, and `bun run pick`'s 3-day and 7-day sections show only what is due. no dated plan needed after this — the digest *is* the plan.
+
+campaign-native load per working day once the backlog is gone, all of it inside the cap:
+
+| day | topic | new | `work/3` | `work/7` | load |
+| --- | --- | --- | --- | --- | --- |
+| **sat sep 19** | *review-only* | 0 | 3 | 0 | 3/10 |
+| **mon sep 21** | topic 23 — greedy | 3 | 5 | 2 | 10/10 |
+| **tue sep 22** | topic 24 — intervals | 3 | 1 | 2 | 6/10 |
+| **wed sep 23** | *review-only* | 0 | 0 | 3 | 3/10 |
+| **thu sep 24** | *review-only* | 0 | 3 | 3 | 6/10 |
+| **fri sep 25** | *review-only* | 0 | 3 | 3 | 6/10 |
+| **sat sep 26** | *review-only* | 0 | 0 | 0 | 0/10 |
+| **mon sep 28** | *review-only* | 0 | 0 | 3 | 3/10 |
+| **tue sep 29** | *review-only* | 0 | 0 | 3 | 3/10 |
+
+two things to watch there. **mon sep 21 is 10/10 on campaign load alone** — topic 23's core set, two `+7`s, and five of the six `+3`s that land there (thursday's three slide off sunday onto monday, friday's three land natively, and the sixth is pushed to tuesday exactly as `levelreviews()` would) — so one slipped day re-opens a backlog. and from **wed sep 30** the ladder runs dry: `apps/api/data/schedule.json` books its last topic tue sep 22, so the review-only weeks that close the campaign are drills, optional sets and the weekly gates, none of which this file counts.
+
+## not reviews
+
+three july scaffolds in `work/1` are still empty, so they owe no re-solve — they are unsolved problems, and `bun run pick` still lists them in its new-problem section:
+
+| problem | difficulty |
+| --- | --- |
+| [lc 347 · top k frequent elements](https://github.com/prdlk/leetcode/issues/31) | medium |
+| lc 451 · sort characters by frequency | medium |
+| lc 1636 · sort array by increasing frequency | easy |
+
+## what this plan exposes
+
+- **8 of the 36 have no problem issue** (387, 1365, 268, 344, 1426, 1832, 1413, 1480) — pre-campaign solves. the catalog reconcile never invents rows, so d1 does not know them and no digest can ever surface them. `bun run pick` is the only thing that will ask for these reviews.
+- **`/api/stats` reports a stage that does not exist**: `ladder: { new: 128, "+3": 3, "+7": 0, retired: 0, "+2": 30 }`. `+2` is not in `stages` (`apps/api/src/srs.ts`), so 30 rows sit on a pre-`0002` rung — which is why the digest queue plateaus at 32 due instead of tracking the tables above. that wants a migration, not a re-solve.
@@ -46,7 +46,8 @@ interface Stats {
  }[];
  streak: number;
  queue: { date: string; due: number }[];
-  recent: { date: string; attempts: number; passes: number }[];
+  /** Every campaign day, zeros included; this page reads only the tail. */
+  heat: { date: string; attempts: number; passes: number }[];
 }

 function isStats(value: unknown): value is Stats {
@@ -60,7 +61,7 @@ function isStats(value: unknown): value is Stats {
    Array.isArray(v.phases) &&
    Array.isArray(v.gates) &&
    Array.isArray(v.queue) &&
-    Array.isArray(v.recent) &&
+    Array.isArray(v.heat) &&
    typeof v.streak === "number"
  );
 }
@@ -332,11 +333,14 @@ const GREENS = [
 ];

 function Recent({ stats }: { stats: Stats }) {
+  // heat spans the whole campaign, future days and all. The window wanted here
+  // is the seven days ending today, and campaign.day is that day, 1-based.
+  const week = stats.heat.slice(Math.max(0, stats.campaign.day - 7), stats.campaign.day);
  return (
    <div style={card}>
      <div style={heading}>Last 7 days</div>
      <div style={{ display: "flex", gap: "0.4rem", flexWrap: "wrap" }}>
-        {stats.recent.map((r) => (
+        {week.map((r) => (
          <span
            key={r.date}
            title={`${r.date}: ${r.passes}/${r.attempts} passed`}
@@ -15,6 +15,7 @@
    "api:deploy": "cd apps/api && bun run deploy",
    "api:test": "cd apps/api && bun test src",
    "pick": "bun apps/cli/pick.ts",
+    "stats": "bun apps/cli/stats.ts",
    "sync": "bun apps/cli/sync.ts",
    "submit": "bun apps/cli/submit.ts",
    "test": "bun apps/cli/test.ts"
@@ -0,0 +1,51 @@
+"""
+217. Contains Duplicate
+Difficulty: Easy
+https://leetcode.com/problems/contains-duplicate/
+
+──────────────────────────────────────────────────
+
+Given an integer array nums, return true if any value appears at
+least twice in the array, and return false if every element is
+distinct.
+
+ 
+
+Example 1:
+
+Input: nums = [1,2,3,1]
+
+Output: true
+
+Explanation:
+
+The element 1 occurs at the indices 0 and 3.
+
+Example 2:
+
+Input: nums = [1,2,3,4]
+
+Output: false
+
+Explanation:
+
+All elements are distinct.
+
+Example 3:
+
+Input: nums = [1,1,1,3,3,4,3,2,4,2]
+
+Output: true
+
+ 
+
+Constraints:
+
+	• 1 <= nums.length <= 10^5
+
+	• -10^9 <= nums[i] <= 10^9
+"""
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        
@@ -0,0 +1,46 @@
+"""
+104. Maximum Depth of Binary Tree
+Difficulty: Easy
+https://leetcode.com/problems/maximum-depth-of-binary-tree/
+
+──────────────────────────────────────────────────
+
+Given the root of a binary tree, return its maximum depth.
+
+A binary tree's maximum depth is the number of nodes along the
+longest path from the root node down to the farthest leaf node.
+
+
+
+Example 1:
+
+Input: root = [3,9,20,null,null,15,7]
+Output: 3
+
+Example 2:
+
+Input: root = [1,null,2]
+Output: 2
+
+
+
+Constraints:
+
+        • The number of nodes in the tree is in the range [0, 10^4].
+
+        • -100 <= Node.val <= 100
+"""
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
@@ -0,0 +1,54 @@
+"""
+226. Invert Binary Tree
+Difficulty: Easy
+https://leetcode.com/problems/invert-binary-tree/
+
+──────────────────────────────────────────────────
+
+Given the root of a binary tree, invert the tree, and return its root.
+
+
+
+Example 1:
+
+Input: root = [4,2,7,1,3,6,9]
+Output: [4,7,2,9,6,3,1]
+
+Example 2:
+
+Input: root = [2,1,3]
+Output: [2,3,1]
+
+Example 3:
+
+Input: root = []
+Output: []
+
+
+
+Constraints:
+
+        • The number of nodes in the tree is in the range [0, 100].
+
+        • -100 <= Node.val <= 100
+"""
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root:
+            return None
+
+        left = self.invertTree(root.left)
+        right = self.invertTree(root.right)
+
+        root.left = right
+        root.right = left
+
+        return root
@@ -0,0 +1,87 @@
+"""
+23. Merge k Sorted Lists
+Difficulty: Hard
+https://leetcode.com/problems/merge-k-sorted-lists/
+
+──────────────────────────────────────────────────
+
+You are given an array of k linked-lists lists, each linked-list is
+sorted in ascending order.
+
+Merge all the linked-lists into one sorted linked-list and return it.
+
+
+
+Example 1:
+
+Input: lists = [[1,4,5],[1,3,4],[2,6]]
+Output: [1,1,2,3,4,4,5,6]
+Explanation: The linked-lists are:
+[
+  1->4->5,
+  1->3->4,
+  2->6
+]
+merging them into one sorted linked list:
+1->1->2->3->4->4->5->6
+
+Example 2:
+
+Input: lists = []
+Output: []
+
+Example 3:
+
+Input: lists = [[]]
+Output: []
+
+
+
+Constraints:
+
+        • k == lists.length
+
+        • 0 <= k <= 10^4
+
+        • 0 <= lists[i].length <= 500
+
+        • -10^4 <= lists[i][j] <= 10^4
+
+        • lists[i] is sorted in ascending order.
+
+        • The sum of lists[i].length will not exceed 10^4.
+"""
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+import heapq
+
+
+class Solution:
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        heap = []
+
+        # K log K
+        for i, node in enumerate(lists):
+            if node:
+                heapq.heappush(heap, (node.val, i, node))
+
+        D = ListNode()
+        cur = D
+
+        # n log k
+        while heap:
+            val, i, node = heapq.heappop(heap)
+            cur.next = node
+            cur = node
+            node = node.next
+
+            if node:
+                heapq.heappush(heap, (node.val, i, node))
+
+        # Time: O(N log k)
+        # Space: O(n)
+        return D.next
@@ -0,0 +1,50 @@
+"""
+215. Kth Largest Element in an Array
+Difficulty: Medium
+https://leetcode.com/problems/kth-largest-element-in-an-array/
+
+──────────────────────────────────────────────────
+
+Given an integer array nums and an integer k, return the k^th largest
+element in the array.
+
+Note that it is the k^th largest element in the sorted order, not the
+k^th distinct element.
+
+Can you solve it without sorting?
+
+
+
+Example 1:
+
+Input: nums = [3,2,1,5,6,4], k = 2
+Output: 5
+
+Example 2:
+
+Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
+Output: 4
+
+
+
+Constraints:
+
+        • 1 <= k <= nums.length <= 10^5
+
+        • -10^4 <= nums[i] <= 10^4
+"""
+
+import heapq
+
+
+class Solution:
+    def findKthLargest(self, nums: List[int], k: int) -> int:
+        for i in range(len(nums)):
+            nums[i] = -nums[i]
+
+        heapq.heapify(nums)
+
+        for _ in range(k - 1):
+            heapq.heappop(nums)
+
+        return -heapq.heappop(nums)
@@ -0,0 +1,92 @@
+"""
+271. Encode and Decode Strings
+Difficulty: Medium
+https://leetcode.com/problems/encode-and-decode-strings/
+
+──────────────────────────────────────────────────
+
+Design an algorithm to encode a list of strings to a string. The
+encoded string is then sent over the network and is decoded back to
+the original list of strings.
+
+Machine 1 (sender) has the function:
+
+string encode(vector<string> strs) {
+  // ... your code
+  return encoded_string;
+}
+Machine 2 (receiver) has the function:
+
+vector<string> decode(string s) {
+  //... your code
+  return strs;
+}
+
+So Machine 1 does:
+
+string encoded_string = encode(strs);
+
+and Machine 2 does:
+
+vector<string> strs2 = decode(encoded_string);
+
+strs2 in Machine 2 should be the same as strs in Machine 1.
+
+Implement the encode and decode methods.
+
+You are not allowed to solve the problem using any serialize methods
+(such as eval).
+
+ 
+
+Example 1:
+
+Input: dummy_input = ["Hello","World"]
+Output: ["Hello","World"]
+Explanation:
+Machine 1:
+Codec encoder = new Codec();
+String msg = encoder.encode(strs);
+Machine 1 ---msg---> Machine 2
+
+Machine 2:
+Codec decoder = new Codec();
+String[] strs = decoder.decode(msg);
+
+Example 2:
+
+Input: dummy_input = [""]
+Output: [""]
+
+ 
+
+Constraints:
+
+	• 1 <= strs.length <= 200
+
+	• 0 <= strs[i].length <= 200
+
+• strs[i] contains any possible characters out of 256 valid ASCII
+characters.
+
+ 
+
+Follow up: Could you write a generalized algorithm to work on any
+possible set of characters?
+"""
+
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        """Encodes a list of strings to a single string.
+        """
+        
+
+    def decode(self, s: str) -> List[str]:
+        """Decodes a single string to a list of strings.
+        """
+        
+
+
+# Your Codec object will be instantiated and called as such:
+# codec = Codec()
+# codec.decode(codec.encode(strs))
@@ -0,0 +1,47 @@
+"""
+48. Rotate Image
+Difficulty: Medium
+https://leetcode.com/problems/rotate-image/
+
+──────────────────────────────────────────────────
+
+You are given an n x n 2D matrix representing an image, rotate the
+image by 90 degrees (clockwise).
+
+You have to rotate the image in-place, which means you have to modify
+the input 2D matrix directly. DO NOT allocate another 2D matrix and do
+the rotation.
+
+
+
+Example 1:
+
+Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
+Output: [[7,4,1],[8,5,2],[9,6,3]]
+
+Example 2:
+
+Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
+
+
+
+Constraints:
+
+        • n == matrix.length == matrix[i].length
+
+        • 1 <= n <= 20
+
+        • -1000 <= matrix[i][j] <= 1000
+"""
+
+
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        n = len(matrix)
+        for r in range(n):
+            for c in range(r + 1, n):
+                matrix[r][c], matrix[c][r] = matrix[c][r], matrix[r][c]
+
+        for r in range(n):
+            matrix[r].reverse()
@@ -0,0 +1,66 @@
+"""
+54. Spiral Matrix
+Difficulty: Medium
+https://leetcode.com/problems/spiral-matrix/
+
+──────────────────────────────────────────────────
+
+Given an m x n matrix, return all elements of the matrix in spiral
+order.
+
+
+
+Example 1:
+
+Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
+Output: [1,2,3,6,9,8,7,4,5]
+
+Example 2:
+
+Input: matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+Output: [1,2,3,4,8,12,11,10,9,5,6,7]
+
+
+
+Constraints:
+
+        • m == matrix.length
+
+        • n == matrix[i].length
+
+        • 1 <= m, n <= 10
+
+        • -100 <= matrix[i][j] <= 100
+"""
+
+
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        res = []
+        top, bottom = 0, len(matrix) - 1
+        left, right = 0, len(matrix[0]) - 1
+
+        while top <= bottom and left <= right:
+            # 1. Top Row
+            for c in range(left, right + 1):
+                res.append(matrix[top][c])
+            top += 1
+
+            # 2. Right Column
+            for r in range(top, bottom + 1):
+                res.append(matrix[r][right])
+            right -= 1
+
+            # 3. Bottom Row
+            if top <= bottom:
+                for c in range(right, left - 1, -1):
+                    res.append(matrix[bottom][c])
+                bottom -= 1
+
+            # 4. Left Column
+            if left <= right:
+                for r in range(bottom, top - 1, -1):
+                    res.append(matrix[r][left])
+                left += 1
+
+        return res
@@ -0,0 +1,81 @@
+"""
+73. Set Matrix Zeroes
+Difficulty: Medium
+https://leetcode.com/problems/set-matrix-zeroes/
+
+──────────────────────────────────────────────────
+
+Given an m x n integer matrix matrix, if an element is 0, set its
+entire row and column to 0's.
+
+You must do it in place.
+
+
+
+Example 1:
+
+Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]
+Output: [[1,0,1],[0,0,0],[1,0,1]]
+
+Example 2:
+
+Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
+
+
+
+Constraints:
+
+        • m == matrix.length
+
+        • n == matrix[0].length
+
+        • 1 <= m, n <= 200
+
+        • -2^31 <= matrix[i][j] <= 2^31 - 1
+
+
+
+Follow up:
+
+• A straightforward solution using O(mn) space is probably a bad
+idea.
+
+• A simple improvement uses O(m + n) space, but still not the best
+solution.
+
+        • Could you devise a constant space solution?
+"""
+
+
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        m, n = len(matrix), len(matrix[0])
+
+        # 1. remember if row 0 or column 0 have their own zeros
+        row0_zero = any(matrix[0][c] == 0 for c in range(n))
+        col0_zero = any(matrix[r][0] == 0 for r in range(m))
+
+        # 2. use row 0 and column 0 as marker lists
+        for r in range(1, m):
+            for c in range(1, n):
+                if matrix[r][c] == 0:
+                    matrix[r][0] = 0
+                    matrix[0][c] = 0
+
+        # 3. zero the inner cells from the markers
+        for r in range(1, m):
+            for c in range(1, n):
+                if matrix[r][0] == 0 or matrix[0][c] == 0:
+                    matrix[r][c] = 0
+
+        # 4. handle row 0 and column 0 last
+        if row0_zero:
+            for c in range(n):
+                matrix[0][c] = 0
+        if col0_zero:
+            for r in range(m):
+                matrix[r][0] = 0
@@ -0,0 +1,64 @@
+"""
+973. K Closest Points to Origin
+Difficulty: Medium
+https://leetcode.com/problems/k-closest-points-to-origin/
+
+──────────────────────────────────────────────────
+
+Given an array of points where points[i] = [xi, yi] represents a
+point on the X-Y plane and an integer k, return the k closest points
+to the origin (0, 0).
+
+The distance between two points on the X-Y plane is the Euclidean
+distance (i.e., &radic;(x1 - x2)^2 + (y1 - y2)^2).
+
+You may return the answer in any order. The answer is guaranteed to
+be unique (except for the order that it is in).
+
+
+
+Example 1:
+
+Input: points = [[1,3],[-2,2]], k = 1
+Output: [[-2,2]]
+Explanation:
+The distance between (1, 3) and the origin is sqrt(10).
+The distance between (-2, 2) and the origin is sqrt(8).
+Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin.
+We only want the closest k = 1 points from the origin, so the answer
+is just [[-2,2]].
+
+Example 2:
+
+Input: points = [[3,3],[5,-1],[-2,4]], k = 2
+Output: [[3,3],[-2,4]]
+Explanation: The answer [[-2,4],[3,3]] would also be accepted.
+
+
+
+Constraints:
+
+        • 1 <= k <= points.length <= 10^4
+
+        • -10^4 <= xi, yi <= 10^4
+"""
+
+import heapq
+
+
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        minHeap = []
+        for x, y in points:
+            dist = (x**2) + (y**2)
+            minHeap.append([dist, x, y])
+
+        heapq.heapify(minHeap)
+        res = []
+
+        while k > 0:
+            dist, x, y = heapq.heappop(minHeap)
+            res.append([x, y])
+            k -= 1
+
+        return res
@@ -0,0 +1,125 @@
+"""
+146. LRU Cache
+Difficulty: Medium
+https://leetcode.com/problems/lru-cache/
+
+──────────────────────────────────────────────────
+
+Design a data structure that follows the constraints of a Least
+Recently Used (LRU) cache.
+
+Implement the LRUCache class:
+
+• LRUCache(int capacity) Initialize the LRU cache with positive size
+capacity.
+
+• int get(int key) Return the value of the key if the key exists,
+otherwise return -1.
+
+• void put(int key, int value) Update the value of the key if the
+key exists. Otherwise, add the key-value pair to the cache. If the
+number of keys exceeds the capacity from this operation, evict the
+least recently used key.
+
+The functions get and put must each run in O(1) average time
+complexity.
+
+
+
+Example 1:
+
+Input
+["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get",
+"get"]
+[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+Output
+[null, null, null, 1, null, -1, null, -1, 3, 4]
+
+Explanation
+LRUCache lRUCache = new LRUCache(2);
+lRUCache.put(1, 1); // cache is {1=1}
+lRUCache.put(2, 2); // cache is {1=1, 2=2}
+lRUCache.get(1);    // return 1
+lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1,
+3=3}
+lRUCache.get(2);    // returns -1 (not found)
+lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4,
+3=3}
+lRUCache.get(1);    // return -1 (not found)
+lRUCache.get(3);    // return 3
+lRUCache.get(4);    // return 4
+
+
+
+Constraints:
+
+        • 1 <= capacity <= 3000
+
+        • 0 <= key <= 10^4
+
+        • 0 <= value <= 10^5
+
+        • At most 2 * 10^5 calls will be made to get and put.
+"""
+
+
+class Node:
+    def __init__(self, key=0, value=0):
+        self.key = key
+        self.value = value
+        self.prev = None
+        self.next = None
+
+
+class LRUCache:
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.cache = {}
+        self.head = Node()
+        self.tail = Node()
+        self.head.next = self.tail  # pyright: ignore[reportAttributeAccessIssue]
+        self.tail.prev = self.head  # pyright: ignore[reportAttributeAccessIssue]
+
+    def _remove_node(self, node):
+        prev_node = node.prev
+        next_node = node.next
+        prev_node.next = next_node
+        next_node.prev = prev_node
+
+    def _add_node(self, node):
+        # Insert just before the tail (most recent at end)
+        node.next = self.tail
+        node.prev = self.tail.prev
+        self.tail.prev.next = node  # pyright: ignore[reportAttributeAccessIssue]
+        self.tail.prev = node
+
+    def get(self, key: int) -> int:
+        if key not in self.cache:
+            return -1
+
+        node = self.cache[key]
+        self._remove_node(node)
+        self._add_node(node)
+        return node.value
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            node = self.cache[key]
+            node.value = value
+            self._remove_node(node)
+            self._add_node(node)
+        else:
+            new_node = Node(key, value)
+            self.cache[key] = new_node
+            self._add_node(new_node)
+
+            if len(self.cache) > self.capacity:
+                lru = self.head.next  # Oldest node is next to the head
+                self._remove_node(lru)
+                del self.cache[lru.key]  # pyright: ignore[reportAttributeAccessIssue]
+
+
+# Your LRUCache object will be instantiated and called as such:
+# obj = LRUCache(capacity)
+# param_1 = obj.get(key)
+# obj.put(key,value)
@@ -0,0 +1,103 @@
+"""
+208. Implement Trie (Prefix Tree)
+Difficulty: Medium
+https://leetcode.com/problems/implement-trie-prefix-tree/
+
+──────────────────────────────────────────────────
+
+A trie (pronounced as "try") or prefix tree is a tree data structure
+used to efficiently store and retrieve keys in a dataset of strings.
+There are various applications of this data structure, such as
+autocomplete and spellchecker.
+
+Implement the Trie class:
+
+        • Trie() Initializes the trie object.
+
+        • void insert(String word) Inserts the string word into the trie.
+
+• boolean search(String word) Returns true if the string word is in
+the trie (i.e., was inserted before), and false otherwise.
+
+• boolean startsWith(String prefix) Returns true if there is a
+previously inserted string word that has the prefix prefix, and false
+otherwise.
+
+
+
+Example 1:
+
+Input
+["Trie", "insert", "search", "search", "startsWith", "insert",
+"search"]
+[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
+Output
+[null, null, true, false, true, null, true]
+
+Explanation
+Trie trie = new Trie();
+trie.insert("apple");
+trie.search("apple");   // return True
+trie.search("app");     // return False
+trie.startsWith("app"); // return True
+trie.insert("app");
+trie.search("app");     // return True
+
+
+
+Constraints:
+
+        • 1 <= word.length, prefix.length <= 2000
+
+        • word and prefix consist only of lowercase English letters.
+
+• At most 3 * 10^4 calls in total will be made to insert, search,
+and startsWith.
+"""
+
+
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.endOfWord = False
+
+
+class Trie:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def insert(self, word: str) -> None:
+        cur = self.root
+
+        for c in word:
+            if c not in cur.children:
+                cur.children[c] = TrieNode()
+            cur = cur.children[c]
+        cur.endOfWord = True
+
+    def search(self, word: str) -> bool:
+        cur = self.root
+
+        for c in word:
+            if c not in cur.children:
+                return False
+            cur = cur.children[c]
+
+        return cur.endOfWord
+
+    def startsWith(self, prefix: str) -> bool:
+        cur = self.root
+
+        for c in prefix:
+            if c not in cur.children:
+                return False
+            cur = cur.children[c]
+
+        return True
+
+
+# Your Trie object will be instantiated and called as such:
+# obj = Trie()
+# obj.insert(word)
+# param_2 = obj.search(word)
+# param_3 = obj.startsWith(prefix)
@@ -0,0 +1,70 @@
+"""
+2. Add Two Numbers
+Difficulty: Medium
+https://leetcode.com/problems/add-two-numbers/
+
+──────────────────────────────────────────────────
+
+You are given two non-empty linked lists representing two
+non-negative integers. The digits are stored in reverse order, and
+each of their nodes contains a single digit. Add the two numbers and
+return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero,
+except the number 0 itself.
+
+
+
+Example 1:
+
+Input: l1 = [2,4,3], l2 = [5,6,4]
+Output: [7,0,8]
+Explanation: 342 + 465 = 807.
+
+Example 2:
+
+Input: l1 = [0], l2 = [0]
+Output: [0]
+
+Example 3:
+
+Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+Output: [8,9,9,9,0,0,0,1]
+
+
+
+Constraints:
+
+        • The number of nodes in each linked list is in the range [1, 100].
+
+        • 0 <= Node.val <= 9
+
+• It is guaranteed that the list represents a number that does not
+have leading zeros.
+"""
+
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def addTwoNumbers(
+        self, l1: Optional[ListNode], l2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+
+        dummy = ListNode()
+        carry = 0
+        curr = dummy
+        while l1 or l2 or carry:
+            s = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
+            carry, val = divmod(s, 10)
+
+            curr.next = ListNode(val)
+            curr = curr.next
+
+            l1 = l1.next if l1 else None
+            l2 = l2.next if l2 else None
+
+        return dummy.next
@@ -0,0 +1,101 @@
+"""
+211. Design Add and Search Words Data Structure
+Difficulty: Medium
+https://leetcode.com/problems/design-add-and-search-words-data-structure/
+
+──────────────────────────────────────────────────
+
+Design a data structure that supports adding new words and finding if
+a string matches any previously added string.
+
+Implement the WordDictionary class:
+
+        • WordDictionary() Initializes the object.
+
+• void addWord(word) Adds word to the data structure, it can be
+matched later.
+
+• bool search(word) Returns true if there is any string in the data
+structure that matches word or false otherwise. word may contain dots
+'.' where dots can be matched with any letter.
+
+
+
+Example:
+
+Input
+
+["WordDictionary","addWord","addWord","addWord","search","search","search","search"]
+[[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]
+Output
+[null,null,null,null,false,true,true,true]
+
+Explanation
+WordDictionary wordDictionary = new WordDictionary();
+wordDictionary.addWord("bad");
+wordDictionary.addWord("dad");
+wordDictionary.addWord("mad");
+wordDictionary.search("pad"); // return False
+wordDictionary.search("bad"); // return True
+wordDictionary.search(".ad"); // return True
+wordDictionary.search("b.."); // return True
+
+
+
+Constraints:
+
+        • 1 <= word.length <= 25
+
+        • word in addWord consists of lowercase English letters.
+
+        • word in search consist of '.' or lowercase English letters.
+
+        • There will be at most 2 dots in word for search queries.
+
+        • At most 10^4 calls will be made to addWord and search.
+"""
+
+
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.endOfWord = False
+
+
+class WordDictionary:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def addWord(self, word: str) -> None:
+        cur = self.root
+        for c in word:
+            if c not in cur.children:
+                cur.children[c] = TrieNode()
+            cur = cur.children[c]
+        cur.endOfWord = True
+
+    # Leverage Recursion
+    def search(self, word: str) -> bool:
+        def dfs(j, root):
+            cur = root
+            for i in range(j, len(word)):
+                c = word[i]
+
+                if c == ".":
+                    for child in cur.children.values():
+                        if dfs(i + 1, child):
+                            return True
+                    return False
+                else:
+                    if c not in cur.children:
+                        return False
+                    cur = cur.children[c]
+            return cur.endOfWord
+
+        return dfs(0, self.root)
+
+
+# Your WordDictionary object will be instantiated and called as such:
+# obj = WordDictionary()
+# obj.addWord(word)
+# param_2 = obj.search(word)
Author	SHA1	Message	Date
Prad Nukala	204e178fa4	feat(work): add solution for LeetCode 211 design add and search words data structure	2026-09-21 12:50:53 -04:00
Prad Nukala	61dc19fb29	docs(docs): add MDX page for LeetCode 211 design problem	2026-09-21 12:50:51 -04:00
Prad Nukala	5c644ca050	docs(schedule): clarify schedule JSON format, gate problem handling, and update week dates in README	2026-09-21 12:14:37 -04:00
Prad Nukala	fb2d4c88c2	feat(work): add solution for LeetCode 208 Implement Trie (Prefix Tree)	2026-09-21 12:14:33 -04:00
Prad Nukala	1fa0731ea7	docs(docs): add MDX page for LeetCode 208 Implement Trie (Prefix Tree)	2026-09-21 12:14:29 -04:00
Prad Nukala	86107d5ef7	feat(api): add structured schedule plan with topics, problems, gate, sweep and reserved problem handling	2026-09-21 12:14:25 -04:00
Prad Nukala	00f44a1c47	docs(docs): add MDX page for Merge k Sorted Lists problem	2026-09-14 12:50:08 -04:00
Prad Nukala	24312437eb	feat(work): add solution for LeetCode 23 Merge k Sorted Lists	2026-09-14 12:49:55 -04:00
Prad Nukala	4c9c8f39ae	feat(work): add solution for LeetCode 973 K Closest Points to Origin	2026-09-14 12:37:15 -04:00
Prad Nukala	88ff63f5c4	docs(docs): add MDX page for LeetCode 973 K Closest Points to Origin	2026-09-14 12:37:11 -04:00
Prad Nukala	2066856d15	feat(work): add solution for LeetCode 215 Kth Largest Element in an Array	2026-09-14 12:21:55 -04:00
Prad Nukala	393d72c9fe	docs(docs): add MDX page for LeetCode 215 Kth Largest Element in an Array	2026-09-14 12:21:51 -04:00
Prad Nukala	6c18301aa6	feat(work): add Lowest Common Ancestor of BST solution	2026-09-05 16:33:03 -04:00
Prad Nukala	02f6a20cc1	docs(docs): add documentation for 235 Lowest Common Ancestor of a Binary Search Tree	2026-09-05 16:32:59 -04:00
Prad Nukala	9288aaa152	feat(work): add Kth Smallest Element in a BST solution	2026-09-05 16:28:21 -04:00
Prad Nukala	d5ea71dbc1	docs(docs): add MDX page for “230. Kth Smallest Element in a BST”	2026-09-05 16:28:18 -04:00
Prad Nukala	3e1a66eb37	feat(work): add LeetCode solutions for 217, 271, and 98	2026-09-05 13:37:53 -04:00
Prad Nukala	9a2b80949b	docs(docs): add 271 Encode/Decode Strings and 98 Validate BST pages	2026-09-05 13:37:42 -04:00
Prad Nukala	883dc69dba	docs(docs): update index title from “Progress” to “Overview”	2026-09-04 16:49:23 -04:00
Prad Nukala	e3f0b5420a	docs(docs): replace index with live progress dashboard and delete redundant progress page	2026-09-04 16:46:50 -04:00
Prad Nukala	987eb7ab5b	feat(work): add solution for LeetCode 1448 Count Good Nodes in Binary Tree	2026-09-04 16:44:07 -04:00
Prad Nukala	e4118fccd3	docs(docs): add MDX page for LeetCode 1448 Count Good Nodes in Binary Tree problem	2026-09-04 16:44:04 -04:00
Prad Nukala	95db4ca46c	feat(work): add solution for Binary Tree Right Side View problem	2026-09-04 11:48:03 -04:00
Prad Nukala	0cc7ca607e	docs(docs): add documentation for Binary Tree Right Side View problem	2026-09-04 11:47:59 -04:00
Prad Nukala	71ec39fe34	feat(work): add solution for Binary Tree Level Order Traversal (LC 102)	2026-09-04 11:33:20 -04:00
Prad Nukala	51decd23bd	docs(docs): add documentation for Binary Tree Level Order Traversal (LeetCode 102)	2026-09-04 11:33:15 -04:00
Prad Nukala	90082518a6	feat(work): add solution for Lowest Common Ancestor of a Binary Tree	2026-09-03 14:17:54 -04:00
Prad Nukala	e10a913546	docs(docs): add 236 Lowest Common Ancestor of a Binary Tree documentation	2026-09-03 14:17:51 -04:00
Prad Nukala	fec94ed636	feat(work): add solution for Invert Binary Tree (LC 226)	2026-09-03 14:01:06 -04:00
Prad Nukala	30273d0030	docs(docs): add Invert Binary Tree documentation	2026-09-03 14:01:02 -04:00
Prad Nukala	50299defef	feat(work): add Maximum Depth of Binary Tree solution	2026-09-03 13:52:57 -04:00
Prad Nukala	c843be855e	feat(docs): add Maximum Depth of Binary Tree documentation	2026-09-03 13:52:54 -04:00
Prad Nukala	1e0e03daaa	feat(work): add Set Matrix Zeroes solution	2026-09-02 16:52:29 -04:00
Prad Nukala	7b182206dd	docs(docs): add documentation for Set Matrix Zeroes problem	2026-09-02 16:52:26 -04:00
Prad Nukala	faaaf52f85	feat(work): add Rotate Image and Spiral Matrix solutions	2026-09-02 16:49:41 -04:00
Prad Nukala	090f3d6719	docs(docs): add new problem pages for Rotate Image, Spiral Matrix, and Add Two Numbers	2026-09-02 16:49:39 -04:00
Prad Nukala	a3ae16ad96	feat(work): add Group Anagrams solution	2026-09-01 15:56:02 -04:00
Prad Nukala	9faa0b0337	feat(work): implement correct addTwoNumbers algorithm for linked list addition	2026-09-01 14:39:45 -04:00
Prad Nukala	cc29304903	docs(agents): clarify sync.ts contract description for solution section ownership	2026-09-01 14:22:01 -04:00
Prad Nukala	c50b600103	feat(work): add Add Two Numbers solution	2026-09-01 14:21:57 -04:00
Prad Nukala	a86d72c7db	docs(docs): add Approach and Explanation sections with mermaid diagrams to problem pages	2026-09-01 14:21:54 -04:00
Prad Nukala	e59d78e571	feat(cli): preserve custom sections after solution during docs sync	2026-09-01 14:21:50 -04:00
Prad Nukala	a93bb068b6	fix(work): correct node insertion and eviction order in LRUCache	2026-09-01 13:59:03 -04:00
Prad Nukala	53b2d5ec8c	docs(docs): clarify LRUCache insertion order in example MDX	2026-09-01 13:59:01 -04:00
Prad Nukala	5dda64e41e	feat(work): add LRU Cache solution	2026-09-01 13:31:34 -04:00
Prad Nukala	d798871fbc	docs(docs): add LRU Cache problem documentation	2026-09-01 13:31:31 -04:00
Prad Nukala	bb7324fe8c	docs(AGENTS): add terminal dashboard info and expand documentation for stats, work layout, and tooling preferences	2026-08-31 18:56:57 -04:00
Prad Nukala	d13859d31e	refactor(docs): rename recent stats to heat and update dashboard rendering	2026-08-31 18:56:52 -04:00
Prad Nukala	664ea534ed	feat(config): add stats script to package.json	2026-08-31 18:56:46 -04:00
Prad Nukala	b86f36daf1	feat(cli): add terminal stats dashboard and solution detection utilities	2026-08-31 18:56:42 -04:00
Prad Nukala	7bae7b2920	feat(api): add concept temperature bands and expose in stats	2026-08-31 18:56:40 -04:00
Prad Nukala	64173857e7	feat(work): add new LeetCode solution files for 1426, 1832, 344, and 15	2026-08-31 16:50:30 -04:00
Prad Nukala	002c2c9c97	feat(work): add solutions for LeetCode 1365 and 268 problems	2026-08-31 16:36:29 -04:00
Prad Nukala	fa8deac963	feat(work): add solution for LeetCode 387 First Unique Character in a String	2026-08-31 16:21:47 -04:00
Prad Nukala	ef8d2b41e1	docs(todos): add review backlog planning markdown	2026-08-31 14:57:38 -04:00