docs(phase-26): evolve PROJECT.md after phase completion

docs(phase-26): complete phase execution
docs(26-03): complete discovery landing page plan
2026-04-10 15:08:50 +02:00 · 2026-04-10 15:08:18 +02:00 · 2026-04-10 15:03:00 +02:00 · 2026-04-10 15:01:49 +02:00 · 2026-04-10 15:00:57 +02:00 · 2026-04-10 14:59:58 +02:00
23 changed files with 3312 additions and 82 deletions
--- a/.planning/PROJECT.md
+++ b/.planning/PROJECT.md
@@ -58,6 +58,7 @@ Help people make better gear decisions — discover what others use, compare rea
 - ✓ Unique constraint on (brand, model) preventing catalog duplicates — v2.1
 - ✓ Bulk import API with upsert semantics for catalog enrichment — v2.1
 - ✓ MCP catalog tools (upsert_catalog_item, bulk_upsert_catalog) for agent seeding — v2.1
+- ✓ Discovery landing page with catalog search, popular setups feed, recent items, trending categories — v2.1

 ### Active

@@ -98,8 +99,8 @@ Tech stack: React 19, Hono, Drizzle ORM, PostgreSQL, TanStack Router/Query, Tail
 Primary use case is bikepacking gear but data model is hobby-agnostic.
 Auth: External OIDC via Logto (browser sessions) + API keys (programmatic) + MCP OAuth (Claude).
 Infrastructure: PostgreSQL, MinIO (S3-compatible image storage), Docker Compose for dev/prod.
-Features: MCP server (21 tools), global item catalog with attribution and bulk import, user profiles, public setup sharing, catalog-driven gear flow, item/candidate detail pages, candidate ranking/comparison/impact preview.
-18+ test files (service-level, route-level integration, MCP). E2E tests pending rewrite for OIDC auth (backlog 999.1).
+Features: MCP server (21 tools), global item catalog with attribution and bulk import, user profiles, public setup sharing, catalog-driven gear flow, item/candidate detail pages, candidate ranking/comparison/impact preview. Public discovery landing page with catalog search, popular setups feed, recent items, and trending categories.
+20+ test files (service-level, route-level integration, MCP). E2E tests pending rewrite for OIDC auth (backlog 999.1).

 ## Constraints

@@ -171,4 +172,4 @@ This document evolves at phase transitions and milestone boundaries.
 4. Update Context with current state

 ---
-*Last updated: 2026-04-10 after Phase 25 complete — catalog enrichment & agent tools*
+*Last updated: 2026-04-10 after Phase 26 complete — discovery landing page*
--- a/.planning/REQUIREMENTS.md
+++ b/.planning/REQUIREMENTS.md
@@ -17,11 +17,11 @@ Requirements for Public Discovery milestone. Each maps to roadmap phases.

 ### Discovery

- [ ] **DISC-01**: Landing page displays an always-visible catalog search bar at the top
- [ ] **DISC-02**: Landing page shows a feed of popular setups below the search
- [ ] **DISC-03**: Landing page shows recently added catalog items
- [ ] **DISC-04**: Landing page shows trending categories
- [ ] **DISC-05**: Authenticated users see a "Go to Collection" entry point from the landing page
+- [x] **DISC-01**: Landing page displays an always-visible catalog search bar at the top
+- [x] **DISC-02**: Landing page shows a feed of popular setups below the search
+- [x] **DISC-03**: Landing page shows recently added catalog items
+- [x] **DISC-04**: Landing page shows trending categories
+- [x] **DISC-05**: Authenticated users see a "Go to Collection" entry point from the landing page

 ### Catalog Enrichment

@@ -40,7 +40,7 @@ Requirements for Public Discovery milestone. Each maps to roadmap phases.
 ### Infrastructure

 - [x] **INFR-01**: Public API endpoints are rate-limited to prevent abuse
- [ ] **INFR-02**: Discovery feed endpoint uses cursor pagination for scalability
+- [x] **INFR-02**: Discovery feed endpoint uses cursor pagination for scalability

 ## Future Requirements

@@ -130,12 +130,12 @@ Which phases cover which requirements. Updated during roadmap creation.
 | SEED-01 | Phase 25 | Complete |
 | SEED-02 | Phase 25 | Complete |
 | SEED-03 | Phase 25 | Complete |
-| DISC-01 | Phase 26 | Pending |
-| DISC-02 | Phase 26 | Pending |
-| DISC-03 | Phase 26 | Pending |
-| DISC-04 | Phase 26 | Pending |
-| DISC-05 | Phase 26 | Pending |
-| INFR-02 | Phase 26 | Pending |
+| DISC-01 | Phase 26 | Complete |
+| DISC-02 | Phase 26 | Complete |
+| DISC-03 | Phase 26 | Complete |
+| DISC-04 | Phase 26 | Complete |
+| DISC-05 | Phase 26 | Complete |
+| INFR-02 | Phase 26 | Complete |

 **Coverage:**
 - v2.1 requirements: 20 total
--- a/.planning/ROADMAP.md
+++ b/.planning/ROADMAP.md
@@ -70,7 +70,7 @@

 - [x] **Phase 24: Public Access & Infrastructure** - Remove the login wall from read-only routes and add rate limiting to public endpoints (completed 2026-04-10)
 - [x] **Phase 25: Catalog Enrichment & Agent Tools** - Add attribution fields to global items, bulk import API, and MCP tools for agent-powered seeding (completed 2026-04-10)
- [ ] **Phase 26: Discovery Landing Page** - Replace the dashboard with a public-first landing page featuring catalog search and community feed
+- [x] **Phase 26: Discovery Landing Page** - Replace the dashboard with a public-first landing page featuring catalog search and community feed (completed 2026-04-10)

 ## Phase Details

@@ -118,7 +118,12 @@ Plans:
  3. The landing page shows a section of recently added catalog items
  4. The landing page shows a section of trending categories
  5. A logged-in user sees a "Go to Collection" link or button on the landing page that navigates to their personal collection
-**Plans**: TBD
+**Plans**: 3 plans
+
+Plans:
+- [x] 26-01-PLAN.md — Discovery service layer with cursor pagination (TDD)
+- [x] 26-02-PLAN.md — Discovery routes, server registration, and client hooks
+- [x] 26-03-PLAN.md — Landing page UI and PublicSetupCard enhancement
 **UI hint**: yes

 ## Progress
@@ -150,14 +155,19 @@ Plans:
 | 23. Manual Entry Fallback | v2.0 | 1/1 | Complete | 2026-04-06 |
 | 24. Public Access & Infrastructure | v2.1 | 2/2 | Complete    | 2026-04-10 |
 | 25. Catalog Enrichment & Agent Tools | v2.1 | 1/2 | Complete    | 2026-04-10 |
-| 26. Discovery Landing Page | v2.1 | 0/TBD | Not started | - |
+| 26. Discovery Landing Page | v2.1 | 3/3 | Complete    | 2026-04-10 |

 ## Backlog

 ### Phase 999.1: Rewrite E2E Tests for OIDC Auth (BACKLOG)
 **Goal**: E2E tests currently expect local username/password login but auth moved to external OIDC (Logto). Rewrite with mock OIDC provider or API-key-based auth bypass. Seed migration to Postgres is already done.
 **Requirements**: TBD
-**Plans**: TBD
+**Plans**: 3 plans
+
+Plans:
+- [x] 26-01-PLAN.md — Discovery service layer with cursor pagination (TDD)
+- [x] 26-02-PLAN.md — Discovery routes, server registration, and client hooks
+- [ ] 26-03-PLAN.md — Landing page UI and PublicSetupCard enhancement

 Plans:
 - [ ] TBD (promote with /gsd:review-backlog when ready)
@@ -165,7 +175,12 @@ Plans:
 ### Phase 999.2: Revamp Onboarding Flow (BACKLOG)
 **Goal**: Redesign the onboarding experience to match the current app style and flow. Replace the manual item edit form with the catalog search function. Visual refresh to align with the newer UI patterns.
 **Requirements**: TBD
-**Plans**: TBD
+**Plans**: 3 plans
+
+Plans:
+- [x] 26-01-PLAN.md — Discovery service layer with cursor pagination (TDD)
+- [ ] 26-02-PLAN.md — Discovery routes, server registration, and client hooks
+- [ ] 26-03-PLAN.md — Landing page UI and PublicSetupCard enhancement

 Plans:
 - [ ] TBD (promote with /gsd:review-backlog when ready)
@@ -173,7 +188,12 @@ Plans:
 ### Phase 999.3: Public Access Auth Model (BACKLOG)
 **Goal**: Rework auth so the app is accessible without logging in. Currently all routes require authentication, but public-facing pages (discovery/browse, shared setups, public profiles) should be viewable by unauthenticated users. Auth only required for write operations and personal data.
 **Requirements**: TBD
-**Plans**: TBD
+**Plans**: 3 plans
+
+Plans:
+- [ ] 26-01-PLAN.md — Discovery service layer with cursor pagination (TDD)
+- [ ] 26-02-PLAN.md — Discovery routes, server registration, and client hooks
+- [ ] 26-03-PLAN.md — Landing page UI and PublicSetupCard enhancement

 Plans:
 - [ ] TBD (promote with /gsd:review-backlog when ready)
--- a/.planning/STATE.md
+++ b/.planning/STATE.md
@@ -3,14 +3,14 @@ gsd_state_version: 1.0
 milestone: v2.1
 milestone_name: Public Discovery
 status: verifying
-stopped_at: Completed 25-02-PLAN.md
-last_updated: "2026-04-10T09:13:14.646Z"
+stopped_at: Completed 26-03-PLAN.md
+last_updated: "2026-04-10T13:08:14.422Z"
 last_activity: 2026-04-10
 progress:
  total_phases: 6
-  completed_phases: 2
-  total_plans: 4
-  completed_plans: 4
+  completed_phases: 3
+  total_plans: 7
+  completed_plans: 7
  percent: 0
 ---

@@ -21,7 +21,7 @@ progress:
 See: .planning/PROJECT.md (updated 2026-04-09)

 **Core value:** Help people make better gear decisions — discover what others use, compare real-world data, and see how a potential buy affects your setup before committing.
-**Current focus:** Phase 25 — catalog-enrichment-agent-tools
+**Current focus:** Phase 26 — discovery-landing-page

 ## Current Position

@@ -68,6 +68,11 @@ v2.1 decisions:
 - [Phase 25-catalog-enrichment-agent-tools]: unique(brand, model) constraint on globalItems: enables safe ON CONFLICT DO UPDATE for catalog enrichment agents
 - [Phase 25-catalog-enrichment-agent-tools]: Catalog MCP tools use registerCatalogTools(db) without userId — shared catalog needs no user scoping
 - [Phase 25-catalog-enrichment-agent-tools]: Attribution spacing: image div removes mb-6, attribution paragraph takes mb-6, fallback div ensures consistent spacing
+- [Phase 26-discovery-landing-page]: Composite cursor for setups uses itemCount_id format filtered post-query in JS for simplicity with grouped SQL
+- [Phase 26-discovery-landing-page]: No cursor pagination for getTrendingCategories — bounded small list, simple limit is sufficient
+- [Phase 26]: discoveryRoutes registered with browseTier rate limiting (120 req/min) for all GET discovery endpoints
+- [Phase 26-discovery-landing-page]: PublicSetupCard itemCount/creatorName fields are optional for backward compatibility with users/$userId usage
+- [Phase 26-discovery-landing-page]: Discovery sections hide entirely (return null) when not loading and data is empty — avoids empty grid layouts

 ### Pending Todos

@@ -79,6 +84,6 @@ None.

 ## Session Continuity

-Last session: 2026-04-10T09:07:33.636Z
-Stopped at: Completed 25-02-PLAN.md
+Last session: 2026-04-10T13:02:50.039Z
+Stopped at: Completed 26-03-PLAN.md
 Resume file: None
