Bugfix/questions 6mb payload limit

.claude/CLAUDE.md

@@ -0,0 +1,141 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+**AutoRFP** is an AI-powered RFP response automation platform for government contractors. Core capabilities: RFP document processing, AI answer generation (RAG), executive briefs, proposal generation, SAM.gov integration, and knowledge base management.
+
+## Monorepo Structure
+
+```
+auto_rfp/                    # pnpm workspaces monorepo
+├── apps/
+│   ├── web/                 # Next.js App Router frontend (Tailwind 4, Shadcn UI, SWR)
+│   └── functions/           # AWS Lambda handlers (Node.js 20, ESM)
+├── packages/
+│   ├── core/                # Shared Zod schemas & inferred TypeScript types (tsup, vitest)
+│   └── infra/               # AWS CDK stacks (API Gateway, DynamoDB, Cognito, S3, etc.)
+└── scripts/                 # Utility scripts
+```
+
+## Commands
+
+All commands use `pnpm`. Run from the monorepo root unless noted.
+
+```bash
+# Root-level
+pnpm build                   # Build all packages
+pnpm dev                     # Start web dev server
+pnpm test                    # Run all tests
+pnpm lint                    # Lint all packages
+
+# Core schemas (packages/core)
+cd packages/core
+pnpm build                   # Build with tsup (required before web/functions can import)
+pnpm test                    # Run vitest schema tests
+
+# Lambda functions (apps/functions)
+cd apps/functions
+pnpm test                    # Run all Jest tests
+pnpm test -- --testPathPattern=handlers/answer   # Run tests for a specific domain
+pnpm test -- path/to/file.test.ts                # Run a single test file
+
+# Web app (apps/web)
+cd apps/web
+pnpm dev                     # Dev server (port 3000)
+pnpm build                   # Production build
+pnpm test                    # Jest unit/component tests
+pnpm test:e2e                # Playwright e2e tests
+pnpm test:e2e:ui             # Playwright with UI
+pnpm lint                    # ESLint
+
+# Infrastructure (packages/infra)
+cd packages/infra
+pnpm test                    # CDK/Jest tests
+
+# Deployments (from root)
+pnpm deploy:dev              # Deploy all CDK stacks to dev
+pnpm deploy:dev:hotswap      # Hotswap deploy (faster for Lambda changes)
+pnpm deploy:dev:api          # Deploy only API stack to dev
+```
+
+### Build Order
+
+`packages/core` must be built first — both `apps/web` and `apps/functions` depend on it:
+```bash
+cd packages/core && pnpm build   # Always rebuild after changing schemas
+```
+
+### Type Checking
+
+```bash
+cd apps/functions && pnpm build  # tsc (checks types)
+cd apps/web && npx tsc --noEmit  # Type-check without emitting
+cd packages/infra && pnpm build  # tsc
+```
+
+## Architecture
+
+### Backend (apps/functions)
+
+Lambda handlers are organized by domain in `src/handlers/<domain>/`. Each handler follows a thin pattern:
+1. Parse event → 2. Validate with Zod (destructure `safeParse`) → 3. Call helper → 4. Return `apiResponse()`
+
+Key directories:
+- `src/handlers/` — Thin Lambda handlers grouped by domain (~30 domains)
+- `src/helpers/` — Business logic, DynamoDB operations, AI integrations
+- `src/constants/` — PK constants, config values
+- `src/middleware/` — Middy middleware (auth, RBAC, error handling)
+- `src/types/` — DynamoDB item types extending core schemas with PK/SK
+
+DynamoDB uses single-table design. All operations go through `src/helpers/db.ts` (`createItem`, `getItem`, `queryBySkPrefix`, etc.). PK constants are in `src/constants/`. SK strings are built via helper functions — never manually.
+
+### Frontend (apps/web)
+
+Next.js App Router with Feature-Sliced Design:
+- `app/` — Pages and layouts (route groups: `(auth)`, `(dashboard)`)
+- `features/` — Domain modules with `components/`, `hooks/`, `lib/`, `index.ts` barrel exports
+- `components/ui/` — Shadcn UI primitives
+- `lib/hooks/` — Shared SWR data-fetching hooks
+- `context/` — Auth, organization providers
+
+State: SWR for server state, AWS Amplify for auth, `nuqs` for URL state.
+
+### Infrastructure (packages/infra)
+
+CDK stacks in `lib/`. API routes defined in `api/routes/<domain>.routes.ts` and registered in `api/api-orchestrator-stack.ts`.
+
+### Shared Types (packages/core)
+
+All domain types are Zod schemas in `src/schemas/`. Types are always inferred via `z.infer<>` — never defined manually. Built with tsup to ESM + CJS.
+
+## Git Workflow
+
+- **develop** — Main development branch. PRs target here. Deploys to staging.
+- **production** — Customer-facing. Updated only via Release workflow.
+- Create feature branches from `develop`, open PRs to `develop`.
+
+## Key Conventions
+
+Detailed rules are in `.claude/rules/`. The most critical ones:
+
+- **No `any` type.** Use `unknown` with type guards, or specific type assertions.
+- **All types from Zod.** `type Foo = z.infer<typeof FooSchema>` — never manual interfaces for domain types.
+- **`const` arrow functions** for all function definitions (except Next.js page/layout defaults).
+- **Destructure `safeParse`** immediately: `const { success, data, error } = Schema.safeParse(raw)`.
+- **`orgId` from request body/query/path** — never from JWT token or `event.auth`.
+- **Use `apiResponse()`** from `@/helpers/api` for all REST responses.
+- **No raw DynamoDB SDK in handlers** — use helpers from `@/helpers/db` or domain helpers.
+- **Skeleton loading states** — never spinners or "Loading..." text.
+- **Shadcn UI components** — never raw HTML elements for buttons, inputs, etc.
+- **Tests are co-located** with source files (e.g., `create-foo.ts` → `create-foo.test.ts`).
+- **Test the exported business function directly**, not the middy-wrapped handler.
+- **Mock middy and AWS SDK before imports** in test files.
+
+## Lessons Learned
+
+- When modifying handler parameters, update ALL corresponding test files.
+- All React hooks must be called before any conditional returns.
+- Mock function names must exactly match the imported function names.
+- After changing core schemas, rebuild `packages/core` before running dependent tests.

