You are an expert in TypeScript, Node.js, React, GraphQL, PostgreSQL, Prisma, Jest, Playwright, Docker, and Terraform.

Key Principles
- Build features that directly support mentorship outcomes: smart matching, structured check-ins, feedback capture, analytics.
- Domain-driven design (DDD): isolate bounded contexts (Matching, Scheduling, Sessions, Feedback).
- Functional, declarative code preferred; keep side effects at boundaries (DB, network, IO).
- Small, composable modules (≤150 LOC) with single responsibility.
- Fail fast: validate inputs immediately; use exhaustive guards and return typed results.
- Treat psychological-safety features (private notes, anonymity options) as first-class product requirements.
- Infrastructure as Code (IaC) and CI/CD are mandatory; all merges must pass full test battery & static analysis.

TypeScript
- Always enable "strict", "noImplicitAny", "exactOptionalPropertyTypes" in tsconfig.
- Prefer `interface` for contracts, `type` for unions & primitives.
- Use `Readonly` & `const` assertions to model immutability.
- Use `Result<T, E>` (e.g., `neverthrow`) instead of exceptions in domain layer; map to HTTP/GraphQL errors at edge.
- Never use `any`. If unavoidable, isolate in `__unsafe__` folder and document.
- File anatomy: domain (entities, value objects) → services → controllers → routes/resolvers.
- Naming: verbs for functions (`generatePairings`), nouns for data (`MentorProfile`).

Error Handling & Validation
- Centralised error map: `errors/*.ts` enumerates codes (e.g., `MENTOR_NOT_AVAILABLE`, `MATCH_CONFLICT`).
- Each API returns RFC 7807 Problem Details; GraphQL uses `extensions.code`.
- Zod schemas validate every API payload at boundary; map failures to 400.
- Use early returns. Example:
  ```ts
  if (!schema.safeParse(body).success) return problem(400, 'INVALID_PAYLOAD');
  ```
- Log with structured logger (Pino) including `requestId`, `actorId`, `context`.
- Do not leak PII in error messages—mask emails & names.

React (Next.js)
- Use Server Components for data fetching; Client Components only when interaction needed.
- Co-locate GraphQL operations with components via `*.gql.ts`.
- State management: React Query + Zustand for ephemeral UI state.
- Directory: `app/(public|dashboard)/feature/page.tsx`, `components/ui/*`, `lib/hooks/*`.
- Accessibility first: every interactive element must have discernible label.
- Pair-programming widget: integrate VS Code Live Share—lazy-load module, handle missing permission errors.

Node.js (Fastify Server)
- `src/server.ts` boots Fastify; register `plugins/*` for auth, db, tracing.
- Use `@fastify/cors` with allow-list from env.
- GraphQL server via Mercurius; each schema module under `src/graphql/*` with resolver map + SDL.
- Background jobs (matching runs, reminders) in BullMQ; store metadata in Redis with TTL.
- Config via environment variables validated at startup (dotenv + zod `EnvSchema`).

Database (PostgreSQL + Prisma)
- Schema follows DDD contexts (matching, feedback). Example:
  ```prisma
  model Mentor {
    id           String   @id @default(uuid())
    skills       Skill[]  @relation("MentorSkills")
    capacity     Int      @default(3)  // max mentees
    ...
  }
  ```
- Use nullable columns sparingly; instead model optionality with association tables.
- Soft-delete via `deleted_at` timestamp; always scope queries with `WHERE deleted_at IS NULL` middleware.
- Use row-level security for multi-tenant deployments.

Matching Algorithm Rules
- Inputs: mentor skills, mentee goals, availability, time zones, preferred language.
- Weighted scoring (0-100) = Σ(weight × normalizedFactor).
- Hard constraints: capacity, non-overlapping time zones ±4 h, HR compliance blockers.
- Run nightly; expose dry-run endpoint for admins.

Testing
- Unit: Jest with 80% branch coverage gate.
- Integration: Spin ephemeral Postgres via Testcontainers; run GraphQL end-to-end scenarios.
- E2E: Playwright scripts cover onboarding flow, scheduling, feedback submission.
- Contract tests against mentoring platforms API (e.g., Zoom) using Pact.

Performance
- Index foreign keys & search columns (`skills`, `time_zone`).
- Cache GET /mentors & GET /mentees with Redis for 5 min; bust on update.
- Use `EXPLAIN` in CI to block queries with cost > 100k.

Security
- SSO via SAML/OIDC; fallback password auth disabled in prod.
- Rate-limit login 5/min/IP; graphite metrics.
- All PII encrypted at rest (Postgres pgcrypto). Audit log immutable table.
- OWASP dependency check in pipeline; auto-create PRs for vulnerabilities.

DevOps
- Docker images pinned to digest; multi-stage build to keep runtime ≤120 MB.
- Terraform modules provision RDS, Redis, CloudWatch dashboards.
- Feature flags via Unleash; roll out mentoring-AI suggestions to 5% first.

Analytics & Feedback
- Capture mentor/mentee NPS after each session; send to Segment.
- Pre/post-assessment tables for skill deltas. Dashboards in Metabase.

Documentation
- Use `docs/adr/*.md` for architecture decisions (ADR-0001-matching-algorithm.md).
- `/api` endpoint auto-docs via GraphQL voyager + Markdown examples.

Folder Structure (root)
```
.
├─ src
│  ├─ domain
│  ├─ services
│  ├─ graphql
│  ├─ plugins
│  ├─ jobs
│  └─ server.ts
├─ app (Next.js)
├─ prisma
├─ tests
├─ docker
└─ docs
```

Common Pitfalls & Guards
- Avoid circular mentor–mentee links: unique composite (mentorId, menteeId) with constraint.
- Detect session conflicts: `EXCLUDE USING gist` on tsrange.
- Ensure timezone math uses `luxon`; forbid native `Date` in code review.

Linting & Formatting
- ESLint + @typescript-eslint + Prettier (printWidth = 100, trailingComma = all).
- CI fails on any lint error; husky pre-commit runs `lint-staged`.

Commit & PR Rules
- Conventional Commits; PR title must follow `<type>(scope): summary`.
- Require linked issue & changelog entry.

Onboarding for Contributors
- Run `pnpm i && pnpm dev` boots frontend & backend with Dockerized Postgres.
- `pnpm storybook` to view UI components including mentorship widgets.

End of Rules