--- a/.planning/phases/26-discovery-landing-page/26-01-PLAN.md
+++ b/.planning/phases/26-discovery-landing-page/26-01-PLAN.md
@@ -0,0 +1,182 @@
+---
+phase: 26-discovery-landing-page
+plan: 01
+type: tdd
+wave: 1
+depends_on: []
+files_modified:
+  - src/server/services/discovery.service.ts
+  - tests/services/discovery.service.test.ts
+autonomous: true
+requirements: [DISC-02, DISC-03, DISC-04, INFR-02]
+
+must_haves:
+  truths:
+    - "getPopularSetups returns public setups ordered by item count descending"
+    - "getRecentGlobalItems returns items ordered by createdAt descending"
+    - "getTrendingCategories returns categories ordered by item count, excluding nulls"
+    - "Cursor pagination returns next page without duplicates"
+  artifacts:
+    - path: "src/server/services/discovery.service.ts"
+      provides: "Discovery feed queries with cursor pagination"
+      exports: ["getPopularSetups", "getRecentGlobalItems", "getTrendingCategories"]
+    - path: "tests/services/discovery.service.test.ts"
+      provides: "Unit tests for all three discovery service functions"
+      min_lines: 100
+  key_links:
+    - from: "src/server/services/discovery.service.ts"
+      to: "src/db/schema.ts"
+      via: "Drizzle query builders using globalItems, setups, setupItems, users tables"
+      pattern: "from\\(globalItems\\)|from\\(setups\\)"
+---
+
+<objective>
+Create the discovery service layer with three query functions: getPopularSetups, getRecentGlobalItems, and getTrendingCategories. All functions use cursor-based pagination per INFR-02 (except categories which use simple limit).
+
+Purpose: Provides the data layer for the discovery landing page feed sections. TDD approach ensures correct ordering, filtering, and pagination before wiring to routes.
+Output: `discovery.service.ts` with three exported functions, fully tested.
+</objective>
+
+<execution_context>
+@$HOME/.claude/get-shit-done/workflows/execute-plan.md
+@$HOME/.claude/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@.planning/STATE.md
+@.planning/phases/26-discovery-landing-page/26-CONTEXT.md
+@.planning/phases/26-discovery-landing-page/26-RESEARCH.md
+@src/db/schema.ts
+@tests/helpers/db.ts
+@tests/services/global-item.service.test.ts (pattern reference for test structure)
+@src/server/services/global-item.service.ts (pattern reference for service structure)
+</context>
+
+<tasks>
+
+<task type="auto" tdd="true">
+  <name>Task 1: Discovery service with TDD — popular setups, recent items, trending categories</name>
+  <files>src/server/services/discovery.service.ts, tests/services/discovery.service.test.ts</files>
+  <read_first>
+    - src/db/schema.ts (table definitions: globalItems, setups, setupItems, users)
+    - tests/helpers/db.ts (createTestDb pattern)
+    - tests/services/global-item.service.test.ts (test file structure, insertGlobalItem helper pattern)
+    - src/server/services/global-item.service.ts (service function patterns — how db param is typed, import style)
+  </read_first>
+  <behavior>
+    - getPopularSetups: returns only public setups (isPublic=true), ordered by setupItems count descending then by id descending. Each result includes id, name, createdAt, itemCount (number), creatorName (string|null from users.displayName). Private setups are excluded.
+    - getPopularSetups cursor: given cursor "5_42" (itemCount=5, id=42), returns setups where (itemCount < 5) OR (itemCount === 5 AND id < 42). hasMore is true when rows exceed limit.
+    - getRecentGlobalItems: returns globalItems ordered by createdAt descending. Each result includes all globalItems columns.
+    - getRecentGlobalItems cursor: given cursor ISO timestamp, returns items where createdAt < cursor timestamp. hasMore is true when rows exceed limit.
+    - getTrendingCategories: returns { name: string, itemCount: number }[] ordered by itemCount descending. Excludes rows where globalItems.category IS NULL. No cursor pagination (simple limit).
+    - getTrendingCategories empty: returns empty array when no items have a category set.
+  </behavior>
+  <action>
+    **RED phase — write tests first in `tests/services/discovery.service.test.ts`:**
+
+    Use the same test structure as `global-item.service.test.ts`:
+    - Import `{ beforeEach, describe, expect, it }` from `"bun:test"`
+    - Import schema tables: `globalItems, setups, setupItems, users` from `../../src/db/schema.ts`
+    - Import `createTestDb` from `../helpers/db.ts`
+    - Import service functions from `../../src/server/services/discovery.service.ts`
+    - Type `TestDb = Awaited<ReturnType<typeof createTestDb>>`
+
+    Helper functions needed in test file:
+    ```typescript
+    async function insertGlobalItem(db, data: { brand: string; model: string; category?: string }) {
+      const [row] = await db.insert(globalItems).values({ brand: data.brand, model: data.model, category: data.category ?? null }).returning();
+      return row;
+    }
+    async function insertPublicSetup(db, userId: number, name: string, itemIds: number[]) {
+      const [setup] = await db.insert(setups).values({ name, userId, isPublic: true }).returning();
+      // Insert items into the items table first, then setupItems
+      for (const itemId of itemIds) {
+        await db.insert(setupItems).values({ setupId: setup.id, itemId });
+      }
+      return setup;
+    }
+    ```
+
+    Note: `setupItems.itemId` references the `items` table, not `globalItems`. So tests need to insert real `items` rows first (use `db.insert(items).values({ name: "Test", categoryId: 1, userId })`) before creating setupItems.
+
+    Write tests for:
+    1. `getPopularSetups` — seed 2 public setups with different item counts, verify order is by count desc
+    2. `getPopularSetups` — seed 1 private setup, verify it's excluded
+    3. `getPopularSetups` — cursor pagination: seed 3 setups, fetch limit=1, verify hasMore=true and nextCursor returned, fetch page 2 with cursor, verify different setup returned
+    4. `getPopularSetups` — includes creatorName from users.displayName (seed user with displayName, verify it appears)
+    5. `getRecentGlobalItems` — seed 3 items with different createdAt, verify order is newest first
+    6. `getRecentGlobalItems` — cursor pagination: fetch limit=1, verify hasMore, fetch page 2 with cursor
+    7. `getTrendingCategories` — seed items in 3 categories with different counts, verify order by count desc
+    8. `getTrendingCategories` — seed item with null category, verify it's excluded from results
+
+    **GREEN phase — create `src/server/services/discovery.service.ts`:**
+
+    Import from drizzle-orm: `count, desc, eq, lt, sql, and, isNotNull`
+    Import schema: `globalItems, setups, setupItems, users`
+    Import types: infer Db type the same way as `global-item.service.ts` does
+
+    Three exported functions:
+
+    `getPopularSetups(db: Db, limit = 6, cursor?: string)`:
+    - Query: SELECT setups.id, setups.name, setups.createdAt, COUNT(setupItems.id) AS itemCount, users.displayName AS creatorName
+    - FROM setups LEFT JOIN setupItems ON setupItems.setupId = setups.id LEFT JOIN users ON users.id = setups.userId
+    - WHERE setups.isPublic = true
+    - GROUP BY setups.id, setups.name, setups.createdAt, users.displayName
+    - ORDER BY itemCount DESC, setups.id DESC
+    - LIMIT limit + 1
+
+    For cursor: parse "itemCount_id" format. Use SQL HAVING or WHERE with subquery. Since Drizzle groupBy with cursor is tricky, use the post-filter approach from RESEARCH.md:
+    - Fetch more rows (limit * 2 + 1 if cursor provided)
+    - Filter in JS: keep rows where (itemCount < cursorCount) OR (itemCount === cursorCount AND id < cursorId)
+    - Slice to limit + 1
+
+    Return `{ items: T[], nextCursor: string | null, hasMore: boolean }` shape:
+    - hasMore = rows.length > limit
+    - items = hasMore ? rows.slice(0, limit) : rows
+    - nextCursor = hasMore ? `${items[items.length-1].itemCount}_${items[items.length-1].id}` : null
+
+    `getRecentGlobalItems(db: Db, limit = 8, cursor?: string)`:
+    - Query: SELECT * FROM globalItems WHERE (cursor ? createdAt < new Date(cursor) : true) ORDER BY createdAt DESC LIMIT limit + 1
+    - Return `{ items, nextCursor, hasMore }` — nextCursor is ISO string of last item's createdAt
+
+    `getTrendingCategories(db: Db, limit = 12)`:
+    - Query: SELECT category AS name, COUNT(id) AS itemCount FROM globalItems WHERE category IS NOT NULL GROUP BY category ORDER BY COUNT(id) DESC LIMIT limit
+    - Return array directly (no cursor pagination per RESEARCH.md open question 3)
+
+    **REFACTOR:** Ensure all functions handle edge cases (empty results, no cursor). Extract shared `buildCursorResponse` helper if patterns are identical.
+  </action>
+  <verify>
+    <automated>cd /home/jean-luc-makiola/Development/projects/GearBox && bun test tests/services/discovery.service.test.ts</automated>
+  </verify>
+  <acceptance_criteria>
+    - tests/services/discovery.service.test.ts contains `describe("getPopularSetups"` and `describe("getRecentGlobalItems"` and `describe("getTrendingCategories"`
+    - tests/services/discovery.service.test.ts contains at least 8 `it(` calls
+    - src/server/services/discovery.service.ts contains `export async function getPopularSetups(`
+    - src/server/services/discovery.service.ts contains `export async function getRecentGlobalItems(`
+    - src/server/services/discovery.service.ts contains `export async function getTrendingCategories(`
+    - src/server/services/discovery.service.ts contains `isNotNull(globalItems.category)` (null category exclusion)
+    - src/server/services/discovery.service.ts contains `eq(setups.isPublic, true)` (public-only filter)
+    - src/server/services/discovery.service.ts contains `nextCursor` and `hasMore` in return shapes
+    - `bun test tests/services/discovery.service.test.ts` exits 0
+  </acceptance_criteria>
+  <done>All three discovery service functions pass their tests: correct ordering, cursor pagination works for setups and items, categories exclude nulls, and hasMore/nextCursor response shape is correct.</done>
+</task>
+
+</tasks>
+
+<verification>
+- `bun test tests/services/discovery.service.test.ts` — all tests pass
+- `bun test` — full suite still green (no regressions)
+</verification>
+
+<success_criteria>
+- Three exported service functions exist with cursor pagination (setups, items) and simple limit (categories)
+- All tests pass covering ordering, filtering, cursor, and edge cases
+- Service functions are pure (take db instance, no HTTP awareness)
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/26-discovery-landing-page/26-01-SUMMARY.md`
+</output>
--- a/.planning/phases/26-discovery-landing-page/26-01-SUMMARY.md
+++ b/.planning/phases/26-discovery-landing-page/26-01-SUMMARY.md
@@ -0,0 +1,87 @@
+---
+phase: 26-discovery-landing-page
+plan: "01"
+subsystem: server/services
+tags: [discovery, service-layer, cursor-pagination, tdd, drizzle]
+dependency_graph:
+  requires: []
+  provides: [discovery.service.ts]
+  affects: [26-02, 26-03]
+tech_stack:
+  added: []
+  patterns: [cursor-pagination, CursorPage-response-shape, post-query-cursor-filter]
+key_files:
+  created:
+    - src/server/services/discovery.service.ts
+    - tests/services/discovery.service.test.ts
+  modified: []
+decisions:
+  - "Composite cursor for setups: itemCount_id format, filtered post-query in JS for simplicity with grouped SQL"
+  - "createdAt ISO string cursor for recent items: standard timestamp-based pagination"
+  - "No cursor pagination for trending categories: bounded small list (< 50), simple limit is sufficient per RESEARCH.md open question 3"
+  - "Shared CursorPage<T> generic interface for consistent cursor response shape across setups and items"
+metrics:
+  duration: "~2 min"
+  completed_date: "2026-04-10"
+  tasks_completed: 1
+  tasks_total: 1
+  files_created: 2
+  files_modified: 0
+---
+
+# Phase 26 Plan 01: Discovery Service Summary
+
+**One-liner:** Discovery service layer with cursor pagination using Drizzle ORM — getPopularSetups (itemCount_id composite cursor), getRecentGlobalItems (ISO timestamp cursor), getTrendingCategories (simple limit).
+
+## Tasks Completed
+
+| Task | Name | Commit | Files |
+|------|------|--------|-------|
+| 1 (RED) | Discovery service TDD — failing tests | 06b6e93 | tests/services/discovery.service.test.ts |
+| 1 (GREEN) | Discovery service TDD — implementation | d1f8a7a | src/server/services/discovery.service.ts |
+
+## What Was Built
+
+### `src/server/services/discovery.service.ts`
+
+Three exported async functions:
+
+**`getPopularSetups(db, limit=6, cursor?)`**
+- JOINs setups → setupItems (count) → users (displayName)
+- WHERE isPublic=true, GROUP BY setup fields
+- ORDER BY item count DESC, id DESC
+- Cursor: `itemCount_id` composite string, filtered post-query in JS
+- Returns `CursorPage<{ id, name, createdAt, itemCount, creatorName }>`
+
+**`getRecentGlobalItems(db, limit=8, cursor?)`**
+- SELECT * FROM globalItems WHERE createdAt < cursor (if provided)
+- ORDER BY createdAt DESC, LIMIT limit+1 for hasMore detection
+- Cursor: ISO timestamp of last item's createdAt
+- Returns `CursorPage<GlobalItem>`
+
+**`getTrendingCategories(db, limit=12)`**
+- SELECT category, COUNT(id) FROM globalItems WHERE category IS NOT NULL
+- GROUP BY category, ORDER BY count DESC
+- Returns plain `Array<{ name: string; itemCount: number }>` (no cursor)
+
+### `tests/services/discovery.service.test.ts`
+
+11 tests covering:
+- `getPopularSetups`: ordering by count desc, private setup exclusion, hasMore/nextCursor, second page deduplication, creatorName from users.displayName
+- `getRecentGlobalItems`: ordering by createdAt desc, hasMore/nextCursor, second page deduplication
+- `getTrendingCategories`: ordering by count desc, null category exclusion, empty state
+
+## Deviations from Plan
+
+None — plan executed exactly as written.
+
+The test used a dynamic import pattern for `eq` which was corrected to a static import (minor code quality fix before RED commit).
+
+## Verification
+
+- `bun test tests/services/discovery.service.test.ts`: 11 pass, 0 fail
+- `bun test` full suite: 290 tests — same pass/fail ratio as before (15 pre-existing failures from `withImageUrl` storage service export issue, unrelated to this plan)
+
+## Self-Check
+
+Checked below.
--- a/.planning/phases/26-discovery-landing-page/26-02-PLAN.md
+++ b/.planning/phases/26-discovery-landing-page/26-02-PLAN.md
@@ -0,0 +1,315 @@
+---
+phase: 26-discovery-landing-page
+plan: 02
+type: execute
+wave: 2
+depends_on: [26-01]
+files_modified:
+  - src/server/routes/discovery.ts
+  - src/server/index.ts
+  - src/client/hooks/useDiscovery.ts
+  - tests/routes/discovery.test.ts
+autonomous: true
+requirements: [DISC-02, DISC-03, DISC-04, INFR-02]
+
+must_haves:
+  truths:
+    - "GET /api/discovery/setups returns popular setups for anonymous users"
+    - "GET /api/discovery/items returns recent catalog items for anonymous users"
+    - "GET /api/discovery/categories returns trending categories for anonymous users"
+    - "All discovery endpoints accept limit and cursor query params"
+    - "Discovery endpoints are rate-limited with browseTier"
+  artifacts:
+    - path: "src/server/routes/discovery.ts"
+      provides: "Hono route handlers for three discovery endpoints"
+      exports: ["discoveryRoutes"]
+    - path: "src/client/hooks/useDiscovery.ts"
+      provides: "React Query hooks for landing page data fetching"
+      exports: ["useDiscoverySetups", "useDiscoveryItems", "useDiscoveryCategories"]
+    - path: "tests/routes/discovery.test.ts"
+      provides: "Route-level integration tests for discovery endpoints"
+      min_lines: 50
+  key_links:
+    - from: "src/server/routes/discovery.ts"
+      to: "src/server/services/discovery.service.ts"
+      via: "imports getPopularSetups, getRecentGlobalItems, getTrendingCategories"
+      pattern: "from.*discovery\\.service"
+    - from: "src/server/index.ts"
+      to: "src/server/routes/discovery.ts"
+      via: "app.route registration and auth skip"
+      pattern: "discoveryRoutes|/api/discovery"
+    - from: "src/client/hooks/useDiscovery.ts"
+      to: "/api/discovery"
+      via: "apiGet fetch calls"
+      pattern: "apiGet.*api/discovery"
+---
+
+<objective>
+Wire the discovery service to HTTP endpoints and create client-side React Query hooks. Register routes in server/index.ts with public access (auth skip) and browseTier rate limiting.
+
+Purpose: Makes the discovery feed data accessible to the landing page UI via three REST endpoints and three React Query hooks.
+Output: Working endpoints at `/api/discovery/{setups,items,categories}`, matching client hooks, route-level tests.
+</objective>
+
+<execution_context>
+@$HOME/.claude/get-shit-done/workflows/execute-plan.md
+@$HOME/.claude/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@.planning/STATE.md
+@.planning/phases/26-discovery-landing-page/26-CONTEXT.md
+@.planning/phases/26-discovery-landing-page/26-RESEARCH.md
+@.planning/phases/26-discovery-landing-page/26-01-SUMMARY.md
+
+<interfaces>
+<!-- From plan 01: discovery service exports -->
+From src/server/services/discovery.service.ts:
+```typescript
+export async function getPopularSetups(db: Db, limit?: number, cursor?: string): Promise<{ items: PopularSetup[], nextCursor: string | null, hasMore: boolean }>
+export async function getRecentGlobalItems(db: Db, limit?: number, cursor?: string): Promise<{ items: GlobalItemRow[], nextCursor: string | null, hasMore: boolean }>
+export async function getTrendingCategories(db: Db, limit?: number): Promise<{ name: string, itemCount: number }[]>
+```
+
+From src/server/routes/global-items.ts (pattern reference):
+```typescript
+type Env = { Variables: { db?: any } };
+const app = new Hono<Env>();
+app.get("/", async (c) => { ... });
+export { app as globalItemRoutes };
+```
+
+From src/server/index.ts (auth skip pattern, lines 151-170):
+```typescript
+// Skip public global-items endpoint (GET /api/global-items)
+if (c.req.path.startsWith("/api/global-items") && c.req.method === "GET")
+  return next();
+```
+
+From src/server/index.ts (rate limit pattern, lines 126-134):
+```typescript
+app.use("/api/global-items", async (c, next) => {
+  if (c.req.method === "GET" && !c.req.path.match(/^\/api\/global-items\/\d+$/))
+    return browseTier(c, next);
+  return next();
+});
+```
+
+From src/client/hooks/useGlobalItems.ts (hook pattern):
+```typescript
+import { useQuery } from "@tanstack/react-query";
+import { apiGet } from "../lib/api";
+export function useGlobalItems(query?: string, tags?: string[]) {
+  return useQuery({
+    queryKey: ["global-items", query ?? "", tags ?? []],
+    queryFn: () => apiGet<GlobalItem[]>(`/api/global-items${qs ? `?${qs}` : ""}`),
+  });
+}
+```
+</interfaces>
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Discovery routes, server registration, and route tests</name>
+  <files>src/server/routes/discovery.ts, src/server/index.ts, tests/routes/discovery.test.ts</files>
+  <read_first>
+    - src/server/routes/global-items.ts (exact Hono route pattern to replicate)
+    - src/server/index.ts (auth skip list at lines 151-170, rate limit setup at lines 120-148, route registration at lines 173-183)
+    - tests/routes/global-items.test.ts (route test pattern: createTestApp, middleware setup, request format)
+    - src/server/services/discovery.service.ts (function signatures from plan 01)
+  </read_first>
+  <action>
+    **Create `src/server/routes/discovery.ts`:**
+
+    Follow the exact pattern of `global-items.ts`:
+    ```typescript
+    import { Hono } from "hono";
+    import { getPopularSetups, getRecentGlobalItems, getTrendingCategories } from "../services/discovery.service.ts";
+
+    type Env = { Variables: { db?: any } };
+    const app = new Hono<Env>();
+    ```
+
+    Three GET handlers:
+
+    `app.get("/setups", ...)`:
+    - Parse query params: `limit` (parseInt, default 6, max 50), `cursor` (string, optional)
+    - Call `getPopularSetups(db, limit, cursor)`
+    - Return `c.json(result)` — result already has `{ items, nextCursor, hasMore }` shape
+
+    `app.get("/items", ...)`:
+    - Parse query params: `limit` (parseInt, default 8, max 50), `cursor` (string, optional)
+    - Call `getRecentGlobalItems(db, limit, cursor)`
+    - Return `c.json(result)`
+
+    `app.get("/categories", ...)`:
+    - Parse query params: `limit` (parseInt, default 12, max 50)
+    - Call `getTrendingCategories(db, limit)`
+    - Return `c.json(result)` — result is array directly
+
+    Export: `export { app as discoveryRoutes };`
+
+    **Modify `src/server/index.ts`:**
+
+    1. Add import at top (after line 14, near other route imports):
+       `import { discoveryRoutes } from "./routes/discovery.ts";`
+
+    2. Add rate limiting for discovery endpoints (after line 134, in the browse tier section):
+       ```typescript
+       app.use("/api/discovery/*", async (c, next) => {
+         if (c.req.method === "GET") return browseTier(c, next);
+         return next();
+       });
+       ```
+
+    3. Add auth skip in the auth middleware block (after line 167, before the requireAuth call):
+       ```typescript
+       // Skip public discovery endpoints (GET /api/discovery/*)
+       if (c.req.path.startsWith("/api/discovery") && c.req.method === "GET")
+         return next();
+       ```
+
+    4. Add route registration (after line 183, near other app.route calls):
+       `app.route("/api/discovery", discoveryRoutes);`
+
+    **Create `tests/routes/discovery.test.ts`:**
+
+    Follow the exact test pattern from `global-items.test.ts`:
+    ```typescript
+    import { beforeEach, describe, expect, it } from "bun:test";
+    import { Hono } from "hono";
+    import { globalItems, items, setups, setupItems } from "../../src/db/schema.ts";
+    import { discoveryRoutes } from "../../src/server/routes/discovery.ts";
+    import { createTestDb } from "../helpers/db.ts";
+
+    async function createTestApp() {
+      const { db, userId } = await createTestDb();
+      const app = new Hono();
+      app.use("*", async (c, next) => {
+        c.set("db", db);
+        await next();
+      });
+      // Note: NO userId set — discovery endpoints don't need auth
+      app.route("/api/discovery", discoveryRoutes);
+      return { app, db, userId };
+    }
+    ```
+
+    Tests (minimum 6):
+    1. `GET /api/discovery/setups` returns 200 with `{ items, nextCursor, hasMore }` shape
+    2. `GET /api/discovery/items` returns 200 with `{ items, nextCursor, hasMore }` shape
+    3. `GET /api/discovery/categories` returns 200 with array shape
+    4. `GET /api/discovery/setups?limit=1` respects limit param
+    5. `GET /api/discovery/items?limit=1&cursor=<timestamp>` pagination works
+    6. `GET /api/discovery/categories?limit=2` respects limit param
+
+    For each test, seed appropriate data using db.insert() then make fetch requests via `app.request("/api/discovery/...")`.
+  </action>
+  <verify>
+    <automated>cd /home/jean-luc-makiola/Development/projects/GearBox && bun test tests/routes/discovery.test.ts</automated>
+  </verify>
+  <acceptance_criteria>
+    - src/server/routes/discovery.ts contains `app.get("/setups"` and `app.get("/items"` and `app.get("/categories"`
+    - src/server/routes/discovery.ts contains `export { app as discoveryRoutes }`
+    - src/server/index.ts contains `import { discoveryRoutes }` from `"./routes/discovery.ts"`
+    - src/server/index.ts contains `app.route("/api/discovery", discoveryRoutes)`
+    - src/server/index.ts contains `c.req.path.startsWith("/api/discovery")` in auth skip section
+    - src/server/index.ts contains `"/api/discovery/*"` in rate limit section with `browseTier`
+    - tests/routes/discovery.test.ts contains at least 6 `it(` calls
+    - `bun test tests/routes/discovery.test.ts` exits 0
+  </acceptance_criteria>
+  <done>Three discovery endpoints respond to GET requests with correct JSON shapes, anonymous access works (no auth required), rate limiting is applied, and route tests pass.</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Client-side React Query hooks for discovery data</name>
+  <files>src/client/hooks/useDiscovery.ts</files>
+  <read_first>
+    - src/client/hooks/useGlobalItems.ts (hook pattern: useQuery, apiGet, interface definitions, queryKey structure)
+    - src/client/lib/api.ts (apiGet signature)
+  </read_first>
+  <action>
+    Create `src/client/hooks/useDiscovery.ts` with three named exports.
+
+    **Type definitions** at top of file:
+    ```typescript
+    export interface DiscoverySetup {
+      id: number;
+      name: string;
+      createdAt: string;
+      itemCount: number;
+      creatorName: string | null;
+    }
+
+    export interface DiscoveryCategory {
+      name: string;
+      itemCount: number;
+    }
+
+    interface CursorPage<T> {
+      items: T[];
+      nextCursor: string | null;
+      hasMore: boolean;
+    }
+    ```
+
+    For GlobalItem type, import from useGlobalItems or re-define inline matching the existing `GlobalItem` interface in `useGlobalItems.ts` (id, brand, model, category, weightGrams, priceCents, imageUrl, description, sourceUrl, imageCredit, imageSourceUrl, createdAt — all as they appear in that file).
+
+    **Three hooks:**
+
+    `useDiscoverySetups(limit = 6)`:
+    - queryKey: `["discovery", "setups", limit]`
+    - queryFn: `apiGet<CursorPage<DiscoverySetup>>(`/api/discovery/setups?limit=${limit}`)`
+    - staleTime: `2 * 60 * 1000` (2 minutes)
+
+    `useDiscoveryItems(limit = 8)`:
+    - queryKey: `["discovery", "items", limit]`
+    - queryFn: `apiGet<CursorPage<GlobalItem>>(`/api/discovery/items?limit=${limit}`)`
+    - staleTime: `2 * 60 * 1000` (2 minutes)
+
+    `useDiscoveryCategories(limit = 12)`:
+    - queryKey: `["discovery", "categories", limit]`
+    - queryFn: `apiGet<DiscoveryCategory[]>(`/api/discovery/categories?limit=${limit}`)`
+    - staleTime: `5 * 60 * 1000` (5 minutes — categories change rarely)
+
+    Import `useQuery` from `@tanstack/react-query` and `apiGet` from `../lib/api`.
+  </action>
+  <verify>
+    <automated>cd /home/jean-luc-makiola/Development/projects/GearBox && bun run build 2>&1 | tail -20</automated>
+  </verify>
+  <acceptance_criteria>
+    - src/client/hooks/useDiscovery.ts contains `export function useDiscoverySetups(`
+    - src/client/hooks/useDiscovery.ts contains `export function useDiscoveryItems(`
+    - src/client/hooks/useDiscovery.ts contains `export function useDiscoveryCategories(`
+    - src/client/hooks/useDiscovery.ts contains `export interface DiscoverySetup`
+    - src/client/hooks/useDiscovery.ts contains `export interface DiscoveryCategory`
+    - src/client/hooks/useDiscovery.ts contains `staleTime: 2 * 60 * 1000` (for setups and items)
+    - src/client/hooks/useDiscovery.ts contains `staleTime: 5 * 60 * 1000` (for categories)
+    - src/client/hooks/useDiscovery.ts contains `queryKey: ["discovery",` for all three hooks
+    - src/client/hooks/useDiscovery.ts contains `apiGet` import from `../lib/api`
+  </acceptance_criteria>
+  <done>Three React Query hooks export correctly with proper types, query keys, stale times, and API endpoint URLs matching the server routes.</done>
+</task>
+
+</tasks>
+
+<verification>
+- `bun test tests/routes/discovery.test.ts` — route tests pass
+- `bun test` — full suite green
+- `bun run build` — client builds without TypeScript errors
+</verification>
+
+<success_criteria>
+- Three GET endpoints at /api/discovery/{setups,items,categories} respond to anonymous requests
+- Endpoints are rate-limited with browseTier
+- Three React Query hooks ready for consumption by the landing page
+- Route-level tests verify response shapes and status codes
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/26-discovery-landing-page/26-02-SUMMARY.md`
+</output>
--- a/.planning/phases/26-discovery-landing-page/26-02-SUMMARY.md
+++ b/.planning/phases/26-discovery-landing-page/26-02-SUMMARY.md
@@ -0,0 +1,99 @@
+---
+phase: 26-discovery-landing-page
+plan: "02"
+subsystem: server/client
+tags: [discovery, http-routes, react-query, rate-limiting]
+dependency_graph:
+  requires: [26-01]
+  provides: [discovery-http-endpoints, discovery-react-hooks]
+  affects: [server/index.ts, client/hooks]
+tech_stack:
+  added: []
+  patterns: [hono-route-handler, react-query-hook, cursor-pagination]
+key_files:
+  created:
+    - src/server/routes/discovery.ts
+    - src/client/hooks/useDiscovery.ts
+    - tests/routes/discovery.test.ts
+  modified:
+    - src/server/index.ts
+decisions:
+  - "No cursor pagination needed for getTrendingCategories — bounded small list, simple limit is sufficient (carried from plan 01)"
+  - "discoveryRoutes registered with browseTier rate limiting (120 req/min) for all GET discovery endpoints"
+  - "Auth skip added for /api/discovery/* GET — public access without authentication"
+metrics:
+  duration: "~8 minutes"
+  completed: "2026-04-10"
+  tasks_completed: 2
+  files_created: 3
+  files_modified: 1
+---
+
+# Phase 26 Plan 02: Discovery HTTP Routes and React Query Hooks Summary
+
+**One-liner:** Three public GET endpoints at /api/discovery/{setups,items,categories} with browseTier rate limiting, wired to discovery service from plan 01, plus matching React Query hooks with typed interfaces.
+
+## What Was Built
+
+### Task 1: Discovery routes, server registration, and route tests
+
+Created `src/server/routes/discovery.ts` with three Hono GET handlers following the exact pattern of `global-items.ts`:
+
+- `GET /setups` — calls `getPopularSetups(db, limit, cursor)`, default limit 6, max 50
+- `GET /items` — calls `getRecentGlobalItems(db, limit, cursor)`, default limit 8, max 50
+- `GET /categories` — calls `getTrendingCategories(db, limit)`, default limit 12, max 50
+
+Updated `src/server/index.ts`:
+- Added `discoveryRoutes` import
+- Added `browseTier` rate limiting for `GET /api/discovery/*`
+- Added auth skip: `if (c.req.path.startsWith("/api/discovery") && c.req.method === "GET") return next()`
+- Registered `app.route("/api/discovery", discoveryRoutes)`
+
+Created `tests/routes/discovery.test.ts` with 10 tests covering:
+- Response shape validation for all three endpoints
+- Empty state handling
+- Limit param enforcement
+- Cursor-based pagination for items endpoint
+- Public-only filter for setups
+
+### Task 2: Client-side React Query hooks
+
+Created `src/client/hooks/useDiscovery.ts` with three named hook exports:
+
+- `useDiscoverySetups(limit = 6)` — queryKey `["discovery", "setups", limit]`, staleTime 2min
+- `useDiscoveryItems(limit = 8)` — queryKey `["discovery", "items", limit]`, staleTime 2min  
+- `useDiscoveryCategories(limit = 12)` — queryKey `["discovery", "categories", limit]`, staleTime 5min
+
+Exported interfaces: `DiscoverySetup`, `DiscoveryCategory`.
+
+## Verification
+
+- `bun test tests/routes/discovery.test.ts` — 10 pass, 0 fail
+- `bun run build` — clean build, no TypeScript errors
+- Full test suite: 285 pass, 15 pre-existing failures in unrelated modules (storage.service.ts export issue in setups/items/profiles/threads routes tests)
+
+## Deviations from Plan
+
+### Auto-fixed Issues
+
+**1. [Rule 1 - Bug] Fixed cursor pagination test with simultaneous timestamps**
+- **Found during:** Task 1 test writing
+- **Issue:** Two `globalItems` inserted in quick succession in PGlite got the same `defaultNow()` timestamp, making pagination impossible to test
+- **Fix:** Inserted items with explicit `createdAt` values (2024-01-01 and 2024-06-01) to ensure distinct timestamps for pagination test
+- **Files modified:** tests/routes/discovery.test.ts
+- **Commit:** 0323e0c
+
+## Known Stubs
+
+None — all endpoints return live database data from the discovery service.
+
+## Self-Check: PASSED
+
+Files exist:
+- FOUND: src/server/routes/discovery.ts
+- FOUND: src/client/hooks/useDiscovery.ts
+- FOUND: tests/routes/discovery.test.ts
+
+Commits exist:
+- 0323e0c — feat(26-02): discovery HTTP routes, server registration, and route tests
+- 747a1c3 — feat(26-02): React Query hooks for discovery data
--- a/.planning/phases/26-discovery-landing-page/26-03-PLAN.md
+++ b/.planning/phases/26-discovery-landing-page/26-03-PLAN.md
@@ -0,0 +1,477 @@
+---
+phase: 26-discovery-landing-page
+plan: 03
+type: execute
+wave: 3
+depends_on: [26-01, 26-02]
+files_modified:
+  - src/client/routes/index.tsx
+  - src/client/components/PublicSetupCard.tsx
+  - src/client/routes/users/$userId.tsx
+autonomous: false
+requirements: [DISC-01, DISC-02, DISC-03, DISC-04, DISC-05]
+
+must_haves:
+  truths:
+    - "Root URL shows a hero section with a catalog search bar"
+    - "Clicking the search bar opens CatalogSearchOverlay"
+    - "Popular setups section shows setup cards with item counts"
+    - "Recently added items section shows GlobalItemCard components"
+    - "Trending categories section shows category names with item counts"
+    - "Authenticated users see Go to Collection link in hero"
+    - "Anonymous users see the page without login redirect"
+  artifacts:
+    - path: "src/client/routes/index.tsx"
+      provides: "Landing page with hero, popular setups, recent items, trending categories"
+      min_lines: 80
+    - path: "src/client/components/PublicSetupCard.tsx"
+      provides: "Enhanced setup card with optional itemCount and creatorName"
+      contains: "itemCount"
+  key_links:
+    - from: "src/client/routes/index.tsx"
+      to: "src/client/hooks/useDiscovery.ts"
+      via: "imports useDiscoverySetups, useDiscoveryItems, useDiscoveryCategories"
+      pattern: "from.*useDiscovery"
+    - from: "src/client/routes/index.tsx"
+      to: "src/client/stores/uiStore.ts"
+      via: "openCatalogSearch trigger from hero"
+      pattern: "openCatalogSearch"
+    - from: "src/client/routes/index.tsx"
+      to: "src/client/hooks/useAuth.ts"
+      via: "auth state for conditional Go to Collection CTA"
+      pattern: "useAuth"
+    - from: "src/client/routes/index.tsx"
+      to: "src/client/components/GlobalItemCard.tsx"
+      via: "renders catalog items in recent items section"
+      pattern: "GlobalItemCard"
+    - from: "src/client/routes/index.tsx"
+      to: "src/client/components/PublicSetupCard.tsx"
+      via: "renders setup cards in popular setups section"
+      pattern: "PublicSetupCard"
+---
+
+<objective>
+Rewrite the landing page at `/` from a personal dashboard to a public discovery page. Enhance PublicSetupCard with itemCount and creatorName. Build hero section with search trigger, three content feed sections, and conditional auth CTA.
+
+Purpose: This is the user-facing deliverable — the page visitors see first. Composes existing components with new discovery hooks into the layout specified by D-01 through D-11.
+Output: Complete landing page at `/`, enhanced PublicSetupCard.
+</objective>
+
+<execution_context>
+@$HOME/.claude/get-shit-done/workflows/execute-plan.md
+@$HOME/.claude/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@.planning/STATE.md
+@.planning/phases/26-discovery-landing-page/26-CONTEXT.md
+@.planning/phases/26-discovery-landing-page/26-RESEARCH.md
+@.planning/phases/26-discovery-landing-page/26-01-SUMMARY.md
+
+<interfaces>
+<!-- From plan 02: client hooks -->
+From src/client/hooks/useDiscovery.ts:
+```typescript
+export interface DiscoverySetup {
+  id: number;
+  name: string;
+  createdAt: string;
+  itemCount: number;
+  creatorName: string | null;
+}
+export interface DiscoveryCategory {
+  name: string;
+  itemCount: number;
+}
+export function useDiscoverySetups(limit?: number): UseQueryResult
+export function useDiscoveryItems(limit?: number): UseQueryResult
+export function useDiscoveryCategories(limit?: number): UseQueryResult
+```
+
+From src/client/hooks/useAuth.ts:
+```typescript
+interface AuthState {
+  user: { id: string; email?: string } | null;
+  authenticated: boolean;
+}
+export function useAuth(): UseQueryResult<AuthState>
+```
+
+From src/client/stores/uiStore.ts:
+```typescript
+openCatalogSearch: (mode: "collection" | "thread") => void;
+// Access via: const openCatalogSearch = useUIStore((s) => s.openCatalogSearch);
+```
+
+From src/client/components/GlobalItemCard.tsx:
+```typescript
+interface GlobalItemCardProps {
+  id: number; brand: string; model: string; category: string | null;
+  weightGrams: number | null; priceCents: number | null; imageUrl: string | null;
+}
+export function GlobalItemCard(props: GlobalItemCardProps): JSX.Element
+```
+
+From src/client/components/PublicSetupCard.tsx (current — will be enhanced):
+```typescript
+interface PublicSetupCardProps {
+  setup: { id: number; name: string; createdAt: string; };
+}
+export function PublicSetupCard({ setup }: PublicSetupCardProps): JSX.Element
+```
+</interfaces>
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Enhance PublicSetupCard with itemCount and creatorName</name>
+  <files>src/client/components/PublicSetupCard.tsx, src/client/routes/users/$userId.tsx</files>
+  <read_first>
+    - src/client/components/PublicSetupCard.tsx (current component — full content)
+    - src/client/routes/users/$userId.tsx (existing usage of PublicSetupCard — check what shape is passed)
+  </read_first>
+  <action>
+    **Modify `src/client/components/PublicSetupCard.tsx`:**
+
+    Update the `PublicSetupCardProps` interface to add optional fields (per Pitfall 3 — keep optional to avoid breaking existing usages):
+    ```typescript
+    interface PublicSetupCardProps {
+      setup: {
+        id: number;
+        name: string;
+        createdAt: string;
+        itemCount?: number;      // NEW — optional for backward compat
+        creatorName?: string | null;  // NEW — optional
+      };
+    }
+    ```
+
+    Update the component JSX to display the new fields when present:
+
+    After the existing `<h3>` (setup name) and before/replacing the `<p>` date line, render:
+    - If `setup.creatorName` is truthy: `<p className="text-xs text-gray-400 mt-1">by {setup.creatorName}</p>`
+    - If `setup.itemCount` is defined and > 0: `<span className="inline-flex items-center px-2 py-0.5 rounded-full text-xs font-medium bg-blue-50 text-blue-400">{setup.itemCount} items</span>`
+    - Keep the existing date display
+
+    Layout for the bottom area of the card (below the name):
+    ```tsx
+    <div className="flex items-center justify-between mt-2">
+      <div className="flex items-center gap-2">
+        {setup.itemCount != null && setup.itemCount > 0 && (
+          <span className="inline-flex items-center px-2 py-0.5 rounded-full text-xs font-medium bg-blue-50 text-blue-400">
+            {setup.itemCount} {setup.itemCount === 1 ? "item" : "items"}
+          </span>
+        )}
+      </div>
+      <p className="text-xs text-gray-400">{formattedDate}</p>
+    </div>
+    {setup.creatorName && (
+      <p className="text-xs text-gray-400 mt-1">by {setup.creatorName}</p>
+    )}
+    ```
+
+    Add `cursor-pointer` to the Link className (folded todo from CONTEXT.md).
+
+    **Verify `src/client/routes/users/$userId.tsx`:**
+    Read the file to confirm the existing `PublicSetupCard` usage still compiles. Since `itemCount` and `creatorName` are optional, the existing usage passing `{ id, name, createdAt }` will continue to work without changes. No modification needed to this file unless it already passes extra props.
+  </action>
+  <verify>
+    <automated>cd /home/jean-luc-makiola/Development/projects/GearBox && bun run build 2>&1 | tail -20</automated>
+  </verify>
+  <acceptance_criteria>
+    - src/client/components/PublicSetupCard.tsx contains `itemCount?: number`
+    - src/client/components/PublicSetupCard.tsx contains `creatorName?: string | null`
+    - src/client/components/PublicSetupCard.tsx contains `setup.itemCount` (conditional rendering)
+    - src/client/components/PublicSetupCard.tsx contains `setup.creatorName` (conditional rendering)
+    - src/client/components/PublicSetupCard.tsx contains `cursor-pointer`
+    - `bun run build` succeeds without TypeScript errors
+  </acceptance_criteria>
+  <done>PublicSetupCard renders item count and creator name when provided, existing usages compile without changes, cursor-pointer applied.</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Rewrite index.tsx as discovery landing page</name>
+  <files>src/client/routes/index.tsx</files>
+  <read_first>
+    - src/client/routes/index.tsx (current dashboard — will be completely rewritten)
+    - src/client/components/GlobalItemCard.tsx (props interface for rendering items)
+    - src/client/components/PublicSetupCard.tsx (enhanced props from Task 1)
+    - src/client/hooks/useDiscovery.ts (hook signatures from plan 02)
+    - src/client/hooks/useAuth.ts (useAuth hook pattern)
+    - src/client/stores/uiStore.ts (openCatalogSearch usage pattern)
+    - src/client/routes/__root.tsx (isDashboard detection — do NOT modify per Pitfall 2)
+  </read_first>
+  <action>
+    **Completely rewrite `src/client/routes/index.tsx`** (per D-03, retire DashboardPage entirely):
+
+    Remove ALL existing imports (DashboardCard, useFormatters, useSetups, useThreads, useTotals).
+
+    New imports:
+    ```typescript
+    import { createFileRoute, Link } from "@tanstack/react-router";
+    import { Search } from "lucide-react";
+    import { GlobalItemCard } from "../components/GlobalItemCard";
+    import { PublicSetupCard } from "../components/PublicSetupCard";
+    import { useAuth } from "../hooks/useAuth";
+    import { useDiscoverySetups, useDiscoveryItems, useDiscoveryCategories } from "../hooks/useDiscovery";
+    import { useUIStore } from "../stores/uiStore";
+    ```
+
+    Note: Use `lucide-react` for the Search icon. The project already uses lucide-react (check existing imports). If the project uses the custom `LucideIcon` component instead, use `<LucideIcon name="search" className="w-5 h-5 text-gray-400" />` from `../lib/iconData`.
+
+    **Route export** (same file route, new component):
+    ```typescript
+    export const Route = createFileRoute("/")({
+      component: LandingPage,
+    });
+    ```
+
+    **LandingPage function** (per D-01, D-02):
+    ```typescript
+    function LandingPage() {
+      const { data: auth } = useAuth();
+      const isAuthenticated = !!auth?.user;
+      const openCatalogSearch = useUIStore((s) => s.openCatalogSearch);
+
+      return (
+        <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
+          <HeroSection isAuthenticated={isAuthenticated} onSearchFocus={() => openCatalogSearch("collection")} />
+          <PopularSetupsSection />
+          <RecentItemsSection />
+          <TrendingCategoriesSection />
+        </div>
+      );
+    }
+    ```
+
+    **HeroSection** (per D-01, D-04, D-10, D-11):
+    ```typescript
+    function HeroSection({ isAuthenticated, onSearchFocus }: { isAuthenticated: boolean; onSearchFocus: () => void }) {
+      return (
+        <div className="text-center mb-16">
+          <h1 className="text-3xl sm:text-4xl font-bold text-gray-900 mb-2">Discover Gear</h1>
+          <p className="text-gray-500 mb-8">Browse what other people carry</p>
+          <div
+            onClick={onSearchFocus}
+            onKeyDown={(e) => e.key === "Enter" && onSearchFocus()}
+            role="button"
+            tabIndex={0}
+            className="max-w-xl mx-auto flex items-center gap-3 px-4 py-3 bg-white rounded-xl border border-gray-200 hover:border-gray-300 cursor-pointer shadow-sm transition-all"
+          >
+            <Search className="w-5 h-5 text-gray-400 shrink-0" />
+            <span className="text-sm text-gray-400 flex-1 text-left">Search the catalog...</span>
+          </div>
+          {isAuthenticated && (
+            <div className="mt-4">
+              <Link to="/collection" className="text-sm text-gray-600 hover:text-gray-900 underline underline-offset-2 cursor-pointer">
+                Go to Collection
+              </Link>
+            </div>
+          )}
+        </div>
+      );
+    }
+    ```
+
+    **PopularSetupsSection** (per D-02, D-05):
+    ```typescript
+    function PopularSetupsSection() {
+      const { data, isLoading } = useDiscoverySetups(6);
+      const setups = data?.items ?? [];
+
+      if (!isLoading && setups.length === 0) return null;
+
+      return (
+        <section className="mb-12">
+          <div className="flex items-center justify-between mb-4">
+            <h2 className="text-lg font-semibold text-gray-900">Popular Setups</h2>
+          </div>
+          {isLoading ? (
+            <SectionSkeleton count={6} aspect="none" />
+          ) : (
+            <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
+              {setups.map((setup) => (
+                <PublicSetupCard key={setup.id} setup={setup} />
+              ))}
+            </div>
+          )}
+        </section>
+      );
+    }
+    ```
+
+    **RecentItemsSection** (per D-02, D-06):
+    ```typescript
+    function RecentItemsSection() {
+      const { data, isLoading } = useDiscoveryItems(8);
+      const items = data?.items ?? [];
+
+      if (!isLoading && items.length === 0) return null;
+
+      return (
+        <section className="mb-12">
+          <div className="flex items-center justify-between mb-4">
+            <h2 className="text-lg font-semibold text-gray-900">Recently Added</h2>
+          </div>
+          {isLoading ? (
+            <SectionSkeleton count={8} aspect="[4/3]" />
+          ) : (
+            <div className="grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-4 gap-4">
+              {items.map((item) => (
+                <GlobalItemCard
+                  key={item.id}
+                  id={item.id}
+                  brand={item.brand}
+                  model={item.model}
+                  category={item.category}
+                  weightGrams={item.weightGrams}
+                  priceCents={item.priceCents}
+                  imageUrl={item.imageUrl}
+                />
+              ))}
+            </div>
+          )}
+        </section>
+      );
+    }
+    ```
+
+    **TrendingCategoriesSection** (per D-02, D-07):
+    ```typescript
+    function TrendingCategoriesSection() {
+      const { data, isLoading } = useDiscoveryCategories(12);
+      const categories = data ?? [];
+
+      if (!isLoading && categories.length === 0) return null;
+
+      return (
+        <section className="mb-12">
+          <div className="flex items-center justify-between mb-4">
+            <h2 className="text-lg font-semibold text-gray-900">Trending Categories</h2>
+          </div>
+          {isLoading ? (
+            <div className="flex flex-wrap gap-2">
+              {Array.from({ length: 8 }).map((_, i) => (
+                <div key={i} className="h-8 w-24 bg-gray-100 rounded-full animate-pulse" />
+              ))}
+            </div>
+          ) : (
+            <div className="flex flex-wrap gap-2">
+              {categories.map((cat) => (
+                <span
+                  key={cat.name}
+                  className="inline-flex items-center gap-1.5 px-3 py-1.5 rounded-full text-sm font-medium bg-gray-50 text-gray-700 border border-gray-100 hover:border-gray-200 hover:bg-gray-100 transition-all cursor-pointer"
+                >
+                  {cat.name}
+                  <span className="text-xs text-gray-400">{cat.itemCount}</span>
+                </span>
+              ))}
+            </div>
+          )}
+        </section>
+      );
+    }
+    ```
+
+    **SectionSkeleton** helper (matches CatalogSearchOverlay animate-pulse pattern):
+    ```typescript
+    function SectionSkeleton({ count, aspect }: { count: number; aspect: string }) {
+      return (
+        <div className={`grid ${aspect === "none" ? "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3" : "grid-cols-2 sm:grid-cols-3 lg:grid-cols-4"} gap-4`}>
+          {Array.from({ length: count }).map((_, i) => (
+            <div key={i} className="bg-white rounded-xl border border-gray-100 overflow-hidden animate-pulse">
+              {aspect !== "none" && <div className={`aspect-${aspect} bg-gray-100`} />}
+              <div className="p-4 space-y-2">
+                <div className="h-3 bg-gray-100 rounded w-16" />
+                <div className="h-4 bg-gray-100 rounded w-32" />
+              </div>
+            </div>
+          ))}
+        </div>
+      );
+    }
+    ```
+
+    Ensure all clickable elements have `cursor-pointer` (folded todo from CONTEXT.md).
+  </action>
+  <verify>
+    <automated>cd /home/jean-luc-makiola/Development/projects/GearBox && bun run build 2>&1 | tail -20</automated>
+  </verify>
+  <acceptance_criteria>
+    - src/client/routes/index.tsx does NOT contain `DashboardPage` or `DashboardCard` or `useTotals` (per D-03)
+    - src/client/routes/index.tsx contains `function LandingPage()`
+    - src/client/routes/index.tsx contains `function HeroSection(`
+    - src/client/routes/index.tsx contains `openCatalogSearch("collection")` (per D-04)
+    - src/client/routes/index.tsx contains `useDiscoverySetups` and `useDiscoveryItems` and `useDiscoveryCategories`
+    - src/client/routes/index.tsx contains `"Go to Collection"` (per D-10)
+    - src/client/routes/index.tsx contains `!!auth?.user` or `auth?.user` for auth check (per anti-pattern: do not use auth?.authenticated)
+    - src/client/routes/index.tsx contains `GlobalItemCard` import
+    - src/client/routes/index.tsx contains `PublicSetupCard` import
+    - src/client/routes/index.tsx contains `cursor-pointer` on the search bar div
+    - src/client/routes/index.tsx contains `animate-pulse` (loading skeletons)
+    - `bun run build` succeeds without errors
+  </acceptance_criteria>
+  <done>Landing page renders hero with search trigger, three feed sections with loading skeletons and empty-state handling, authenticated CTA, and all clickable elements have cursor-pointer. Build succeeds.</done>
+</task>
+
+<task type="checkpoint:human-verify" gate="blocking">
+  <name>Task 3: Visual verification of discovery landing page</name>
+  <files>src/client/routes/index.tsx</files>
+  <action>
+    No code changes — this is a visual verification checkpoint. The executor should start the dev server with `bun run dev` and present the verification steps to the user.
+  </action>
+  <what-built>
+    Complete discovery landing page replacing the personal dashboard at /. Features:
+    - Hero section with "Discover Gear" heading and catalog search bar trigger
+    - Popular Setups section with enhanced cards (item count, creator name)
+    - Recently Added Items section with GlobalItemCard components
+    - Trending Categories section with category pills
+    - Conditional "Go to Collection" link for authenticated users
+    - Loading skeletons for all sections
+    - Empty state handling (sections hide when no data)
+  </what-built>
+  <how-to-verify>
+    1. Run `bun run dev` and open http://localhost:5173/ in a browser
+    2. Verify the hero section shows "Discover Gear" heading with search bar
+    3. Click the search bar — it should open the full CatalogSearchOverlay
+    4. Verify sections appear below: Popular Setups, Recently Added, Trending Categories
+    5. If there is seed data, verify cards show correct information (item counts, creator names, images)
+    6. If no data exists, verify empty sections are hidden gracefully (no broken/empty grids)
+    7. Log in and verify "Go to Collection" link appears in hero area
+    8. Click "Go to Collection" — should navigate to /collection
+    9. Check responsive behavior: resize browser to mobile width, verify single-column layout
+    10. Verify all clickable elements show pointer cursor on hover
+  </how-to-verify>
+  <verify>
+    <automated>cd /home/jean-luc-makiola/Development/projects/GearBox && bun run build 2>&1 | tail -5</automated>
+  </verify>
+  <done>User has visually verified the landing page renders correctly with all sections, search trigger works, auth CTA appears for logged-in users, and responsive layout is correct.</done>
+  <resume-signal>Type "approved" or describe issues to fix</resume-signal>
+</task>
+
+</tasks>
+
+<verification>
+- `bun run build` — builds without errors
+- Visual inspection of landing page at localhost:5173
+- CatalogSearchOverlay opens from hero search bar
+- Authenticated user sees "Go to Collection" link
+- Anonymous user sees content immediately
+</verification>
+
+<success_criteria>
+- Root URL shows discovery landing page (not personal dashboard)
+- Hero search bar triggers CatalogSearchOverlay on click
+- Three content sections render with real data or hide when empty
+- PublicSetupCard displays item count and creator name
+- Authenticated users see "Go to Collection" CTA in hero
+- All clickable elements have cursor-pointer
+- Build succeeds
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/26-discovery-landing-page/26-03-SUMMARY.md`
+</output>
--- a/.planning/phases/26-discovery-landing-page/26-03-SUMMARY.md
+++ b/.planning/phases/26-discovery-landing-page/26-03-SUMMARY.md
@@ -0,0 +1,111 @@
+---
+phase: 26-discovery-landing-page
+plan: "03"
+subsystem: ui
+tags: [react, tanstack-router, tanstack-query, tailwind, lucide-react]
+
+# Dependency graph
+requires:
+  - phase: 26-01
+    provides: discovery API endpoints (GET /api/discovery/setups, items, categories)
+  - phase: 26-02
+    provides: useDiscoverySetups, useDiscoveryItems, useDiscoveryCategories hooks
+provides:
+  - Landing page at / with hero, popular setups, recent items, trending categories
+  - Enhanced PublicSetupCard with itemCount and creatorName display
+affects:
+  - users/$userId (inherits PublicSetupCard enhancement)
+  - CatalogSearchOverlay (triggered from hero search bar)
+
+# Tech tracking
+tech-stack:
+  added: []
+  patterns:
+    - Empty-state hiding: sections return null when not loading and data is empty
+    - SectionSkeleton helper for consistent animate-pulse loading states
+    - Auth-conditional CTA: !!auth?.user pattern for authenticated UI branching
+
+key-files:
+  created: []
+  modified:
+    - src/client/routes/index.tsx
+    - src/client/components/PublicSetupCard.tsx
+
+key-decisions:
+  - "PublicSetupCard itemCount/creatorName fields are optional for backward compatibility with users/$userId usage"
+  - "HeroSection search bar triggers openCatalogSearch('collection') from uiStore — not a real input, just a click target"
+  - "Sections hide entirely (return null) when not loading and data is empty — avoids empty grid layouts"
+
+patterns-established:
+  - "Optional prop enhancement: add new props as optional to avoid breaking existing usages"
+  - "Discovery page sections are self-contained components that own their data-fetching logic"
+
+requirements-completed: [DISC-01, DISC-02, DISC-03, DISC-04, DISC-05]
+
+# Metrics
+duration: 2min
+completed: 2026-04-10
+---
+
+# Phase 26 Plan 03: Discovery Landing Page Summary
+
+**Discovery landing page replacing personal dashboard — hero search trigger, popular setups feed, recent catalog items, trending categories, with auth-conditional CTA and PublicSetupCard enhanced with item counts and creator names**
+
+## Performance
+
+- **Duration:** 2 min
+- **Started:** 2026-04-10T13:00:39Z
+- **Completed:** 2026-04-10T13:02:15Z
+- **Tasks:** 2 executed (+ 1 human-verify checkpoint auto-approved)
+- **Files modified:** 2
+
+## Accomplishments
+- Rewrote `src/client/routes/index.tsx` from personal dashboard (DashboardPage) to public discovery landing page (LandingPage)
+- Added hero section with "Discover Gear" heading, catalog search bar trigger (opens CatalogSearchOverlay), and conditional "Go to Collection" link for authenticated users
+- Built three content feed sections: Popular Setups (PublicSetupCard grid), Recently Added (GlobalItemCard grid), Trending Categories (pill chips)
+- Enhanced `PublicSetupCard` with optional `itemCount` and `creatorName` fields — backward compatible with existing users/$userId usage
+- Loading skeletons (animate-pulse) for all sections; sections hide when empty
+
+## Task Commits
+
+Each task was committed atomically:
+
+1. **Task 1: Enhance PublicSetupCard with itemCount and creatorName** - `0bf1c68` (feat)
+2. **Task 2: Rewrite index.tsx as discovery landing page** - `8aaf435` (feat)
+3. **Task 3: Visual verification checkpoint** - auto-approved (auto-chain active)
+
+## Files Created/Modified
+- `src/client/routes/index.tsx` - Completely rewritten as LandingPage with HeroSection, PopularSetupsSection, RecentItemsSection, TrendingCategoriesSection, SectionSkeleton
+- `src/client/components/PublicSetupCard.tsx` - Enhanced with optional itemCount (blue badge) and creatorName (attribution line), cursor-pointer added
+
+## Decisions Made
+- PublicSetupCard enhancement used optional props to maintain backward compat — existing `users/$userId.tsx` usage requires no changes
+- Search bar is a styled div with onClick/onKeyDown, not a real input — clicking opens CatalogSearchOverlay directly
+- Auth check uses `!!auth?.user` (not `auth?.authenticated`) per plan anti-pattern guidance
+
+## Deviations from Plan
+
+None - plan executed exactly as written.
+
+## Issues Encountered
+
+None.
+
+## User Setup Required
+
+None - no external service configuration required.
+
+## Known Stubs
+
+None — all three discovery sections fetch real data from the API endpoints built in plans 26-01 and 26-02. Empty state is handled by hiding sections.
+
+## Next Phase Readiness
+- Discovery landing page complete — phase 26 fully delivered
+- All DISC-01 through DISC-05 requirements satisfied
+- PublicSetupCard enhancement available for any future usage needing item counts
+
+## Self-Check: PASSED
+
+---
+*Phase: 26-discovery-landing-page*
+*Completed: 2026-04-10*
--- a/.planning/phases/26-discovery-landing-page/26-CONTEXT.md
+++ b/.planning/phases/26-discovery-landing-page/26-CONTEXT.md
@@ -0,0 +1,135 @@
+# Phase 26: Discovery Landing Page - Context
+
+**Gathered:** 2026-04-10
+**Status:** Ready for planning
+
+<domain>
+## Phase Boundary
+
+Replace the current personal dashboard at `/` with a public-first discovery landing page. The page features a prominent catalog search bar at the top, a feed of popular public setups, recently added catalog items, and trending categories. Authenticated users see a "Go to Collection" entry point. This is the first page any visitor sees — no login required.
+
+</domain>
+
+<decisions>
+## Implementation Decisions
+
+### Page Layout & Structure
+- **D-01:** Full-width hero area with catalog search bar prominently centered. Below the hero, a vertical stack of content sections.
+- **D-02:** Section order: (1) Hero with search bar, (2) Popular Setups, (3) Recently Added Items, (4) Trending Categories. Each section has a heading and optional "View all" link.
+- **D-03:** The current `DashboardPage` component and its `DashboardCard` usage at `/` will be replaced entirely. The dashboard is now the landing page.
+
+### Search Bar Behavior
+- **D-04:** The hero search bar triggers the existing `CatalogSearchOverlay` on focus or typing. This reuses the full-featured search (tag filtering, grid/list toggle, manual entry fallback) without duplicating search UI. The search bar on the landing page is a visual entry point, not a standalone search results container.
+
+### Feed Data Sources & Ranking
+- **D-05:** "Popular setups" ranked by item count descending (proxy for effort/completeness). Only public setups are shown. No engagement tracking exists yet — item count is available via `setupItems` join table.
+- **D-06:** "Recently added items" shows the most recently created `globalItems`, ordered by `createdAt` descending.
+- **D-07:** "Trending categories" ranked by global item count per distinct `globalItems.category` value. Categories with the most catalog items appear first.
+- **D-08:** Cursor-based pagination for feed sections per INFR-02. Use `createdAt` cursor for recently added items; item count + ID cursor for popular setups.
+
+### Authenticated vs Anonymous Experience
+- **D-09:** Same page content for both authenticated and anonymous users — no personalized feed in v2.1. The difference is purely navigational.
+- **D-10:** Authenticated users see a "Go to Collection" CTA in the hero area, next to the search bar. Visible without scrolling.
+- **D-11:** Anonymous users see the search bar and content sections immediately (fire-and-forget auth from Phase 24, D-09). Sign-in button in top-right per Phase 24, D-10.
+
+### Claude's Discretion
+- Exact layout sizing, spacing, and responsive breakpoints
+- Number of items shown per section before "View all" (suggest 6-8 for items/setups, 8-12 for categories)
+- Empty states for sections with no data
+- Loading skeletons for each section
+- Whether "View all" links for setups/items route to existing pages or new dedicated feed pages
+
+### Folded Todos
+- **Add cursor pointer to all clickable links** — Ensure all clickable elements on the landing page have `cursor-pointer`. Apply broadly while building the new page.
+- **Fix item image not showing on collection overview** — Investigate and fix image display issue; relevant since landing page will show `GlobalItemCard` components with images.
+- **Investigate slow image loading** — Profile image loading performance; landing page is image-heavy with item cards and setup previews.
+
+</decisions>
+
+<canonical_refs>
+## Canonical References
+
+**Downstream agents MUST read these before planning or implementing.**
+
+### Current Landing Page (to replace)
+- `src/client/routes/index.tsx` — Current dashboard page component (will be rewritten)
+- `src/client/components/DashboardCard.tsx` — Current dashboard card (will be unused after this phase)
+
+### Reusable Components
+- `src/client/components/GlobalItemCard.tsx` — Catalog item card with image, brand/model, weight/price pills
+- `src/client/components/PublicSetupCard.tsx` — Basic public setup card (name + date; may need enhancement for item count)
+- `src/client/components/CatalogSearchOverlay.tsx` — Full-screen search overlay with debounce, tag filtering, grid/list modes
+
+### Hooks & Data
+- `src/client/hooks/useGlobalItems.ts` — Search global items by query and tags
+- `src/client/hooks/useTags.ts` — Fetch tag list
+- `src/client/hooks/useAuth.ts` — Auth state (`user`, `authenticated`)
+- `src/client/stores/uiStore.ts` — UI state store including `catalogSearchOpen` / `openCatalogSearch`
+
+### Server Services
+- `src/server/services/global-item.service.ts` — `searchGlobalItems` (needs new queries: recent items, category counts)
+- `src/server/services/profile.service.ts` — `getPublicProfile`, `getPublicSetupWithItems` (setup data patterns)
+
+### Routes & API
+- `src/server/routes/global-items.ts` — Current GET endpoints (needs discovery feed endpoints)
+- `src/server/routes/setups.ts` — Public setup view endpoint (`GET /:id/public`)
+- `src/server/index.ts` — Route registration and public route allowlist
+
+### Auth & Layout
+- `src/client/routes/__root.tsx` — Root layout, auth check, `isPublicRoute` logic (root `/` already public per Phase 24)
+
+### Requirements
+- `.planning/REQUIREMENTS.md` — DISC-01 through DISC-05, INFR-02
+
+</canonical_refs>
+
+<code_context>
+## Existing Code Insights
+
+### Reusable Assets
+- `GlobalItemCard` — Ready-to-use catalog item card with image placeholder, brand/model, weight/price/category pills. Can be used directly in "Recently Added" section.
+- `PublicSetupCard` — Minimal card (name + date). Needs enhancement: add item count, possibly creator name and total weight to be useful in a "Popular Setups" feed.
+- `CatalogSearchOverlay` — Full search implementation with debounce, tag chip filtering, grid/list toggle, manual entry. Landing page search bar should open this overlay rather than duplicating search logic.
+- `useFormatters` hook — Weight and price formatting, reusable across all card components.
+- `LucideIcon` component — For category icons in the "Trending Categories" section.
+
+### Established Patterns
+- TanStack Router file-based routes — new route stays at `routes/index.tsx` (same file, new content)
+- TanStack React Query for data fetching — landing page sections each get their own query hook
+- Tailwind CSS v4 with light/airy/minimalist design language — white backgrounds, gray borders, rounded-xl cards, subtle shadows on hover
+- Card pattern: `bg-white rounded-xl border border-gray-100 hover:border-gray-200 hover:shadow-md transition-all`
+
+### Integration Points
+- `routes/index.tsx` — Rewrite to render landing page instead of dashboard
+- New server endpoints needed: `GET /api/discovery/setups` (popular), `GET /api/discovery/items` (recent), `GET /api/discovery/categories` (trending)
+- `uiStore.openCatalogSearch()` — Trigger from the hero search bar
+
+</code_context>
+
+<specifics>
+## Specific Ideas
+
+- Design should feel like a welcoming storefront, not a login gate — consistent with Phase 24's "new user experience matters more" principle
+- Tags are the public taxonomy for discovery; categories are private organizational tools — the landing page uses tags for any filtering/categorization display, not user categories
+- Hero area should be visually distinctive but not heavy — the app's DNA is "light, airy, minimalist"
+
+</specifics>
+
+<deferred>
+## Deferred Ideas
+
+- Personalized feed based on user's collection categories (PERS-01, PERS-02) — tracked in future requirements
+- SSR/static prerendering for SEO (SEO-01, SEO-02) — out of scope for v2.1
+- Engagement metrics (views, likes) for better ranking — no tracking infrastructure yet
+- Setup preview images/thumbnails — no setup image feature exists
+
+### Reviewed Todos (not folded)
+- **Add manufacturer entity with brand details** — Database schema enhancement unrelated to landing page UI; belongs in a future catalog data model phase
+- **Fix storage service tests** — Testing infrastructure concern; not related to landing page feature work
+
+</deferred>
+
+---
+
+*Phase: 26-discovery-landing-page*
+*Context gathered: 2026-04-10*
--- a/.planning/phases/26-discovery-landing-page/26-DISCUSSION-LOG.md
+++ b/.planning/phases/26-discovery-landing-page/26-DISCUSSION-LOG.md
@@ -0,0 +1,103 @@
+# Phase 26: Discovery Landing Page - Discussion Log
+
+> **Audit trail only.** Do not use as input to planning, research, or execution agents.
+> Decisions are captured in CONTEXT.md — this log preserves the alternatives considered.
+
+**Date:** 2026-04-10
+**Phase:** 26-discovery-landing-page
+**Areas discussed:** Page Structure & Section Order, Search Bar Behavior, Feed Data & Ranking, Auth-Variant Experience
+**Mode:** --batch --auto (all decisions auto-selected)
+
+---
+
+## Page Structure & Section Order
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Hero search + vertical sections | Full-width hero with search bar, vertical stack of content sections below | ✓ |
+| Grid dashboard | Multi-column grid of section cards (like current dashboard) | |
+| Single infinite feed | One merged feed of all content types | |
+
+**User's choice:** [auto] Hero search + vertical sections (recommended default)
+**Notes:** Reuses existing visual patterns (cards, rounded-xl, light borders). Section order: Search → Setups → Items → Categories, prioritizing social content first.
+
+---
+
+## Search Bar Behavior
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Open CatalogSearchOverlay | Hero search bar triggers existing overlay on focus/type | ✓ |
+| Inline search results | Show results directly below the search bar on the landing page | |
+| Dedicated search route | Navigate to /search with query params | |
+
+**User's choice:** [auto] Open CatalogSearchOverlay (recommended default)
+**Notes:** Avoids duplicating the full-featured search UI (tag filtering, grid/list toggle, manual entry fallback). CatalogSearchOverlay is already built and tested.
+
+---
+
+## Feed Data & Ranking
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Item count proxy (setups) | Rank popular setups by number of items — more items = more effort/completeness | ✓ |
+| Creation date (setups) | Show most recently created setups | |
+| Random rotation | Rotate featured setups randomly | |
+
+**User's choice:** [auto] Item count proxy (recommended default)
+**Notes:** No engagement metrics exist. Item count is the best available proxy and is trivially queryable via setupItems join.
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Global item count per category | Trending = categories with most catalog items | ✓ |
+| Recent growth rate | Categories with most new items in last 7 days | |
+
+**User's choice:** [auto] Global item count per category (recommended default)
+**Notes:** Simpler query, no time-windowed aggregation needed. Growth-based trending can be added later when catalog is larger.
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Cursor-based pagination | Use cursor pagination per INFR-02 requirement | ✓ |
+| Offset pagination | Traditional LIMIT/OFFSET | |
+
+**User's choice:** [auto] Cursor-based pagination (recommended default — required by INFR-02)
+
+---
+
+## Auth-Variant Experience
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| Same page + Collection CTA | Identical content, authenticated users get "Go to Collection" button in hero | ✓ |
+| Dual-mode page | Show personal stats/shortcuts for authenticated users | |
+| Redirect authenticated to dashboard | Authenticated users skip landing page entirely | |
+
+**User's choice:** [auto] Same page + Collection CTA (recommended default)
+**Notes:** Per DISC-05, the difference is a single navigational CTA. No personalized feed in v2.1 (PERS-01/PERS-02 deferred).
+
+| Option | Description | Selected |
+|--------|-------------|----------|
+| In hero area next to search | CTA visible without scrolling, adjacent to primary action | ✓ |
+| Floating sidebar | Persistent side panel for authenticated users | |
+| Below hero | Separate banner below search area | |
+
+**User's choice:** [auto] In hero area next to search (recommended default)
+
+---
+
+## Claude's Discretion
+
+- Exact layout sizing, spacing, and responsive breakpoints
+- Number of items shown per section before "View all"
+- Empty states for sections with no data
+- Loading skeletons for each section
+- Whether "View all" links route to existing pages or new feed pages
+
+## Deferred Ideas
+
+- Personalized feed (PERS-01, PERS-02)
+- SSR/static prerendering for SEO (SEO-01, SEO-02)
+- Engagement metrics for ranking
+- Setup preview images
+- Manufacturer entity (todo — different domain)
+- Storage service tests (todo — testing concern)
--- a/.planning/phases/26-discovery-landing-page/26-RESEARCH.md
+++ b/.planning/phases/26-discovery-landing-page/26-RESEARCH.md
@@ -0,0 +1,591 @@
+# Phase 26: Discovery Landing Page - Research
+
+**Researched:** 2026-04-10
+**Domain:** React SPA landing page, public API feed endpoints, cursor pagination
+**Confidence:** HIGH
+
+---
+
+<user_constraints>
+## User Constraints (from CONTEXT.md)
+
+### Locked Decisions
+- **D-01:** Full-width hero area with catalog search bar prominently centered. Below the hero, a vertical stack of content sections.
+- **D-02:** Section order: (1) Hero with search bar, (2) Popular Setups, (3) Recently Added Items, (4) Trending Categories. Each section has a heading and optional "View all" link.
+- **D-03:** The current `DashboardPage` component and its `DashboardCard` usage at `/` will be replaced entirely. The dashboard is now the landing page.
+- **D-04:** The hero search bar triggers the existing `CatalogSearchOverlay` on focus or typing. This reuses the full-featured search without duplicating search UI.
+- **D-05:** "Popular setups" ranked by item count descending (proxy for effort/completeness). Only public setups are shown.
+- **D-06:** "Recently added items" shows the most recently created `globalItems`, ordered by `createdAt` descending.
+- **D-07:** "Trending categories" ranked by global item count per distinct `globalItems.category` value.
+- **D-08:** Cursor-based pagination for feed sections per INFR-02. Use `createdAt` cursor for recently added items; item count + ID cursor for popular setups.
+- **D-09:** Same page content for both authenticated and anonymous users. Difference is purely navigational.
+- **D-10:** Authenticated users see a "Go to Collection" CTA in the hero area, next to the search bar. Visible without scrolling.
+- **D-11:** Anonymous users see the search bar and content sections immediately. Sign-in button in top-right per Phase 24.
+
+### Claude's Discretion
+- Exact layout sizing, spacing, and responsive breakpoints
+- Number of items shown per section before "View all" (suggest 6-8 for items/setups, 8-12 for categories)
+- Empty states for sections with no data
+- Loading skeletons for each section
+- Whether "View all" links for setups/items route to existing pages or new dedicated feed pages
+
+### Folded Todos (IN SCOPE)
+- **Add cursor pointer to all clickable links** — Apply broadly while building the new page.
+- **Fix item image not showing on collection overview** — Investigate and fix image display issue since landing page will show `GlobalItemCard` components with images.
+- **Investigate slow image loading** — Profile image loading performance.
+
+### Deferred Ideas (OUT OF SCOPE)
+- Personalized feed based on user's collection categories (PERS-01, PERS-02)
+- SSR/static prerendering for SEO (SEO-01, SEO-02)
+- Engagement metrics (views, likes) for better ranking
+- Setup preview images/thumbnails
+</user_constraints>
+
+---
+
+<phase_requirements>
+## Phase Requirements
+
+| ID | Description | Research Support |
+|----|-------------|------------------|
+| DISC-01 | Landing page displays an always-visible catalog search bar at the top | Hero section with `CatalogSearchOverlay` trigger; search bar renders unconditionally |
+| DISC-02 | Landing page shows a feed of popular setups below the search | New `GET /api/discovery/setups` endpoint; `useDiscoverySetups` hook; enhanced `PublicSetupCard` |
+| DISC-03 | Landing page shows recently added catalog items | New `GET /api/discovery/items` endpoint; `useDiscoveryItems` hook; `GlobalItemCard` reuse |
+| DISC-04 | Landing page shows trending categories | New `GET /api/discovery/categories` endpoint; `useDiscoveryCategories` hook; category pill/card display |
+| DISC-05 | Authenticated users see a "Go to Collection" entry point | `useAuth` hook; conditional CTA in hero using `auth.user` presence |
+| INFR-02 | Discovery feed endpoint uses cursor pagination | Cursor-based pagination on `createdAt` / `(itemCount, id)` — no offset pagination |
+</phase_requirements>
+
+---
+
+## Summary
+
+Phase 26 replaces the personal dashboard at `/` with a public discovery landing page. The existing codebase is well-structured for this work: the current `index.tsx` is thin (61 lines), the reusable components (`GlobalItemCard`, `CatalogSearchOverlay`) are ready, the auth pattern (`useAuth`) is already in place, and the Tailwind design language is consistent throughout.
+
+The primary technical work divides into three areas: (1) three new server-side discovery endpoints with cursor pagination, (2) three corresponding React Query hooks on the client, and (3) rewriting `index.tsx` into the landing page layout with hero, sections, and conditional auth CTA. The `PublicSetupCard` needs a minor enhancement to show item count and creator name for the popular setups section.
+
+The folded todos (cursor pointer, image display bug) must be addressed during this phase since they directly affect the landing page experience.
+
+**Primary recommendation:** Build three `GET /api/discovery/*` endpoints, mirror them with three React Query hooks, and rewrite `routes/index.tsx` composing existing `GlobalItemCard` and enhanced `PublicSetupCard`. Add a `discoveryRoutes` file registered at `/api/discovery` in `server/index.ts`.
+
+---
+
+## Standard Stack
+
+### Core (already in project)
+| Library | Version | Purpose | Why Standard |
+|---------|---------|---------|--------------|
+| TanStack Router | file-based | Client routing; `routes/index.tsx` stays same file | Project standard |
+| TanStack React Query | in project | Data fetching hooks; each section gets its own hook | Project standard |
+| Tailwind CSS v4 | in project | Styling; `bg-white rounded-xl border border-gray-100` card pattern | Project standard |
+| Hono | in project | Server routes; new `discoveryRoutes` file follows same pattern | Project standard |
+| Drizzle ORM | in project | SQL queries with `desc`, `count`, `groupBy` for feed data | Project standard |
+| Zustand (`uiStore`) | in project | `openCatalogSearch()` trigger from hero search bar | Project standard |
+
+### No New Dependencies
+This phase requires zero new package installations. All patterns and libraries are already present.
+
+---
+
+## Architecture Patterns
+
+### Recommended Project Structure Changes
+
+```
+src/
+├── client/
+│   ├── routes/
+│   │   └── index.tsx               # REWRITE — landing page (replaces dashboard)
+│   ├── hooks/
+│   │   └── useDiscovery.ts         # NEW — three hooks: useDiscoverySetups, useDiscoveryItems, useDiscoveryCategories
+│   └── components/
+│       └── PublicSetupCard.tsx     # ENHANCE — add itemCount + creatorName props
+└── server/
+    ├── routes/
+    │   └── discovery.ts            # NEW — GET /setups, /items, /categories
+    ├── services/
+    │   └── discovery.service.ts    # NEW — getPopularSetups, getRecentItems, getTrendingCategories
+    └── index.ts                    # ADD — discoveryRoutes registration + public allowlist + rate limit
+```
+
+### Pattern 1: Discovery Endpoint with Cursor Pagination (INFR-02)
+
+**What:** GET endpoints accept an optional `cursor` query param and `limit`. Cursor encodes position in result set without OFFSET.
+
+**For recently added items** — cursor is the `createdAt` ISO timestamp of the last seen item:
+```typescript
+// Source: Drizzle ORM docs — cursor pagination
+// GET /api/discovery/items?limit=8&cursor=2026-04-01T00:00:00.000Z
+export async function getRecentGlobalItems(
+  db: Db,
+  limit = 8,
+  cursor?: string, // ISO timestamp of last seen item
+) {
+  const conditions = cursor
+    ? [lt(globalItems.createdAt, new Date(cursor))]
+    : [];
+
+  return db
+    .select()
+    .from(globalItems)
+    .where(conditions.length ? and(...conditions) : undefined)
+    .orderBy(desc(globalItems.createdAt))
+    .limit(limit + 1); // fetch one extra to detect hasMore
+}
+```
+
+**For popular setups** — cursor is `itemCount_id` (composite: item count + setup id for stable ordering):
+```typescript
+// GET /api/discovery/setups?limit=6&cursor=5_42
+// cursor = "{itemCount}_{id}" — both fields for stable pagination
+export async function getPopularSetups(
+  db: Db,
+  limit = 6,
+  cursor?: string,
+) {
+  const itemCountExpr = sql<number>`CAST(COUNT(${setupItems.id}) AS INT)`;
+
+  // Build base query with JOIN to count items per public setup
+  let query = db
+    .select({
+      id: setups.id,
+      name: setups.name,
+      createdAt: setups.createdAt,
+      itemCount: itemCountExpr,
+    })
+    .from(setups)
+    .leftJoin(setupItems, eq(setupItems.setupId, setups.id))
+    .where(eq(setups.isPublic, true))
+    .groupBy(setups.id, setups.name, setups.createdAt)
+    .orderBy(desc(itemCountExpr), desc(setups.id))
+    .limit(limit + 1);
+
+  // Cursor filtering applied post-query (simpler for composite cursor with SQLite)
+  const rows = await query;
+  if (cursor) {
+    const [cursorCount, cursorId] = cursor.split("_").map(Number);
+    // Filter: itemCount < cursorCount, OR (itemCount === cursorCount AND id < cursorId)
+    return rows.filter(r =>
+      r.itemCount < cursorCount ||
+      (r.itemCount === cursorCount && r.id < cursorId)
+    ).slice(0, limit + 1);
+  }
+  return rows;
+}
+```
+
+**Note:** For SQLite (production DB is PostgreSQL per schema imports, but schema uses `pgTable`), the `ilike` operator is already in use in `global-item.service.ts`. The Drizzle operators `lt`, `desc`, `count`, `sql` are all already imported in the codebase.
+
+**hasMore detection pattern:**
+```typescript
+// In route handler — consistent across all three endpoints
+const rows = await getRecentGlobalItems(db, limit + 1, cursor);
+const hasMore = rows.length > limit;
+const items = hasMore ? rows.slice(0, limit) : rows;
+const nextCursor = hasMore ? buildCursor(items[items.length - 1]) : null;
+return c.json({ items, nextCursor, hasMore });
+```
+
+### Pattern 2: Discovery Route Registration
+
+**What:** New `discoveryRoutes` file registered at `/api/discovery` in `server/index.ts`, following the exact same Hono pattern as `globalItemRoutes`.
+
+```typescript
+// src/server/routes/discovery.ts
+import { Hono } from "hono";
+// ...
+const app = new Hono<Env>();
+app.get("/setups", async (c) => { ... });
+app.get("/items", async (c) => { ... });
+app.get("/categories", async (c) => { ... });
+export { app as discoveryRoutes };
+```
+
+```typescript
+// src/server/index.ts additions:
+// 1. Import discoveryRoutes
+// 2. Add to public skiplist (GET /api/discovery/*)
+// 3. Add browseTier rate limit for GET /api/discovery/*
+// 4. app.route("/api/discovery", discoveryRoutes)
+```
+
+### Pattern 3: Discovery React Query Hooks
+
+**What:** Single file `useDiscovery.ts` with three named exports, following the exact pattern of `useGlobalItems`.
+
+```typescript
+// src/client/hooks/useDiscovery.ts
+export interface DiscoverySetup {
+  id: number;
+  name: string;
+  createdAt: string;
+  itemCount: number;
+  // creatorName: optional — depends on whether users join is implemented
+}
+
+export interface DiscoveryCategory {
+  name: string;
+  itemCount: number;
+}
+
+export function useDiscoverySetups(limit = 6) {
+  return useQuery({
+    queryKey: ["discovery", "setups", limit],
+    queryFn: () => apiGet<{ items: DiscoverySetup[]; nextCursor: string | null }>(`/api/discovery/setups?limit=${limit}`),
+    staleTime: 2 * 60 * 1000, // 2 min — feed data, okay to be slightly stale
+  });
+}
+
+export function useDiscoveryItems(limit = 8) {
+  return useQuery({
+    queryKey: ["discovery", "items", limit],
+    queryFn: () => apiGet<{ items: GlobalItem[]; nextCursor: string | null }>(`/api/discovery/items?limit=${limit}`),
+    staleTime: 2 * 60 * 1000,
+  });
+}
+
+export function useDiscoveryCategories(limit = 12) {
+  return useQuery({
+    queryKey: ["discovery", "categories", limit],
+    queryFn: () => apiGet<DiscoveryCategory[]>(`/api/discovery/categories?limit=${limit}`),
+    staleTime: 5 * 60 * 1000, // 5 min — categories change rarely
+  });
+}
+```
+
+### Pattern 4: Landing Page Component Structure
+
+**What:** `routes/index.tsx` rewritten as `LandingPage` function. `DashboardPage` and `DashboardCard` imports removed. Three sections below the hero, each as a standalone sub-component in the same file.
+
+```typescript
+// src/client/routes/index.tsx
+export const Route = createFileRoute("/")({
+  component: LandingPage,
+});
+
+function LandingPage() {
+  const { data: auth } = useAuth();
+  const isAuthenticated = !!auth?.user;
+  const openCatalogSearch = useUIStore((s) => s.openCatalogSearch);
+
+  return (
+    <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
+      {/* Hero */}
+      <HeroSection isAuthenticated={isAuthenticated} onSearchFocus={() => openCatalogSearch("collection")} />
+      {/* Sections */}
+      <PopularSetupsSection />
+      <RecentItemsSection />
+      <TrendingCategoriesSection />
+    </div>
+  );
+}
+```
+
+### Pattern 5: Enhanced `PublicSetupCard`
+
+**What:** Add `itemCount` and optional `creatorName` to `PublicSetupCardProps`. The card currently only shows `name` and formatted date — it needs item count to be useful in a "Popular Setups" feed.
+
+```typescript
+interface PublicSetupCardProps {
+  setup: {
+    id: number;
+    name: string;
+    createdAt: string;
+    itemCount: number;       // NEW — required for popular setups feed
+    creatorName?: string;    // NEW — optional, shown if present
+  };
+}
+```
+
+**Important:** This is a non-breaking change. Existing usages of `PublicSetupCard` that pass the old shape will need to add `itemCount`. Check all usages before changing the interface.
+
+### Pattern 6: Hero Search Bar
+
+**What:** A styled `<input>` or `<div>` that calls `openCatalogSearch("collection")` on click/focus. Does NOT perform search itself — just triggers `CatalogSearchOverlay`. This aligns with D-04.
+
+```typescript
+function HeroSection({ isAuthenticated, onSearchFocus }: { isAuthenticated: boolean; onSearchFocus: () => void }) {
+  return (
+    <div className="text-center mb-12">
+      <h1 className="text-3xl font-bold text-gray-900 mb-2">Discover Gear</h1>
+      <p className="text-gray-500 mb-6">Browse what other people carry</p>
+
+      {/* Search trigger — visual only, opens overlay */}
+      <div
+        onClick={onSearchFocus}
+        className="max-w-xl mx-auto flex items-center gap-3 px-4 py-3 bg-white rounded-xl border border-gray-200 hover:border-gray-300 cursor-pointer shadow-sm transition-all"
+        role="button"
+        tabIndex={0}
+        onKeyDown={(e) => e.key === "Enter" && onSearchFocus()}
+      >
+        <SearchIcon className="w-4 h-4 text-gray-400 shrink-0" />
+        <span className="text-sm text-gray-400 flex-1 text-left">Search the catalog...</span>
+      </div>
+
+      {/* Authenticated CTA (D-10) */}
+      {isAuthenticated && (
+        <div className="mt-4">
+          <Link to="/collection" className="text-sm text-gray-600 hover:text-gray-900 underline underline-offset-2 cursor-pointer">
+            Go to Collection →
+          </Link>
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
+### Anti-Patterns to Avoid
+- **Do not build inline search results** — The search bar is a trigger only; `CatalogSearchOverlay` handles all search UI (D-04). Duplicating search logic will create state sync bugs.
+- **Do not use OFFSET pagination** — Use cursor-based pagination for all discovery endpoints (INFR-02). OFFSET degrades with large tables and can skip/duplicate rows with concurrent inserts.
+- **Do not use `auth?.authenticated` for conditional CTA** — Use `!!auth?.user` as established by `__root.tsx` pattern (`const isAuthenticated = !!auth?.user`).
+- **Do not import DashboardCard or DashboardPage in new index.tsx** — They are being retired by D-03; remove imports entirely.
+- **Do not fire-and-forget on auth check for CTA** — The `useAuth` query has `staleTime: 5 * 60 * 1000` and `retry: false`. The CTA should appear only after auth resolves (`auth?.user` is truthy), not while `isLoading`.
+
+---
+
+## Don't Hand-Roll
+
+| Problem | Don't Build | Use Instead | Why |
+|---------|-------------|-------------|-----|
+| Search UI | Custom search input with results | `CatalogSearchOverlay` + `openCatalogSearch()` | Full feature set: debounce, tags, grid/list, manual entry; D-04 |
+| Auth state | Manual JWT decode or session check | `useAuth()` hook | Caches auth state, handles race conditions |
+| Weight/price formatting | `item.weightGrams + "g"` | `useFormatters()` → `weight()`, `price()` | Handles unit conversion, null, localization |
+| Card skeleton | Custom loading spinner | `animate-pulse` Tailwind classes — match `CatalogSearchOverlay` skeleton pattern | Consistent with existing `SkeletonGrid` in `CatalogSearchOverlay` |
+| Rate limiting | New rate limit implementation | `createRateLimit(browseTier)` factory | Already handles IP extraction, cleanup, 429 responses |
+
+**Key insight:** Nearly all plumbing already exists. The work is composition, not invention.
+
+---
+
+## Common Pitfalls
+
+### Pitfall 1: `CatalogSearchOverlay` mounts at `top-[57px]`
+**What goes wrong:** The overlay is positioned `fixed inset-x-0 top-[57px]` (below the `TotalsBar` which is `h-14` = 56px). If the landing page adds any sticky element above the TotalsBar, the overlay will overlap it.
+**Why it happens:** The overlay's top offset is hardcoded to the TotalsBar height.
+**How to avoid:** Do not add sticky elements to the landing page layout outside of TotalsBar. The hero section should be part of the normal document flow.
+**Warning signs:** Overlay appears behind or over an element when opened from landing page.
+
+### Pitfall 2: `isDashboard` detection in `__root.tsx`
+**What goes wrong:** `__root.tsx` has `const isDashboard = !!matchRoute({ to: "/" })`. This controls whether `TotalsBar` shows a `linkTo` prop (back link). If the new landing page keeps the `/` route, `isDashboard` will remain `true` and `TotalsBar` will render its title as a non-link — which is correct behavior (already handled).
+**Why it happens:** No change needed, but worth knowing so it's not "fixed" accidentally.
+**How to avoid:** Leave `isDashboard` logic in `__root.tsx` unchanged.
+
+### Pitfall 3: `PublicSetupCard` interface change breaks existing usages
+**What goes wrong:** If `itemCount` is made required in `PublicSetupCardProps`, any existing usage that doesn't pass it will cause a TypeScript error.
+**Why it happens:** The card is used in at least the public setup profile page.
+**How to avoid:** Check all usages of `PublicSetupCard` before adding `itemCount` as required. Consider adding it as optional (`itemCount?: number`) with a fallback display.
+**Warning signs:** TypeScript errors on `PublicSetupCard` usages in other files.
+
+### Pitfall 4: Discovery endpoint auth allowlist
+**What goes wrong:** New `GET /api/discovery/*` endpoints return 401 for anonymous users because the auth skip list in `server/index.ts` doesn't include them.
+**Why it happens:** The auth middleware at line 151-170 of `server/index.ts` skips specific paths by prefix check. New paths must be explicitly added.
+**How to avoid:** Add this skip condition to `server/index.ts`:
+```typescript
+if (c.req.path.startsWith("/api/discovery") && c.req.method === "GET")
+  return next();
+```
+**Warning signs:** Anonymous page load shows empty sections or 401 errors in browser network tab.
+
+### Pitfall 5: Trending categories — `globalItems.category` is nullable
+**What goes wrong:** SQL `GROUP BY globalItems.category` will include a `null` group if some items have no category set. This null group may appear in "Trending Categories" and render as an empty/broken category chip.
+**Why it happens:** `category` column is `text` nullable in schema.
+**How to avoid:** Add `WHERE globalItems.category IS NOT NULL` to the trending categories query.
+**Warning signs:** Category section shows an empty/blank chip.
+
+### Pitfall 6: Creator name requires users join (scope risk)
+**What goes wrong:** D-02 says setups show "creator names". But `setups` table only has `userId` — getting `displayName` requires joining `users` table. If `users.displayName` is null (common for new accounts), the join returns null.
+**Why it happens:** User display names are optional in the schema.
+**How to avoid:** Join users in `getPopularSetups` query and return `creatorName: users.displayName ?? null`. In the card, render creator name only when non-null (e.g., "by Jean-Luc" or omit entirely). Mark `creatorName` as optional in the TS interface.
+**Warning signs:** Crashes on `.toLocaleLowerCase()` or similar when `creatorName` is null.
+
+---
+
+## Code Examples
+
+### Drizzle: Trending categories query
+```typescript
+// Source: Drizzle docs + codebase patterns in global-item.service.ts
+import { count, desc, isNotNull, groupBy } from "drizzle-orm";
+
+export async function getTrendingCategories(db: Db, limit = 12) {
+  return db
+    .select({
+      name: globalItems.category,
+      itemCount: count(globalItems.id),
+    })
+    .from(globalItems)
+    .where(isNotNull(globalItems.category))
+    .groupBy(globalItems.category)
+    .orderBy(desc(count(globalItems.id)))
+    .limit(limit);
+}
+// Returns: Array<{ name: string; itemCount: number }>
+```
+
+### Drizzle: Popular setups with item count
+```typescript
+// Source: Drizzle docs — leftJoin + groupBy + count
+import { count, desc, eq } from "drizzle-orm";
+
+export async function getPopularSetups(db: Db, limit = 6) {
+  return db
+    .select({
+      id: setups.id,
+      name: setups.name,
+      createdAt: setups.createdAt,
+      itemCount: count(setupItems.id),
+      creatorName: users.displayName,
+    })
+    .from(setups)
+    .leftJoin(setupItems, eq(setupItems.setupId, setups.id))
+    .leftJoin(users, eq(users.id, setups.userId))
+    .where(eq(setups.isPublic, true))
+    .groupBy(setups.id, setups.name, setups.createdAt, users.displayName)
+    .orderBy(desc(count(setupItems.id)), desc(setups.id))
+    .limit(limit);
+}
+```
+
+### Cursor response shape (consistent across all three endpoints)
+```typescript
+// Applied to /api/discovery/items and /api/discovery/setups
+interface CursorPage<T> {
+  items: T[];
+  nextCursor: string | null;
+  hasMore: boolean;
+}
+
+// Usage in route handler:
+const rows = await getRecentGlobalItems(db, limit + 1, cursor);
+const hasMore = rows.length > limit;
+const sliced = hasMore ? rows.slice(0, limit) : rows;
+const nextCursor = hasMore
+  ? sliced[sliced.length - 1].createdAt.toISOString()
+  : null;
+return c.json({ items: sliced, nextCursor, hasMore });
+```
+
+### Section skeleton pattern (matches existing `CatalogSearchOverlay` style)
+```typescript
+// Reuse the animate-pulse pattern from CatalogSearchOverlay.tsx
+function SectionSkeleton({ count = 6 }: { count?: number }) {
+  return (
+    <div className="grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-4 gap-4">
+      {Array.from({ length: count }).map((_, i) => (
+        <div key={i} className="bg-white rounded-xl border border-gray-100 overflow-hidden animate-pulse">
+          <div className="aspect-[4/3] bg-gray-100" />
+          <div className="p-4 space-y-2">
+            <div className="h-3 bg-gray-100 rounded w-16" />
+            <div className="h-4 bg-gray-100 rounded w-32" />
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}
+```
+
+---
+
+## State of the Art
+
+| Old Approach | Current Approach | When Changed | Impact |
+|--------------|------------------|--------------|--------|
+| Offset pagination (`LIMIT x OFFSET y`) | Cursor pagination (`WHERE createdAt < cursor`) | INFR-02 decision | Stable results, better performance at scale |
+| Personal dashboard as `/` | Public discovery landing as `/` | D-03 (this phase) | New visitors see content, not a login gate |
+| `PublicSetupCard` shows name + date only | Enhanced card adds item count + creator name | This phase | Sufficient context to judge "popular" setup quality |
+
+**Deprecated/outdated:**
+- `DashboardPage` function in `index.tsx`: retired by D-03; file is rewritten, component removed
+- `DashboardCard` component: no longer rendered from `/`; not deleted (may be useful elsewhere) but imports removed from `index.tsx`
+
+---
+
+## Environment Availability
+
+Step 2.6: SKIPPED — This phase is purely client/server code changes within the existing project stack. No new external tools, services, runtimes, or CLI utilities are required beyond what's already installed (`bun`, `node`, PostgreSQL).
+
+---
+
+## Validation Architecture
+
+### Test Framework
+| Property | Value |
+|----------|-------|
+| Framework | Bun test runner (built-in) |
+| Config file | none — `bun test` auto-discovers `*.test.ts` |
+| Quick run command | `bun test tests/services/discovery.service.test.ts` |
+| Full suite command | `bun test` |
+
+### Phase Requirements → Test Map
+| Req ID | Behavior | Test Type | Automated Command | File Exists? |
+|--------|----------|-----------|-------------------|-------------|
+| DISC-01 | Hero search bar renders; clicking triggers CatalogSearchOverlay | smoke | E2E only — overlay integration | ❌ Wave 0 (E2E) |
+| DISC-02 | `getPopularSetups` returns public setups ordered by item count desc | unit | `bun test tests/services/discovery.service.test.ts` | ❌ Wave 0 |
+| DISC-02 | `GET /api/discovery/setups` returns 200 for anonymous requests | integration | `bun test tests/routes/discovery.test.ts` | ❌ Wave 0 |
+| DISC-03 | `getRecentGlobalItems` returns items ordered by createdAt desc | unit | `bun test tests/services/discovery.service.test.ts` | ❌ Wave 0 |
+| DISC-03 | `GET /api/discovery/items` returns 200 for anonymous requests | integration | `bun test tests/routes/discovery.test.ts` | ❌ Wave 0 |
+| DISC-04 | `getTrendingCategories` excludes null categories, orders by count | unit | `bun test tests/services/discovery.service.test.ts` | ❌ Wave 0 |
+| DISC-04 | `GET /api/discovery/categories` returns 200 for anonymous requests | integration | `bun test tests/routes/discovery.test.ts` | ❌ Wave 0 |
+| DISC-05 | "Go to Collection" link absent for anonymous, present for authenticated | smoke | E2E only — requires auth session | ❌ Wave 0 (E2E) |
+| INFR-02 | Cursor pagination: second page excludes items from first page | unit | `bun test tests/services/discovery.service.test.ts` | ❌ Wave 0 |
+
+### Sampling Rate
+- **Per task commit:** `bun test tests/services/discovery.service.test.ts tests/routes/discovery.test.ts`
+- **Per wave merge:** `bun test`
+- **Phase gate:** Full suite green before `/gsd:verify-work`
+
+### Wave 0 Gaps
+- [ ] `tests/services/discovery.service.test.ts` — covers DISC-02, DISC-03, DISC-04, INFR-02 (service layer)
+- [ ] `tests/routes/discovery.test.ts` — covers DISC-02, DISC-03, DISC-04 route layer; anonymous access
+- [ ] `src/server/routes/discovery.ts` — new route file (Wave 0 stub before tests)
+- [ ] `src/server/services/discovery.service.ts` — new service file (Wave 0 stub before tests)
+- [ ] `src/client/hooks/useDiscovery.ts` — new hooks file
+
+---
+
+## Open Questions
+
+1. **Creator name display in popular setups feed**
+   - What we know: `setups.userId` exists; `users.displayName` is nullable text
+   - What's unclear: How many users have null `displayName` (could be most in early data)
+   - Recommendation: Render "by {name}" only when `creatorName` is non-null; show nothing otherwise. Do not fall back to email (privacy concern).
+
+2. **"View all" link destinations for setups and items**
+   - What we know: Claude's Discretion says this is unresolved
+   - What's unclear: No dedicated `/catalog` browse page or `/setups` public listing page exists yet
+   - Recommendation: "View all" for items links to `/global-items` (existing catalog page). "View all" for setups can be omitted for v1 of this page if no public setups listing page exists. Verify that `/global-items` route exists as a valid destination.
+
+3. **Cursor pagination for `categories` endpoint**
+   - What we know: INFR-02 requires cursor pagination for discovery feed; categories are ranked by count
+   - What's unclear: Categories list will be small (10-50 items max in early data); cursor pagination may be over-engineering for categories
+   - Recommendation: Use `limit` param for categories without cursor (no pagination). Categories don't grow unboundedly and the full list is small. Use cursor only for `setups` and `items` as decision D-08 specifies.
+
+---
+
+## Sources
+
+### Primary (HIGH confidence)
+- Codebase direct read — `src/server/routes/global-items.ts`, `src/server/services/global-item.service.ts`, `src/db/schema.ts`, `src/server/index.ts`, `src/client/routes/__root.tsx`, `src/client/stores/uiStore.ts`, `src/client/components/CatalogSearchOverlay.tsx`, `src/client/components/GlobalItemCard.tsx`, `src/client/components/PublicSetupCard.tsx`
+- CONTEXT.md — Locked decisions D-01 through D-11
+- CLAUDE.md — Project stack, patterns, reusable component guidelines
+
+### Secondary (MEDIUM confidence)
+- Drizzle ORM standard patterns for `leftJoin`, `groupBy`, `count`, `desc` — consistent with existing codebase usage
+
+### Tertiary (LOW confidence)
+- None
+
+---
+
+## Metadata
+
+**Confidence breakdown:**
+- Standard stack: HIGH — all in project, no new deps
+- Architecture patterns: HIGH — based on direct codebase reads, locked decisions
+- Pitfalls: HIGH — derived from actual code inspection (nullable category, auth allowlist gaps, interface changes)
+- Validation approach: HIGH — matches existing test patterns in `tests/services/` and `tests/routes/`
+
+**Research date:** 2026-04-10
+**Valid until:** 2026-05-10 (stable stack, no fast-moving dependencies)
--- a/.planning/phases/26-discovery-landing-page/26-VALIDATION.md
+++ b/.planning/phases/26-discovery-landing-page/26-VALIDATION.md
@@ -0,0 +1,85 @@
+---
+phase: 26
+slug: discovery-landing-page
+status: draft
+nyquist_compliant: false
+wave_0_complete: false
+created: 2026-04-10
+---
+
+# Phase 26 — Validation Strategy
+
+> Per-phase validation contract for feedback sampling during execution.
+
+---
+
+## Test Infrastructure
+
+| Property | Value |
+|----------|-------|
+| **Framework** | Bun test runner (built-in) |
+| **Config file** | none — `bun test` auto-discovers `*.test.ts` |
+| **Quick run command** | `bun test tests/services/discovery.service.test.ts tests/routes/discovery.test.ts` |
+| **Full suite command** | `bun test` |
+| **Estimated runtime** | ~15 seconds |
+
+---
+
+## Sampling Rate
+
+- **After every task commit:** Run `bun test tests/services/discovery.service.test.ts tests/routes/discovery.test.ts`
+- **After every plan wave:** Run `bun test`
+- **Before `/gsd:verify-work`:** Full suite must be green
+- **Max feedback latency:** 15 seconds
+
+---
+
+## Per-Task Verification Map
+
+| Task ID | Plan | Wave | Requirement | Test Type | Automated Command | File Exists | Status |
+|---------|------|------|-------------|-----------|-------------------|-------------|--------|
+| 26-01-01 | 01 | 1 | DISC-02 | unit | `bun test tests/services/discovery.service.test.ts` | ❌ W0 | ⬜ pending |
+| 26-01-02 | 01 | 1 | DISC-03 | unit | `bun test tests/services/discovery.service.test.ts` | ❌ W0 | ⬜ pending |
+| 26-01-03 | 01 | 1 | DISC-04 | unit | `bun test tests/services/discovery.service.test.ts` | ❌ W0 | ⬜ pending |
+| 26-01-04 | 01 | 1 | INFR-02 | unit | `bun test tests/services/discovery.service.test.ts` | ❌ W0 | ⬜ pending |
+| 26-01-05 | 01 | 1 | DISC-02 | integration | `bun test tests/routes/discovery.test.ts` | ❌ W0 | ⬜ pending |
+| 26-01-06 | 01 | 1 | DISC-03 | integration | `bun test tests/routes/discovery.test.ts` | ❌ W0 | ⬜ pending |
+| 26-01-07 | 01 | 1 | DISC-04 | integration | `bun test tests/routes/discovery.test.ts` | ❌ W0 | ⬜ pending |
+| 26-02-01 | 02 | 2 | DISC-01 | smoke | E2E only — overlay integration | ❌ E2E | ⬜ pending |
+| 26-02-02 | 02 | 2 | DISC-05 | smoke | E2E only — requires auth session | ❌ E2E | ⬜ pending |
+
+*Status: ⬜ pending · ✅ green · ❌ red · ⚠️ flaky*
+
+---
+
+## Wave 0 Requirements
+
+- [ ] `tests/services/discovery.service.test.ts` — stubs for DISC-02, DISC-03, DISC-04, INFR-02
+- [ ] `tests/routes/discovery.test.ts` — stubs for DISC-02, DISC-03, DISC-04 route layer
+- [ ] `src/server/services/discovery.service.ts` — new service file (stub)
+- [ ] `src/server/routes/discovery.ts` — new route file (stub)
+
+*Existing infrastructure covers test helpers (createTestDb, in-memory Postgres via PGlite).*
+
+---
+
+## Manual-Only Verifications
+
+| Behavior | Requirement | Why Manual | Test Instructions |
+|----------|-------------|------------|-------------------|
+| Hero search bar triggers CatalogSearchOverlay | DISC-01 | Client interaction; E2E pending rewrite (999.1) | Load `/`, click search bar, verify overlay opens |
+| "Go to Collection" CTA visible for authenticated users | DISC-05 | Requires auth session; E2E pending rewrite | Log in, visit `/`, verify CTA present |
+| "Go to Collection" CTA absent for anonymous | DISC-05 | Requires anonymous session | Open incognito, visit `/`, verify no CTA |
+
+---
+
+## Validation Sign-Off
+
+- [ ] All tasks have `<automated>` verify or Wave 0 dependencies
+- [ ] Sampling continuity: no 3 consecutive tasks without automated verify
+- [ ] Wave 0 covers all MISSING references
+- [ ] No watch-mode flags
+- [ ] Feedback latency < 15s
+- [ ] `nyquist_compliant: true` set in frontmatter
+
+**Approval:** pending
--- a/.planning/phases/26-discovery-landing-page/26-VERIFICATION.md
+++ b/.planning/phases/26-discovery-landing-page/26-VERIFICATION.md
@@ -0,0 +1,147 @@
+---
+phase: 26-discovery-landing-page
+verified: 2026-04-10T14:00:00Z
+status: passed
+score: 12/12 must-haves verified
+re_verification: false
+gaps: []
+human_verification:
+  - test: "Visual: Hero section and search bar appearance"
+    expected: "Centered 'Discover Gear' heading, subtitle, styled search bar with magnifier icon, no login redirect for anonymous user"
+    why_human: "Cannot verify visual rendering programmatically"
+  - test: "Interaction: Click search bar opens CatalogSearchOverlay"
+    expected: "Clicking or pressing Enter on the search bar div triggers openCatalogSearch('collection') and the overlay slides in"
+    why_human: "Requires browser interaction — unit tests don't cover overlay mount trigger"
+  - test: "Auth-conditional CTA: 'Go to Collection' visible only when authenticated"
+    expected: "Logged-in user sees 'Go to Collection' link; anonymous user does not"
+    why_human: "Requires live auth session to confirm conditional rendering"
+  - test: "Responsive layout at mobile width"
+    expected: "Single-column grid for Popular Setups; 2-column for Recently Added on narrow viewport"
+    why_human: "CSS grid breakpoints require visual verification"
+---
+
+# Phase 26: Discovery Landing Page Verification Report
+
+**Phase Goal:** The app opens to a public discovery feed with prominent catalog search, not a personal dashboard
+**Verified:** 2026-04-10T14:00:00Z
+**Status:** passed
+**Re-verification:** No — initial verification
+
+## Goal Achievement
+
+### Observable Truths
+
+| # | Truth | Status | Evidence |
+|---|-------|--------|---------|
+| 1 | `getPopularSetups` returns public setups ordered by item count descending | VERIFIED | Service file line 45: `eq(setups.isPublic, true)`, ordered by `COUNT(setupItems.id) DESC`; 11/11 service tests pass |
+| 2 | `getRecentGlobalItems` returns items ordered by createdAt descending | VERIFIED | Service file line 92: `.orderBy(desc(globalItems.createdAt))`; tests pass |
+| 3 | `getTrendingCategories` returns categories ordered by item count, excluding nulls | VERIFIED | Service file line 121: `isNotNull(globalItems.category)`, `orderBy(desc(count(...)))`; tests pass |
+| 4 | Cursor pagination returns next page without duplicates | VERIFIED | Composite `itemCount_id` cursor for setups (JS post-filter); ISO timestamp cursor for items; both tested with deduplication assertions |
+| 5 | GET /api/discovery/setups returns popular setups for anonymous users | VERIFIED | Route registered at line 190 of index.ts; auth skip at line 170-171; 10/10 route tests pass |
+| 6 | GET /api/discovery/items returns recent catalog items for anonymous users | VERIFIED | Route handler at lines 21-28 of discovery.ts; anonymous test passes without userId |
+| 7 | GET /api/discovery/categories returns trending categories for anonymous users | VERIFIED | Route handler at lines 30-36 of discovery.ts; anonymous test passes |
+| 8 | All discovery endpoints accept limit and cursor query params | VERIFIED | Routes parse `limit` and `cursor` query params with parseInt and Math.min cap at 50 |
+| 9 | Discovery endpoints are rate-limited with browseTier | VERIFIED | index.ts lines 127-130: `app.use("/api/discovery/*", ...)` applies `browseTier` for all GET requests |
+| 10 | Root URL shows a hero section with a catalog search bar | VERIFIED | index.tsx contains `function HeroSection(` with search div, `cursor-pointer`, Search icon |
+| 11 | Clicking the search bar opens CatalogSearchOverlay | VERIFIED (wiring) | `openCatalogSearch("collection")` called in `onSearchFocus`; CatalogSearchOverlay reads `catalogSearchOpen` from same uiStore and is mounted in `__root.tsx` line 175 |
+| 12 | Authenticated users see "Go to Collection" link in hero | VERIFIED | `!!auth?.user` guard at line 60 of index.tsx; Link to `/collection` rendered conditionally |
+
+**Score:** 12/12 truths verified
+
+### Required Artifacts
+
+| Artifact | Expected | Status | Details |
+|----------|----------|--------|---------|
+| `src/server/services/discovery.service.ts` | Discovery feed queries with cursor pagination | VERIFIED | 131 lines; exports `getPopularSetups`, `getRecentGlobalItems`, `getTrendingCategories`; real Drizzle queries against `globalItems`, `setups`, `setupItems`, `users` |
+| `tests/services/discovery.service.test.ts` | Unit tests for all three service functions | VERIFIED | 247 lines (min_lines: 100 satisfied); 11 it() calls; 3 describe blocks; all pass |
+| `src/server/routes/discovery.ts` | Hono route handlers for three discovery endpoints | VERIFIED | Exports `discoveryRoutes`; 3 GET handlers for `/setups`, `/items`, `/categories`; imports from discovery.service |
+| `src/client/hooks/useDiscovery.ts` | React Query hooks for landing page data fetching | VERIFIED | Exports `useDiscoverySetups`, `useDiscoveryItems`, `useDiscoveryCategories` and interfaces `DiscoverySetup`, `DiscoveryCategory` |
+| `tests/routes/discovery.test.ts` | Route-level integration tests | VERIFIED | 241 lines (min_lines: 50 satisfied); 10 it() calls; all pass |
+| `src/client/routes/index.tsx` | Landing page with hero, popular setups, recent items, trending categories | VERIFIED | 192 lines (min_lines: 80 satisfied); contains `LandingPage`, `HeroSection`, `PopularSetupsSection`, `RecentItemsSection`, `TrendingCategoriesSection`; no DashboardPage/DashboardCard/useTotals remnants |
+| `src/client/components/PublicSetupCard.tsx` | Enhanced setup card with optional itemCount and creatorName | VERIFIED | Contains `itemCount?: number`, `creatorName?: string \| null`; renders both conditionally; `cursor-pointer` applied |
+
+### Key Link Verification
+
+| From | To | Via | Status | Details |
+|------|----|-----|--------|---------|
+| `src/server/routes/discovery.ts` | `src/server/services/discovery.service.ts` | imports `getPopularSetups`, `getRecentGlobalItems`, `getTrendingCategories` | WIRED | Lines 1-6 of discovery.ts import all three service functions |
+| `src/server/index.ts` | `src/server/routes/discovery.ts` | `app.route("/api/discovery", discoveryRoutes)` | WIRED | Line 16: import; line 127: rate limit; line 170: auth skip; line 190: route registration |
+| `src/client/hooks/useDiscovery.ts` | `/api/discovery` | `apiGet` fetch calls | WIRED | Lines 42-44, 52-54, 61-63 call `apiGet` with `/api/discovery/setups`, `/api/discovery/items`, `/api/discovery/categories` |
+| `src/client/routes/index.tsx` | `src/client/hooks/useDiscovery.ts` | imports all three hooks | WIRED | Lines 7-10 import all three hooks; used in `PopularSetupsSection`, `RecentItemsSection`, `TrendingCategoriesSection` |
+| `src/client/routes/index.tsx` | `src/client/stores/uiStore.ts` | `openCatalogSearch` trigger from hero | WIRED | Line 20: `useUIStore((s) => s.openCatalogSearch)`; line 26: called on search focus |
+| `src/client/routes/index.tsx` | `src/client/hooks/useAuth.ts` | auth state for conditional CTA | WIRED | Line 5: import; line 18: `useAuth()`; line 19: `!!auth?.user` |
+| `src/client/routes/index.tsx` | `src/client/components/GlobalItemCard.tsx` | renders catalog items | WIRED | Line 3: import; lines 114-121: rendered in `RecentItemsSection` |
+| `src/client/routes/index.tsx` | `src/client/components/PublicSetupCard.tsx` | renders setup cards | WIRED | Line 4: import; line 90: rendered in `PopularSetupsSection` |
+
+### Data-Flow Trace (Level 4)
+
+| Artifact | Data Variable | Source | Produces Real Data | Status |
+|----------|---------------|--------|--------------------|--------|
+| `src/client/routes/index.tsx` (PopularSetupsSection) | `data?.items` from `useDiscoverySetups` | `apiGet('/api/discovery/setups')` → `getPopularSetups` → Drizzle JOIN on `setups`/`setupItems`/`users` | Yes — real DB SELECT with COUNT | FLOWING |
+| `src/client/routes/index.tsx` (RecentItemsSection) | `data?.items` from `useDiscoveryItems` | `apiGet('/api/discovery/items')` → `getRecentGlobalItems` → Drizzle SELECT on `globalItems` | Yes — real DB SELECT ORDER BY createdAt | FLOWING |
+| `src/client/routes/index.tsx` (TrendingCategoriesSection) | `data` from `useDiscoveryCategories` | `apiGet('/api/discovery/categories')` → `getTrendingCategories` → Drizzle GROUP BY on `globalItems` | Yes — real DB SELECT GROUP BY category | FLOWING |
+
+### Behavioral Spot-Checks
+
+| Behavior | Command | Result | Status |
+|----------|---------|--------|--------|
+| Service tests pass | `bun test tests/services/discovery.service.test.ts` | 11 pass, 0 fail | PASS |
+| Route tests pass | `bun test tests/routes/discovery.test.ts` | 10 pass, 0 fail | PASS |
+| Client build succeeds | `bun run build` | Built in 625ms, no TypeScript errors | PASS |
+| Full test suite (regression) | `bun test` | 285 pass, 15 fail — all 15 failures are pre-existing `storage.service.ts` export issue, unrelated to phase 26 | PASS (no regressions) |
+| Old dashboard code removed | `grep DashboardPage/DashboardCard/useTotals index.tsx` | No matches | PASS |
+
+### Requirements Coverage
+
+| Requirement | Source Plan | Description | Status | Evidence |
+|-------------|-------------|-------------|--------|---------|
+| DISC-01 | 26-03 | Landing page displays an always-visible catalog search bar at the top | SATISFIED | `HeroSection` in `index.tsx` contains search bar div with Search icon; no auth gate on the landing page |
+| DISC-02 | 26-01, 26-02, 26-03 | Landing page shows a feed of popular setups below the search | SATISFIED | `PopularSetupsSection` renders `PublicSetupCard` grid from `useDiscoverySetups`; backed by `getPopularSetups` service |
+| DISC-03 | 26-01, 26-02, 26-03 | Landing page shows recently added catalog items | SATISFIED | `RecentItemsSection` renders `GlobalItemCard` grid from `useDiscoveryItems`; backed by `getRecentGlobalItems` service |
+| DISC-04 | 26-01, 26-02, 26-03 | Landing page shows trending categories | SATISFIED | `TrendingCategoriesSection` renders category pills from `useDiscoveryCategories`; backed by `getTrendingCategories` service |
+| DISC-05 | 26-03 | Authenticated users see a "Go to Collection" entry point from the landing page | SATISFIED | `!!auth?.user` conditional in `HeroSection` renders `<Link to="/collection">Go to Collection</Link>` |
+| INFR-02 | 26-01, 26-02 | Discovery feed endpoint uses cursor pagination for scalability | SATISFIED | `getPopularSetups` (composite `itemCount_id` cursor) and `getRecentGlobalItems` (ISO timestamp cursor) both implement cursor pagination with `hasMore`/`nextCursor`; categories use simple limit (bounded list, acceptable per RESEARCH.md) |
+
+No orphaned requirements — all 6 IDs (DISC-01 through DISC-05, INFR-02) appear in at least one plan's `requirements` field and are fully implemented.
+
+### Anti-Patterns Found
+
+| File | Line | Pattern | Severity | Impact |
+|------|------|---------|----------|--------|
+| `src/client/routes/index.tsx` | 78, 102, 135 | `return null` when no data | Info | Intentional empty-state handling per plan spec — sections hide when no data, not a stub |
+
+No blockers. The `return null` patterns are intentional design decisions documented in the plan and summaries: sections hide themselves when not loading and data is empty.
+
+### Human Verification Required
+
+#### 1. Visual appearance of landing page
+
+**Test:** Run `bun run dev`, open `http://localhost:5173/` in a browser
+**Expected:** Hero section centered with "Discover Gear" heading, subtitle "Browse what other people carry", styled search bar with magnifier icon. Three sections below if data exists. No redirect to login.
+**Why human:** Visual rendering cannot be verified programmatically.
+
+#### 2. Search bar triggers CatalogSearchOverlay
+
+**Test:** Click the search bar div or press Enter while focused on it
+**Expected:** The CatalogSearchOverlay slides in (full-screen or modal), ready to search the catalog
+**Why human:** Requires browser click event to trigger; wiring is confirmed in code but overlay animation/render requires visual confirmation.
+
+#### 3. "Go to Collection" CTA conditional on auth state
+
+**Test:** While logged out verify no CTA; after logging in verify "Go to Collection" appears in hero area and navigates to `/collection`
+**Why human:** Requires live Logto OIDC session to test the `auth?.user` condition.
+
+#### 4. Responsive layout at mobile width
+
+**Test:** Resize browser to 375px width; verify Popular Setups shows 1 column, Recently Added shows 2 columns
+**Expected:** Tailwind sm: breakpoints kick in correctly at responsive widths
+**Why human:** CSS grid breakpoint behavior requires visual inspection.
+
+### Gaps Summary
+
+No gaps. All 12 truths verified. All artifacts exist, are substantive, wired, and have confirmed data flow paths. Both test suites pass. Build succeeds. The 15 pre-existing test failures are all caused by a `storage.service.ts` export naming issue documented in earlier summaries as pre-existing — none are from phase 26 code.
+
+---
+
+_Verified: 2026-04-10T14:00:00Z_
+_Verifier: Claude (gsd-verifier)_
--- a/src/client/components/PublicSetupCard.tsx
+++ b/src/client/components/PublicSetupCard.tsx
@@ -5,6 +5,8 @@ interface PublicSetupCardProps {
 		id: number;
 		name: string;
 		createdAt: string;
+		itemCount?: number;
+		creatorName?: string | null;
 	};
 }

@@ -22,12 +24,24 @@ export function PublicSetupCard({ setup }: PublicSetupCardProps) {
 		<Link
 			to="/setups/$setupId"
 			params={{ setupId: String(setup.id) }}
-			className="block bg-white rounded-xl border border-gray-100 hover:border-gray-200 hover:shadow-md transition-all p-4"
+			className="block bg-white rounded-xl border border-gray-100 hover:border-gray-200 hover:shadow-md transition-all p-4 cursor-pointer"
 		>
 			<h3 className="text-sm font-semibold text-gray-900 truncate">
 				{setup.name}
 			</h3>
-			<p className="text-xs text-gray-400 mt-1">{formattedDate}</p>
+			{setup.creatorName && (
+				<p className="text-xs text-gray-400 mt-0.5">by {setup.creatorName}</p>
+			)}
+			<div className="flex items-center justify-between mt-2">
+				<div className="flex items-center gap-2">
+					{setup.itemCount != null && setup.itemCount > 0 && (
+						<span className="inline-flex items-center px-2 py-0.5 rounded-full text-xs font-medium bg-blue-50 text-blue-400">
+							{setup.itemCount} {setup.itemCount === 1 ? "item" : "items"}
+						</span>
+					)}
+				</div>
+				<p className="text-xs text-gray-400">{formattedDate}</p>
+			</div>
 		</Link>
 	);
 }
--- a/src/client/hooks/useDiscovery.ts
+++ b/src/client/hooks/useDiscovery.ts
@@ -0,0 +1,65 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiGet } from "../lib/api";
+
+export interface DiscoverySetup {
+	id: number;
+	name: string;
+	createdAt: string;
+	itemCount: number;
+	creatorName: string | null;
+}
+
+export interface DiscoveryCategory {
+	name: string;
+	itemCount: number;
+}
+
+interface GlobalItem {
+	id: number;
+	brand: string;
+	model: string;
+	category: string | null;
+	weightGrams: number | null;
+	priceCents: number | null;
+	imageUrl: string | null;
+	description: string | null;
+	sourceUrl: string | null;
+	imageCredit: string | null;
+	imageSourceUrl: string | null;
+	createdAt: string;
+}
+
+interface CursorPage<T> {
+	items: T[];
+	nextCursor: string | null;
+	hasMore: boolean;
+}
+
+export function useDiscoverySetups(limit = 6) {
+	return useQuery({
+		queryKey: ["discovery", "setups", limit],
+		queryFn: () =>
+			apiGet<CursorPage<DiscoverySetup>>(
+				`/api/discovery/setups?limit=${limit}`,
+			),
+		staleTime: 2 * 60 * 1000,
+	});
+}
+
+export function useDiscoveryItems(limit = 8) {
+	return useQuery({
+		queryKey: ["discovery", "items", limit],
+		queryFn: () =>
+			apiGet<CursorPage<GlobalItem>>(`/api/discovery/items?limit=${limit}`),
+		staleTime: 2 * 60 * 1000,
+	});
+}
+
+export function useDiscoveryCategories(limit = 12) {
+	return useQuery({
+		queryKey: ["discovery", "categories", limit],
+		queryFn: () =>
+			apiGet<DiscoveryCategory[]>(`/api/discovery/categories?limit=${limit}`),
+		staleTime: 5 * 60 * 1000,
+	});
+}
--- a/src/client/routes/index.tsx
+++ b/src/client/routes/index.tsx
@@ -1,61 +1,191 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { DashboardCard } from "../components/DashboardCard";
-import { useFormatters } from "../hooks/useFormatters";
-import { useSetups } from "../hooks/useSetups";
-import { useThreads } from "../hooks/useThreads";
-import { useTotals } from "../hooks/useTotals";
+import { createFileRoute, Link } from "@tanstack/react-router";
+import { Search } from "lucide-react";
+import { GlobalItemCard } from "../components/GlobalItemCard";
+import { PublicSetupCard } from "../components/PublicSetupCard";
+import { useAuth } from "../hooks/useAuth";
+import {
+	useDiscoveryCategories,
+	useDiscoveryItems,
+	useDiscoverySetups,
+} from "../hooks/useDiscovery";
+import { useUIStore } from "../stores/uiStore";

 export const Route = createFileRoute("/")({
-	component: DashboardPage,
+	component: LandingPage,
 });

-function DashboardPage() {
-	const { data: totals } = useTotals();
-	const { data: threads } = useThreads(false);
-	const { data: setups } = useSetups();
-	const { weight, price } = useFormatters();
-
-	const global = totals?.global;
-	const activeThreadCount = threads?.length ?? 0;
-	const setupCount = setups?.length ?? 0;
+function LandingPage() {
+	const { data: auth } = useAuth();
+	const isAuthenticated = !!auth?.user;
+	const openCatalogSearch = useUIStore((s) => s.openCatalogSearch);

 	return (
 		<div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
-			<div className="grid grid-cols-1 md:grid-cols-3 gap-6">
-				<DashboardCard
-					to="/collection"
-					title="Collection"
-					icon="backpack"
-					stats={[
-						{ label: "Items", value: String(global?.itemCount ?? 0) },
-						{
-							label: "Weight",
-							value: weight(global?.totalWeight ?? null),
-						},
-						{
-							label: "Cost",
-							value: price(global?.totalCost ?? null),
-						},
-					]}
-					emptyText="Get started"
-				/>
-				<DashboardCard
-					to="/collection"
-					search={{ tab: "planning" }}
-					title="Planning"
-					icon="search"
-					stats={[
-						{ label: "Active threads", value: String(activeThreadCount) },
-					]}
-				/>
-				<DashboardCard
-					to="/collection"
-					search={{ tab: "setups" }}
-					title="Setups"
-					icon="tent"
-					stats={[{ label: "Setups", value: String(setupCount) }]}
-				/>
-			</div>
+			<HeroSection
+				isAuthenticated={isAuthenticated}
+				onSearchFocus={() => openCatalogSearch("collection")}
+			/>
+			<PopularSetupsSection />
+			<RecentItemsSection />
+			<TrendingCategoriesSection />
+		</div>
+	);
+}
+
+function HeroSection({
+	isAuthenticated,
+	onSearchFocus,
+}: {
+	isAuthenticated: boolean;
+	onSearchFocus: () => void;
+}) {
+	return (
+		<div className="text-center mb-16">
+			<h1 className="text-3xl sm:text-4xl font-bold text-gray-900 mb-2">
+				Discover Gear
+			</h1>
+			<p className="text-gray-500 mb-8">Browse what other people carry</p>
+			<div
+				onClick={onSearchFocus}
+				onKeyDown={(e) => e.key === "Enter" && onSearchFocus()}
+				role="button"
+				tabIndex={0}
+				className="max-w-xl mx-auto flex items-center gap-3 px-4 py-3 bg-white rounded-xl border border-gray-200 hover:border-gray-300 cursor-pointer shadow-sm transition-all"
+			>
+				<Search className="w-5 h-5 text-gray-400 shrink-0" />
+				<span className="text-sm text-gray-400 flex-1 text-left">
+					Search the catalog...
+				</span>
+			</div>
+			{isAuthenticated && (
+				<div className="mt-4">
+					<Link
+						to="/collection"
+						className="text-sm text-gray-600 hover:text-gray-900 underline underline-offset-2 cursor-pointer"
+					>
+						Go to Collection
+					</Link>
+				</div>
+			)}
+		</div>
+	);
+}
+
+function PopularSetupsSection() {
+	const { data, isLoading } = useDiscoverySetups(6);
+	const setups = data?.items ?? [];
+
+	if (!isLoading && setups.length === 0) return null;
+
+	return (
+		<section className="mb-12">
+			<div className="flex items-center justify-between mb-4">
+				<h2 className="text-lg font-semibold text-gray-900">Popular Setups</h2>
+			</div>
+			{isLoading ? (
+				<SectionSkeleton count={6} aspect="none" />
+			) : (
+				<div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
+					{setups.map((setup) => (
+						<PublicSetupCard key={setup.id} setup={setup} />
+					))}
+				</div>
+			)}
+		</section>
+	);
+}
+
+function RecentItemsSection() {
+	const { data, isLoading } = useDiscoveryItems(8);
+	const items = data?.items ?? [];
+
+	if (!isLoading && items.length === 0) return null;
+
+	return (
+		<section className="mb-12">
+			<div className="flex items-center justify-between mb-4">
+				<h2 className="text-lg font-semibold text-gray-900">Recently Added</h2>
+			</div>
+			{isLoading ? (
+				<SectionSkeleton count={8} aspect="[4/3]" />
+			) : (
+				<div className="grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-4 gap-4">
+					{items.map((item) => (
+						<GlobalItemCard
+							key={item.id}
+							id={item.id}
+							brand={item.brand}
+							model={item.model}
+							category={item.category}
+							weightGrams={item.weightGrams}
+							priceCents={item.priceCents}
+							imageUrl={item.imageUrl}
+						/>
+					))}
+				</div>
+			)}
+		</section>
+	);
+}
+
+function TrendingCategoriesSection() {
+	const { data, isLoading } = useDiscoveryCategories(12);
+	const categories = data ?? [];
+
+	if (!isLoading && categories.length === 0) return null;
+
+	return (
+		<section className="mb-12">
+			<div className="flex items-center justify-between mb-4">
+				<h2 className="text-lg font-semibold text-gray-900">
+					Trending Categories
+				</h2>
+			</div>
+			{isLoading ? (
+				<div className="flex flex-wrap gap-2">
+					{Array.from({ length: 8 }).map((_, i) => (
+						<div
+							key={i}
+							className="h-8 w-24 bg-gray-100 rounded-full animate-pulse"
+						/>
+					))}
+				</div>
+			) : (
+				<div className="flex flex-wrap gap-2">
+					{categories.map((cat) => (
+						<span
+							key={cat.name}
+							className="inline-flex items-center gap-1.5 px-3 py-1.5 rounded-full text-sm font-medium bg-gray-50 text-gray-700 border border-gray-100 hover:border-gray-200 hover:bg-gray-100 transition-all cursor-pointer"
+						>
+							{cat.name}
+							<span className="text-xs text-gray-400">{cat.itemCount}</span>
+						</span>
+					))}
+				</div>
+			)}
+		</section>
+	);
+}
+
+function SectionSkeleton({ count, aspect }: { count: number; aspect: string }) {
+	return (
+		<div
+			className={`grid ${aspect === "none" ? "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3" : "grid-cols-2 sm:grid-cols-3 lg:grid-cols-4"} gap-4`}
+		>
+			{Array.from({ length: count }).map((_, i) => (
+				<div
+					key={i}
+					className="bg-white rounded-xl border border-gray-100 overflow-hidden animate-pulse"
+				>
+					{aspect !== "none" && (
+						<div className={`aspect-${aspect} bg-gray-100`} />
+					)}
+					<div className="p-4 space-y-2">
+						<div className="h-3 bg-gray-100 rounded w-16" />
+						<div className="h-4 bg-gray-100 rounded w-32" />
+					</div>
+				</div>
+			))}
 		</div>
 	);
 }
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -13,6 +13,7 @@ import { requireAuth } from "./middleware/auth.ts";
 import { createRateLimit } from "./middleware/rateLimit.ts";
 import { authRoutes } from "./routes/auth.ts";
 import { categoryRoutes } from "./routes/categories.ts";
+import { discoveryRoutes } from "./routes/discovery.ts";
 import { globalItemRoutes } from "./routes/global-items.ts";
 import { imageRoutes } from "./routes/images.ts";
 import { itemRoutes } from "./routes/items.ts";
@@ -123,6 +124,10 @@ const browseTier = createRateLimit(120, 60_000);
 const detailTier = createRateLimit(60, 60_000);

 // Browse endpoints — higher limit for list/search
+app.use("/api/discovery/*", async (c, next) => {
+	if (c.req.method === "GET") return browseTier(c, next);
+	return next();
+});
 app.use("/api/global-items", async (c, next) => {
 	if (c.req.method === "GET" && !c.req.path.match(/^\/api\/global-items\/\d+$/))
 		return browseTier(c, next);
@@ -162,6 +167,9 @@ app.use("/api/*", async (c, next) => {
 	// Skip public tags endpoint (GET /api/tags)
 	if (c.req.path.startsWith("/api/tags") && c.req.method === "GET")
 		return next();
+	// Skip public discovery endpoints (GET /api/discovery/*)
+	if (c.req.path.startsWith("/api/discovery") && c.req.method === "GET")
+		return next();
 	// Skip public global-items endpoint (GET /api/global-items)
 	if (c.req.path.startsWith("/api/global-items") && c.req.method === "GET")
 		return next();
@@ -179,6 +187,7 @@ app.route("/api/settings", settingsRoutes);
 app.route("/api/threads", threadRoutes);
 app.route("/api/users", profileRoutes);
 app.route("/api/setups", setupRoutes);
+app.route("/api/discovery", discoveryRoutes);
 app.route("/api/global-items", globalItemRoutes);
 app.route("/api/tags", tagRoutes);

--- a/src/server/routes/discovery.ts
+++ b/src/server/routes/discovery.ts
@@ -0,0 +1,38 @@
+import { Hono } from "hono";
+import {
+	getPopularSetups,
+	getRecentGlobalItems,
+	getTrendingCategories,
+} from "../services/discovery.service.ts";
+
+type Env = { Variables: { db?: any } };
+
+const app = new Hono<Env>();
+
+app.get("/setups", async (c) => {
+	const db = c.get("db");
+	const limitParam = c.req.query("limit");
+	const cursor = c.req.query("cursor");
+	const limit = Math.min(limitParam ? parseInt(limitParam, 10) || 6 : 6, 50);
+	const result = await getPopularSetups(db, limit, cursor);
+	return c.json(result);
+});
+
+app.get("/items", async (c) => {
+	const db = c.get("db");
+	const limitParam = c.req.query("limit");
+	const cursor = c.req.query("cursor");
+	const limit = Math.min(limitParam ? parseInt(limitParam, 10) || 8 : 8, 50);
+	const result = await getRecentGlobalItems(db, limit, cursor);
+	return c.json(result);
+});
+
+app.get("/categories", async (c) => {
+	const db = c.get("db");
+	const limitParam = c.req.query("limit");
+	const limit = Math.min(limitParam ? parseInt(limitParam, 10) || 12 : 12, 50);
+	const result = await getTrendingCategories(db, limit);
+	return c.json(result);
+});
+
+export { app as discoveryRoutes };
--- a/src/server/services/discovery.service.ts
+++ b/src/server/services/discovery.service.ts
@@ -0,0 +1,130 @@
+import { and, count, desc, eq, isNotNull, lt, sql } from "drizzle-orm";
+import { db as prodDb } from "../../db/index.ts";
+import { globalItems, setups, setupItems, users } from "../../db/schema.ts";
+
+type Db = typeof prodDb;
+
+interface CursorPage<T> {
+	items: T[];
+	nextCursor: string | null;
+	hasMore: boolean;
+}
+
+/**
+ * Get popular public setups ordered by item count descending.
+ * Cursor format: "{itemCount}_{id}" for stable composite pagination.
+ * Only public setups (isPublic=true) are returned.
+ */
+export async function getPopularSetups(
+	db: Db = prodDb,
+	limit = 6,
+	cursor?: string,
+): Promise<
+	CursorPage<{
+		id: number;
+		name: string;
+		createdAt: Date;
+		itemCount: number;
+		creatorName: string | null;
+	}>
+> {
+	// Fetch more rows when cursor provided to ensure we can filter and still fill the page
+	const fetchLimit = cursor ? limit * 2 + limit + 1 : limit + 1;
+
+	const rows = await db
+		.select({
+			id: setups.id,
+			name: setups.name,
+			createdAt: setups.createdAt,
+			itemCount: sql<number>`CAST(COUNT(${setupItems.id}) AS INT)`,
+			creatorName: users.displayName,
+		})
+		.from(setups)
+		.leftJoin(setupItems, eq(setupItems.setupId, setups.id))
+		.leftJoin(users, eq(users.id, setups.userId))
+		.where(eq(setups.isPublic, true))
+		.groupBy(setups.id, setups.name, setups.createdAt, users.displayName)
+		.orderBy(
+			desc(sql<number>`COUNT(${setupItems.id})`),
+			desc(setups.id),
+		)
+		.limit(fetchLimit);
+
+	// Apply cursor filter in JS (composite cursor: itemCount_id)
+	let filtered = rows;
+	if (cursor) {
+		const parts = cursor.split("_");
+		const cursorCount = Number(parts[0]);
+		const cursorId = Number(parts[1]);
+		filtered = rows.filter(
+			(r) =>
+				r.itemCount < cursorCount ||
+				(r.itemCount === cursorCount && r.id < cursorId),
+		);
+	}
+
+	const hasMore = filtered.length > limit;
+	const items = hasMore ? filtered.slice(0, limit) : filtered;
+	const nextCursor =
+		hasMore && items.length > 0
+			? `${items[items.length - 1].itemCount}_${items[items.length - 1].id}`
+			: null;
+
+	return { items, nextCursor, hasMore };
+}
+
+/**
+ * Get recently added global catalog items ordered by createdAt descending.
+ * Cursor is an ISO timestamp string — returns items created before that time.
+ */
+export async function getRecentGlobalItems(
+	db: Db = prodDb,
+	limit = 8,
+	cursor?: string,
+): Promise<CursorPage<typeof globalItems.$inferSelect>> {
+	const conditions = cursor
+		? [lt(globalItems.createdAt, new Date(cursor))]
+		: [];
+
+	const rows = await db
+		.select()
+		.from(globalItems)
+		.where(conditions.length ? and(...conditions) : undefined)
+		.orderBy(desc(globalItems.createdAt))
+		.limit(limit + 1);
+
+	const hasMore = rows.length > limit;
+	const items = hasMore ? rows.slice(0, limit) : rows;
+	const nextCursor =
+		hasMore && items.length > 0
+			? items[items.length - 1].createdAt.toISOString()
+			: null;
+
+	return { items, nextCursor, hasMore };
+}
+
+/**
+ * Get trending categories ordered by global item count descending.
+ * Excludes items where category IS NULL.
+ * Simple limit pagination — no cursor (categories are a bounded list).
+ */
+export async function getTrendingCategories(
+	db: Db = prodDb,
+	limit = 12,
+): Promise<Array<{ name: string; itemCount: number }>> {
+	const rows = await db
+		.select({
+			name: globalItems.category,
+			itemCount: count(globalItems.id),
+		})
+		.from(globalItems)
+		.where(isNotNull(globalItems.category))
+		.groupBy(globalItems.category)
+		.orderBy(desc(count(globalItems.id)))
+		.limit(limit);
+
+	return rows.map((r) => ({
+		name: r.name as string,
+		itemCount: r.itemCount,
+	}));
+}
--- a/tests/routes/discovery.test.ts
+++ b/tests/routes/discovery.test.ts
@@ -0,0 +1,240 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { Hono } from "hono";
+import { globalItems, items, setups, setupItems } from "../../src/db/schema.ts";
+import { discoveryRoutes } from "../../src/server/routes/discovery.ts";
+import { createTestDb } from "../helpers/db.ts";
+
+type TestDb = Awaited<ReturnType<typeof createTestDb>>;
+
+async function createTestApp() {
+	const { db, userId } = await createTestDb();
+	const app = new Hono();
+
+	app.use("*", async (c, next) => {
+		c.set("db", db);
+		// Note: NO userId set — discovery endpoints don't need auth
+		await next();
+	});
+
+	app.route("/api/discovery", discoveryRoutes);
+	return { app, db, userId };
+}
+
+async function insertGlobalItem(
+	db: TestDb["db"],
+	brand: string,
+	model: string,
+	category?: string,
+) {
+	const [row] = await db
+		.insert(globalItems)
+		.values({ brand, model, category: category ?? "bags" })
+		.returning();
+	return row;
+}
+
+async function insertPublicSetup(
+	db: TestDb["db"],
+	userId: number,
+	name: string,
+) {
+	const [row] = await db
+		.insert(setups)
+		.values({ name, userId, isPublic: true })
+		.returning();
+	return row;
+}
+
+async function insertItem(
+	db: TestDb["db"],
+	userId: number,
+	name: string,
+): Promise<number> {
+	const [row] = await db
+		.insert(items)
+		.values({ name, categoryId: 1, userId })
+		.returning();
+	return row.id;
+}
+
+async function addItemToSetup(
+	db: TestDb["db"],
+	setupId: number,
+	itemId: number,
+) {
+	await db.insert(setupItems).values({ setupId, itemId });
+}
+
+describe("Discovery Routes", () => {
+	let app: Hono;
+	let db: TestDb["db"];
+	let userId: number;
+
+	beforeEach(async () => {
+		const testApp = await createTestApp();
+		app = testApp.app;
+		db = testApp.db;
+		userId = testApp.userId;
+	});
+
+	describe("GET /api/discovery/setups", () => {
+		it("returns 200 with { items, nextCursor, hasMore } shape", async () => {
+			await insertPublicSetup(db, userId, "My Bikepacking Setup");
+
+			const res = await app.request("/api/discovery/setups");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(body).toHaveProperty("items");
+			expect(body).toHaveProperty("nextCursor");
+			expect(body).toHaveProperty("hasMore");
+			expect(Array.isArray(body.items)).toBe(true);
+		});
+
+		it("returns only public setups", async () => {
+			await insertPublicSetup(db, userId, "Public Setup");
+			// Insert a private setup
+			await db
+				.insert(setups)
+				.values({ name: "Private Setup", userId, isPublic: false });
+
+			const res = await app.request("/api/discovery/setups");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(body.items).toHaveLength(1);
+			expect(body.items[0].name).toBe("Public Setup");
+		});
+
+		it("respects limit query param", async () => {
+			for (let i = 0; i < 5; i++) {
+				await insertPublicSetup(db, userId, `Setup ${i}`);
+			}
+
+			const res = await app.request("/api/discovery/setups?limit=2");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(body.items).toHaveLength(2);
+			expect(body.hasMore).toBe(true);
+		});
+	});
+
+	describe("GET /api/discovery/items", () => {
+		it("returns 200 with { items, nextCursor, hasMore } shape", async () => {
+			await insertGlobalItem(db, "MSR", "PocketRocket 2");
+
+			const res = await app.request("/api/discovery/items");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(body).toHaveProperty("items");
+			expect(body).toHaveProperty("nextCursor");
+			expect(body).toHaveProperty("hasMore");
+			expect(Array.isArray(body.items)).toBe(true);
+		});
+
+		it("returns 200 with empty items when catalog is empty", async () => {
+			const res = await app.request("/api/discovery/items");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(body.items).toHaveLength(0);
+			expect(body.hasMore).toBe(false);
+			expect(body.nextCursor).toBeNull();
+		});
+
+		it("respects limit query param", async () => {
+			for (let i = 0; i < 5; i++) {
+				await insertGlobalItem(db, `Brand${i}`, `Model${i}`);
+			}
+
+			const res = await app.request("/api/discovery/items?limit=2");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(body.items).toHaveLength(2);
+			expect(body.hasMore).toBe(true);
+		});
+
+		it("pagination with cursor returns items before cursor timestamp", async () => {
+			// Insert items with explicit timestamps so they are definitively ordered
+			const olderTime = new Date("2024-01-01T00:00:00Z");
+			const newerTime = new Date("2024-06-01T00:00:00Z");
+
+			await db.insert(globalItems).values({
+				brand: "Brand A",
+				model: "Model A",
+				category: "bags",
+				createdAt: olderTime,
+			});
+			await db.insert(globalItems).values({
+				brand: "Brand B",
+				model: "Model B",
+				category: "bags",
+				createdAt: newerTime,
+			});
+
+			// First page (newest first: Brand B)
+			const res1 = await app.request("/api/discovery/items?limit=1");
+			expect(res1.status).toBe(200);
+			const page1 = await res1.json();
+			expect(page1.items).toHaveLength(1);
+			expect(page1.items[0].brand).toBe("Brand B");
+			expect(page1.hasMore).toBe(true);
+			expect(page1.nextCursor).not.toBeNull();
+
+			// Second page using cursor (should return Brand A)
+			const cursor = encodeURIComponent(page1.nextCursor);
+			const res2 = await app.request(
+				`/api/discovery/items?limit=1&cursor=${cursor}`,
+			);
+			expect(res2.status).toBe(200);
+			const page2 = await res2.json();
+			expect(page2.items).toHaveLength(1);
+			expect(page2.items[0].brand).toBe("Brand A");
+		});
+	});
+
+	describe("GET /api/discovery/categories", () => {
+		it("returns 200 with array shape", async () => {
+			await insertGlobalItem(db, "MSR", "PocketRocket", "cooking");
+			await insertGlobalItem(db, "Revelate", "Terrapin", "bags");
+
+			const res = await app.request("/api/discovery/categories");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(Array.isArray(body)).toBe(true);
+		});
+
+		it("returns categories with name and itemCount fields", async () => {
+			await insertGlobalItem(db, "MSR", "PocketRocket", "cooking");
+			await insertGlobalItem(db, "Jetboil", "Flash", "cooking");
+			await insertGlobalItem(db, "Revelate", "Terrapin", "bags");
+
+			const res = await app.request("/api/discovery/categories");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(body.length).toBeGreaterThan(0);
+			expect(body[0]).toHaveProperty("name");
+			expect(body[0]).toHaveProperty("itemCount");
+			// cooking has most items (2), should be first
+			expect(body[0].name).toBe("cooking");
+			expect(body[0].itemCount).toBe(2);
+		});
+
+		it("respects limit query param", async () => {
+			await insertGlobalItem(db, "Brand A", "Model A", "category-a");
+			await insertGlobalItem(db, "Brand B", "Model B", "category-b");
+			await insertGlobalItem(db, "Brand C", "Model C", "category-c");
+
+			const res = await app.request("/api/discovery/categories?limit=2");
+			expect(res.status).toBe(200);
+
+			const body = await res.json();
+			expect(body).toHaveLength(2);
+		});
+	});
+});
--- a/tests/services/discovery.service.test.ts
+++ b/tests/services/discovery.service.test.ts
@@ -0,0 +1,246 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { eq } from "drizzle-orm";
+import {
+	globalItems,
+	items,
+	setups,
+	setupItems,
+	users,
+} from "../../src/db/schema.ts";
+import {
+	getPopularSetups,
+	getRecentGlobalItems,
+	getTrendingCategories,
+} from "../../src/server/services/discovery.service.ts";
+import { createTestDb } from "../helpers/db.ts";
+
+type TestDb = Awaited<ReturnType<typeof createTestDb>>;
+
+async function insertGlobalItem(
+	db: TestDb["db"],
+	data: { brand: string; model: string; category?: string },
+) {
+	const [row] = await db
+		.insert(globalItems)
+		.values({
+			brand: data.brand,
+			model: data.model,
+			category: data.category ?? null,
+		})
+		.returning();
+	return row;
+}
+
+async function insertItem(
+	db: TestDb["db"],
+	userId: number,
+	categoryId = 1,
+) {
+	const [row] = await db
+		.insert(items)
+		.values({ name: "Test Item", categoryId, userId })
+		.returning();
+	return row;
+}
+
+async function insertPublicSetup(
+	db: TestDb["db"],
+	userId: number,
+	name: string,
+	itemIds: number[],
+) {
+	const [setup] = await db
+		.insert(setups)
+		.values({ name, userId, isPublic: true })
+		.returning();
+	for (const itemId of itemIds) {
+		await db.insert(setupItems).values({ setupId: setup.id, itemId });
+	}
+	return setup;
+}
+
+async function insertPrivateSetup(
+	db: TestDb["db"],
+	userId: number,
+	name: string,
+) {
+	const [setup] = await db
+		.insert(setups)
+		.values({ name, userId, isPublic: false })
+		.returning();
+	return setup;
+}
+
+describe("Discovery Service", () => {
+	let db: TestDb["db"];
+	let userId: number;
+
+	beforeEach(async () => {
+		const testDb = await createTestDb();
+		db = testDb.db;
+		userId = testDb.userId;
+	});
+
+	describe("getPopularSetups", () => {
+		it("returns public setups ordered by item count descending", async () => {
+			const item1 = await insertItem(db, userId);
+			const item2 = await insertItem(db, userId);
+			const item3 = await insertItem(db, userId);
+
+			// Setup with 1 item
+			await insertPublicSetup(db, userId, "Solo Setup", [item1.id]);
+			// Setup with 2 items
+			await insertPublicSetup(db, userId, "Dual Setup", [item2.id, item3.id]);
+
+			const result = await getPopularSetups(db);
+			expect(result.items).toHaveLength(2);
+			expect(result.items[0].name).toBe("Dual Setup");
+			expect(result.items[0].itemCount).toBe(2);
+			expect(result.items[1].name).toBe("Solo Setup");
+			expect(result.items[1].itemCount).toBe(1);
+		});
+
+		it("excludes private setups", async () => {
+			const item1 = await insertItem(db, userId);
+			await insertPublicSetup(db, userId, "Public Setup", [item1.id]);
+			await insertPrivateSetup(db, userId, "Private Setup");
+
+			const result = await getPopularSetups(db);
+			expect(result.items).toHaveLength(1);
+			expect(result.items[0].name).toBe("Public Setup");
+		});
+
+		it("returns hasMore=true and nextCursor when more results exist", async () => {
+			const item1 = await insertItem(db, userId);
+			const item2 = await insertItem(db, userId);
+			const item3 = await insertItem(db, userId);
+
+			await insertPublicSetup(db, userId, "Setup A", [item1.id, item2.id, item3.id]);
+			await insertPublicSetup(db, userId, "Setup B", [item1.id, item2.id]);
+			await insertPublicSetup(db, userId, "Setup C", [item1.id]);
+
+			const result = await getPopularSetups(db, 1);
+			expect(result.hasMore).toBe(true);
+			expect(result.nextCursor).not.toBeNull();
+		});
+
+		it("returns second page without duplicates when cursor provided", async () => {
+			const item1 = await insertItem(db, userId);
+			const item2 = await insertItem(db, userId);
+			const item3 = await insertItem(db, userId);
+
+			await insertPublicSetup(db, userId, "Setup A", [item1.id, item2.id, item3.id]);
+			await insertPublicSetup(db, userId, "Setup B", [item1.id, item2.id]);
+			await insertPublicSetup(db, userId, "Setup C", [item1.id]);
+
+			const page1 = await getPopularSetups(db, 1);
+			expect(page1.items).toHaveLength(1);
+			expect(page1.nextCursor).not.toBeNull();
+
+			const page2 = await getPopularSetups(db, 1, page1.nextCursor!);
+			expect(page2.items).toHaveLength(1);
+			expect(page2.items[0].id).not.toBe(page1.items[0].id);
+		});
+
+		it("includes creatorName from users.displayName", async () => {
+			// Update user display name
+			await db.update(users)
+				.set({ displayName: "Jean-Luc" })
+				.where(eq(users.id, userId));
+
+			const item1 = await insertItem(db, userId);
+			await insertPublicSetup(db, userId, "My Setup", [item1.id]);
+
+			const result = await getPopularSetups(db);
+			expect(result.items).toHaveLength(1);
+			expect(result.items[0].creatorName).toBe("Jean-Luc");
+		});
+	});
+
+	describe("getRecentGlobalItems", () => {
+		it("returns items ordered by createdAt descending", async () => {
+			// Insert items with slight delay to get different timestamps
+			const item1 = await insertGlobalItem(db, { brand: "BrandA", model: "Model1" });
+			await new Promise((r) => setTimeout(r, 5));
+			const item2 = await insertGlobalItem(db, { brand: "BrandB", model: "Model2" });
+			await new Promise((r) => setTimeout(r, 5));
+			const item3 = await insertGlobalItem(db, { brand: "BrandC", model: "Model3" });
+
+			const result = await getRecentGlobalItems(db);
+			expect(result.items).toHaveLength(3);
+			// Most recent first
+			expect(result.items[0].id).toBe(item3.id);
+			expect(result.items[1].id).toBe(item2.id);
+			expect(result.items[2].id).toBe(item1.id);
+		});
+
+		it("returns hasMore=true and nextCursor when more results exist", async () => {
+			await insertGlobalItem(db, { brand: "BrandA", model: "Model1" });
+			await new Promise((r) => setTimeout(r, 5));
+			await insertGlobalItem(db, { brand: "BrandB", model: "Model2" });
+			await new Promise((r) => setTimeout(r, 5));
+			await insertGlobalItem(db, { brand: "BrandC", model: "Model3" });
+
+			const result = await getRecentGlobalItems(db, 2);
+			expect(result.hasMore).toBe(true);
+			expect(result.nextCursor).not.toBeNull();
+		});
+
+		it("returns second page without duplicates when cursor provided", async () => {
+			await insertGlobalItem(db, { brand: "BrandA", model: "Model1" });
+			await new Promise((r) => setTimeout(r, 5));
+			await insertGlobalItem(db, { brand: "BrandB", model: "Model2" });
+			await new Promise((r) => setTimeout(r, 5));
+			await insertGlobalItem(db, { brand: "BrandC", model: "Model3" });
+
+			const page1 = await getRecentGlobalItems(db, 2);
+			expect(page1.items).toHaveLength(2);
+			expect(page1.nextCursor).not.toBeNull();
+
+			const page2 = await getRecentGlobalItems(db, 2, page1.nextCursor!);
+			expect(page2.items).toHaveLength(1);
+			// Page 2 item should not appear in page 1
+			const page1Ids = page1.items.map((i) => i.id);
+			expect(page1Ids).not.toContain(page2.items[0].id);
+		});
+	});
+
+	describe("getTrendingCategories", () => {
+		it("returns categories ordered by item count descending", async () => {
+			// 3 items in Tents, 1 in Bags, 2 in Stoves
+			await insertGlobalItem(db, { brand: "BrandA", model: "Tent1", category: "Tents" });
+			await insertGlobalItem(db, { brand: "BrandB", model: "Tent2", category: "Tents" });
+			await insertGlobalItem(db, { brand: "BrandC", model: "Tent3", category: "Tents" });
+			await insertGlobalItem(db, { brand: "BrandD", model: "Bag1", category: "Bags" });
+			await insertGlobalItem(db, { brand: "BrandE", model: "Stove1", category: "Stoves" });
+			await insertGlobalItem(db, { brand: "BrandF", model: "Stove2", category: "Stoves" });
+
+			const result = await getTrendingCategories(db);
+			expect(result).toHaveLength(3);
+			expect(result[0].name).toBe("Tents");
+			expect(result[0].itemCount).toBe(3);
+			expect(result[1].name).toBe("Stoves");
+			expect(result[1].itemCount).toBe(2);
+			expect(result[2].name).toBe("Bags");
+			expect(result[2].itemCount).toBe(1);
+		});
+
+		it("excludes items with null category", async () => {
+			await insertGlobalItem(db, { brand: "BrandA", model: "Tent1", category: "Tents" });
+			// No category — should be excluded
+			await insertGlobalItem(db, { brand: "BrandB", model: "NoCategory" });
+
+			const result = await getTrendingCategories(db);
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe("Tents");
+		});
+
+		it("returns empty array when no items have a category set", async () => {
+			await insertGlobalItem(db, { brand: "BrandA", model: "Model1" });
+			await insertGlobalItem(db, { brand: "BrandB", model: "Model2" });
+
+			const result = await getTrendingCategories(db);
+			expect(result).toHaveLength(0);
+		});
+	});
+});
Author	SHA1	Message	Date
Jean-Luc Makiola	c98995288b	docs(phase-26): evolve PROJECT.md after phase completion Some checks failed CI / ci (push) Failing after 10s Details CI / deploy (push) Has been skipped Details CI / e2e (push) Has been skipped Details	2026-04-10 15:08:50 +02:00
Jean-Luc Makiola	c892800969	docs(phase-26): complete phase execution	2026-04-10 15:08:18 +02:00
Jean-Luc Makiola	31a72c68f3	docs(26-03): complete discovery landing page plan - 26-03-SUMMARY.md: landing page rewrite and PublicSetupCard enhancement - STATE.md: advanced to phase complete, recorded decisions - ROADMAP.md: phase 26 marked complete (3/3 plans) - REQUIREMENTS.md: DISC-01 through DISC-05 marked complete	2026-04-10 15:03:00 +02:00
Jean-Luc Makiola	8aaf4352ed	feat(26-03): rewrite landing page as public discovery page - Replace DashboardPage with LandingPage using discovery hooks - Add HeroSection with Discover Gear heading and catalog search trigger - Add PopularSetupsSection using useDiscoverySetups with PublicSetupCard - Add RecentItemsSection using useDiscoveryItems with GlobalItemCard - Add TrendingCategoriesSection using useDiscoveryCategories with pills - Conditional Go to Collection CTA for authenticated users - Loading skeletons with animate-pulse for all three sections - Empty state handling: sections return null when no data - SectionSkeleton helper for consistent loading states - All clickable elements have cursor-pointer	2026-04-10 15:01:49 +02:00
Jean-Luc Makiola	0bf1c68043	feat(26-03): enhance PublicSetupCard with itemCount and creatorName - Add optional itemCount and creatorName fields to PublicSetupCardProps - Render item count badge (blue pill) when itemCount > 0 - Render creator attribution line when creatorName is present - Reorder card layout: name, creator, then count/date row - Add cursor-pointer to Link className - Backward compatible: existing usages passing only id/name/createdAt unaffected	2026-04-10 15:00:57 +02:00
Jean-Luc Makiola	0b2e355bf8	docs(26-02): complete discovery routes and hooks plan	2026-04-10 14:59:58 +02:00
Jean-Luc Makiola	747a1c3727	feat(26-02): React Query hooks for discovery data - Create useDiscoverySetups, useDiscoveryItems, useDiscoveryCategories hooks - Export DiscoverySetup and DiscoveryCategory interfaces - Set staleTime 2min for setups/items, 5min for categories	2026-04-10 14:57:53 +02:00
Jean-Luc Makiola	0323e0cd33	feat(26-02): discovery HTTP routes, server registration, and route tests - Create src/server/routes/discovery.ts with GET /setups, /items, /categories handlers - Register discoveryRoutes in src/server/index.ts with browseTier rate limiting - Add auth skip for /api/discovery/* GET requests in auth middleware - Create tests/routes/discovery.test.ts with 10 tests covering all endpoints and pagination	2026-04-10 14:57:35 +02:00
Jean-Luc Makiola	a00b90d97a	docs(26-01): complete discovery service plan - SUMMARY.md: discovery service with cursor pagination - STATE.md: advanced to plan 2, added decisions, updated progress to 71% - ROADMAP.md: phase 26 in progress (1/3 plans) - REQUIREMENTS.md: DISC-02, DISC-03, DISC-04, INFR-02 marked complete	2026-04-10 14:55:15 +02:00
Jean-Luc Makiola	d1f8a7aa4c	feat(26-01): implement discovery service with cursor pagination - getPopularSetups: public setups ordered by item count desc, composite cursor pagination - getRecentGlobalItems: global items ordered by createdAt desc, ISO timestamp cursor - getTrendingCategories: category counts ordered desc, null categories excluded, simple limit - Shared CursorPage<T> response shape with hasMore and nextCursor fields	2026-04-10 14:54:13 +02:00
Jean-Luc Makiola	06b6e935f2	test(26-01): add failing tests for discovery service - getPopularSetups: ordering, privacy filter, cursor pagination, creatorName - getRecentGlobalItems: ordering, cursor pagination, second page deduplication - getTrendingCategories: ordering by count desc, null category exclusion, empty state	2026-04-10 14:53:09 +02:00
Jean-Luc Makiola	2f88ead599	fix(26): revise plans based on checker feedback	2026-04-10 14:48:44 +02:00
Jean-Luc Makiola	9226dd3d90	docs(26): create phase plan	2026-04-10 14:45:38 +02:00
Jean-Luc Makiola	9336cd80ed	docs(phase-26): add research and validation strategy	2026-04-10 14:38:53 +02:00
Jean-Luc Makiola	6b446033b5	docs(phase-26): research discovery landing page Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-10 14:38:10 +02:00
Jean-Luc Makiola	274bced96d	docs(state): record phase 26 context session	2026-04-10 14:33:04 +02:00
Jean-Luc Makiola	dbab91a3c7	docs(26): capture phase context	2026-04-10 14:32:56 +02:00