.claude/README.md

@@ -0,0 +1,144 @@
+# Claude Code Configuration
+
+This directory contains configuration and rules for [Claude Code](https://claude.ai/code).
+
+## Directory Structure
+
+```
+.claude/
+├── README.md                    # This file
+├── settings.json                # Team settings (tracked in git)
+├── settings.local.json          # Personal settings (gitignored)
+├── agents/                      # Custom agents for specialized workflows
+│   ├── feature-implementer.md   # End-to-end feature implementation
+│   ├── code-reviewer.md         # Convention compliance & security audit
+│   └── test-generator.md        # Comprehensive test suite generation
+├── skills/                      # Reusable skills (10 skills)
+│   ├── audit-logging/SKILL.md   # Audit trail logging for handlers & services
+│   ├── backend-test/SKILL.md    # Jest tests with AWS SDK & middy mocking
+│   ├── cdk-route/SKILL.md       # API Gateway routes with Lambda integration
+│   ├── dynamodb-helper/SKILL.md # DynamoDB helpers with SK builders & CRUD
+│   ├── e2e-test/SKILL.md        # Playwright E2E tests with auth fixtures
+│   ├── frontend-feature/SKILL.md # Feature modules (hooks, components, pages)
+│   ├── frontend-form/SKILL.md   # Forms with react-hook-form & Zod validation
+│   ├── lambda/SKILL.md          # Lambda handlers with middy & Sentry
+│   ├── step-function/SKILL.md   # Step Functions pipelines with CDK
+│   └── zod-schema/SKILL.md      # Zod schemas with types & DTOs
+└── rules/                       # Project rules (tracked in git)
+    ├── 01-project-structure.md
+    ├── 02-typescript-best-practices.md
+    ├── 03-entity-definitions.md
+    ├── 04-backend-architecture.md
+    ├── 05-dynamodb-design.md
+    ├── 06-frontend-architecture.md
+    ├── 07-infrastructure.md
+    ├── 08-cicd.md
+    ├── 09-testing.md
+    ├── RULES.md
+    ├── README.md
+    ├── cost-optimization.md
+    ├── next-js.md
+    ├── web-development.md
+    └── workflows/
+        ├── architecture.md
+        └── implementation.md
+```
+
+## 🤖 Agents
+
+Agents are specialized personas that can be invoked in Claude Code to handle specific workflows. Use them with `/agent <name>` in Claude Code.
+
+### 1. Feature Implementer (`feature-implementer`)
+
+**When to use**: Building a new feature end-to-end across the monorepo.
+
+Implements features in the correct dependency order:
+```
+Core Schemas → Constants → Helpers → Lambda Handlers → CDK Routes → CDK Infra → Frontend Hooks → Components → Tests
+```
+
+**Example prompts**:
+- `"Implement the FOIA request feature from docs/FOIA-IMPLEMENTATION.md"`
+- `"Build a new notifications CRUD with REST API and React UI"`
+- `"Add a deadline extraction feature with DynamoDB storage and frontend display"`
+
+---
+
+### 2. Code Reviewer (`code-reviewer`)
+
+**When to use**: Auditing code for correctness, security, and convention compliance before merging.
+
+Checks 30+ rules across TypeScript, backend, frontend, DynamoDB, testing, and audit trail categories. Produces a structured report at `docs/reviews/`.
+
+**Example prompts**:
+- `"Review the answer feature"`
+- `"Review apps/functions/src/handlers/clustering/"`
+- `"Security review the auth handlers"`
+- `"Review apps/web/components/brief/helpers.ts"`
+
+**Output**: Structured markdown report with severity levels (🔴 Critical, 🟡 Warning, 🔵 Info) and a compliance summary table.
+
+---
+
+### 3. Test Generator (`test-generator`)
+
+**When to use**: Writing comprehensive tests for handlers, helpers, schemas, or components.
+
+Generates tests with proper AWS SDK mocking, covers all code paths (happy path, validation, not-found, guards, errors, edge cases), and follows project conventions.
+
+**Example prompts**:
+- `"Write tests for apps/functions/src/handlers/document/download-document.ts"`
+- `"Write tests for the brief feature"`
+- `"Write schema tests for packages/core/src/schemas/project.ts"`
+- `"Write tests for apps/web/components/brief/"`
+
+---
+
+## 🛠️ Skills
+
+Skills are reusable instruction sets that Claude Code can activate for specific tasks. Each skill provides step-by-step templates and hard rules for a particular type of work.
+
+| # | Skill | Description | Trigger Example |
+|---|---|---|---|
+| 1 | **`zod-schema`** | Create Zod schemas with types, Create/Update DTOs, barrel exports | `"Create a schema for notifications"` |
+| 2 | **`lambda`** | Lambda handler with middy, Zod validation, audit, Sentry | `"Create a handler to list notifications"` |
+| 3 | **`cdk-route`** | API Gateway route with Lambda integration in CDK | `"Add API routes for the notification domain"` |
+| 4 | **`dynamodb-helper`** | DynamoDB helpers with SK builders and CRUD operations | `"Create DynamoDB helpers for notifications"` |
+| 5 | **`frontend-feature`** | Feature module with hooks, components, pages (FSD) | `"Create the notifications frontend feature"` |
+| 6 | **`frontend-form`** | Form page with react-hook-form, Zod, Shadcn UI | `"Create a notification create/edit form"` |
+| 7 | **`backend-test`** | Jest tests with AWS SDK mocking, middy mocking | `"Write tests for the create-notification handler"` |
+| 8 | **`e2e-test`** | Playwright E2E tests with auth fixtures, page objects | `"Write E2E tests for the notifications feature"` |
+| 9 | **`audit-logging`** | Audit trail logging with proper actions and patterns | `"Add audit logging to the notification handlers"` |
+| 10 | **`step-function`** | Step Functions pipelines with CDK for async workflows | `"Create a notification delivery pipeline"` |
+
+---
+
+## Rules Directory
+
+The `rules/` directory contains markdown files that Claude Code automatically reads when working on this project. These rules define:
+
+- **Project conventions** and coding standards
+- **Architecture patterns** for backend and frontend
+- **Database design** patterns
+- **Testing requirements**
+- **CI/CD workflows**
+
+These files are synced from `.clinerules/` to ensure consistency across different AI coding assistants.
+
+## Settings
+
+- `settings.json` - Team-wide Claude Code settings (tracked in git)
+- `settings.local.json` - Personal Claude Code settings (gitignored)
+
+## Syncing Rules
+
+To update Claude Code rules from clinerules:
+
+```bash
+cp -r .clinerules/* .claude/rules/
+```
+
+## Learn More
+
+- [Claude Code Documentation](https://docs.claude.ai/code)
+- [Project Rules in .clinerules/](../.clinerules/README.md)