// Every manager is an employee
interface EmployeeOrgRelations {
  primaryManagerId?: string        // 0..1
  dottedLineManagerIds: string[]   // 0..N
  additionalManagerIds: string[]   // 0..N
  teamIds: string[]                // 0..N
  departmentIds: string[]          // 0..N
  roleIds: string[]                // 0..N
}

ALWAYS:
├── Filter by tenantId in every query
├── Use Prisma 5.x (NOT 6.x)
├── Use REST APIs (NOT GraphQL)
├── Follow established patterns exactly
└── Complete one building block before starting next

NEVER:
├── Add microservices
├── Use event sourcing
├── Create abstract factories for < 3 implementations
├── Touch locked files without ADR
└── Suggest "better" patterns

// Manager operations
Org.assignPrimaryManager(empId, mgrId)
Org.addDottedLineManager(empId, mgrId)
Org.addAdditionalManager(empId, mgrId)

// Team operations
Org.addEmployeeToTeam(empId, teamId, role?)
Org.removeEmployeeFromTeam(empId, teamId)

// Department operations
Org.addEmployeeToDepartment(empId, deptId, isPrimary?)
Org.setPrimaryDepartment(empId, deptId)

// Role operations
Org.assignRole(empId, roleId, isPrimary?)
Org.setPrimaryRole(empId, roleId)

// AI operations
AI.org.explain(empId)
AI.org.validate(options)
AI.org.generateStructure(description)

# HRMS Project - AI Agent Instructions

## Project Context
Multi-tenant HRMS SaaS with flexible org structure.
- Monorepo: apps/web (Next.js 15), apps/api (NestJS 10), packages/database (Prisma 5)
- Database: PostgreSQL 17 with Row-Level Security
- Auth: Auth.js with Google SSO

## Current Phase
Check: https://hrms-docs.vercel.app/docs/15-implementation-plan

## CRITICAL RULES

### Session Start Ritual (MANDATORY)
1. Read PROJECT_STATE.md - Note current phase, step, locked files
2. Read WHAT_EXISTS.md - Note patterns to copy
3. Run: git status && git log -3 --oneline
4. State: "I'm on Phase X, Step Y. I will do Z. Pattern source: [file]."
5. WAIT for approval before any code changes

### Before Writing Code
1. Complete Pre-Code Verification (see below)
2. Confirm understanding: "I will [X]. Gate is [Y]. Proceed?"
3. Wait for approval

### After Each Step
1. Update PROJECT_STATE.md with ✅ and timestamp
2. Run gate verification
3. Report: "Gate [PASS/FAIL]: [details]"
4. Ask: "What's next?" - DO NOT auto-proceed

### Escape Hatch
If unsure about ANYTHING, ASK instead of guessing.

## PRE-CODE VERIFICATION (Before EVERY Edit)

1. Is this file in "Locked Files" list? → STOP if yes
2. Have I read the file's current contents? → Read first if no
3. Does similar file/component exist? → Search first
4. What pattern am I copying from? → Identify source file
5. What is the gate for this step? → State criteria

## CONSTRAINTS - DO NOT VIOLATE

### Architecture
- NO microservices (monolith only)
- NO GraphQL (REST only)
- NO event sourcing or message queues
- NO abstractions without 3+ implementations

### Technology
- Prisma 5.x (NOT 6.x)
- Next.js 15.x with App Router
- NestJS 10.x
- React Query (NOT Redux/MobX)

### Development
- Complete ONE vertical slice before touching anything else
- Never modify locked files without approval
- Never install packages not in tech stack
- Never suggest "improvements" to working code

## ANTI-IMPROVEMENT PLEDGE

NEVER do these without explicit request:
- "Improve" working code
- Suggest "better" alternatives
- Refactor "while we're here"
- Add "helpful" features
- "Clean up" unrelated code
- Premature optimization
- Add extra error handling
- Create abstractions for single use

If tempted, ask: "Is [X] in scope? If not, I'll continue with current task."

## Common Commands
# Development
npm run dev              # Start all services
npm run db:push          # Push schema changes
npm run db:studio        # Open Prisma Studio

# Testing
npm test             # Run tests
npm run lint             # Run linter

# Build
npm run build            # Build all

## Key Files
- packages/database/prisma/schema.prisma - Database schema
- apps/api/src/app.module.ts - API module registration
- apps/web/app/layout.tsx - App layout

## Anti-Patterns (From Bluewoo Lessons)
- Over-engineering for hypothetical scale
- Adding features "for later"
- Enterprise patterns for zero customers
- Shared libraries between modules
- Complex inheritance hierarchies