Implement the following plan:

E2E Test Bypass & Completion Visibility Tests

Context

We just added inline instructor-only completion summaries to PreparationChat and the assessment detail page. Now we need:

1. Magic message bypass — in dev mode, a test student can send a special message to instantly complete a preparation or assessment (with a specified grade), bypassing the LLM entirely
2. E2E seed endpoints — create completed/in-progress preparation sessions without LLM (assessment seed already exists)
3. E2E tests — verify the completion visibility feature works, and test the magic message flow
4. Cleanup fix — preparationSessions is missing from the e2e user cleanup

1. Magic Message Bypass in Chat Routes

Preparation chat: apps/api/src/routes/preparation-chat.ts

After saving the user message (line 145-149) and before the readiness evaluator (line 163), detect the magic message:

Magic message: __E2E_COMPLETE_PREPARATION__
Guard: process.env.NODE_ENV === "development"

When detected:

• Build a synthetic "allReady" readiness state (set all topic criteria to "ready", allReady=true)
• Update preparationSessions with completed status + readinessState
• Stream a canned response: "Preparation complete! (E2E bypass)"
• Insert boundary system message with { preparationBoundary: true }
• Append \n\n---PREPARATION_COMPLETE--- to stream
• Return (skip LLM evaluator + discussion agent entirely)

Assessment chat: apps/api/src/routes/assessment-chat.ts

After saving the user message (line 174-179) and before the evaluator (line 193), detect the magic message:

Magic message: __E2E_COMPLETE_ASSESSMENT_<grade>__
  e.g., __E2E_COMPLETE_ASSESSMENT_E__, __E2E_COMPLETE_ASSESSMENT_S__, etc.
Guard: process.env.NODE_ENV === "development"
Regex: /^__E2E_COMPLETE_ASSESSMENT_([ESNU])__$/

When detected:

• Look up the grade's points from assessment.gradingScale
• Build portion grades: all portions get the requested grade
• Insert evaluation into assessmentEvaluations table
• Mark attempt as completed
• Stream a canned response: "Assessment complete with grade <grade>! (E2E bypass)"
• Insert boundary system message with { assessmentBoundary: true }
• Append \n\n---ASSESSMENT_COMPLETE--- to stream
• Return (skip LLM evaluator + interviewer entirely)

2. E2E Seed Endpoints: apps/api/src/routes/e2e.ts

POST /api/e2e/preparations/seed

Create a completed preparation session (parallel to existing e2e/assessments/seed):

Schema: { userId: string, preparationSlug?: string } (default: "understanding-media-ch1")

Steps:

1. Load preparation config via getPreparation(slug) to get topic structure
2. Create conversation with context: "preparation"
3. Insert canned messages (system + assistant greeting + user response + assistant completion)
4. Build a fully-ready readiness state (all criteria "ready", allReady=true)
5. Create preparationSessions record with status: "completed", the readiness state, and completedAt
6. Insert boundary system message
7. Return { sessionId, conversationId, messageIds }

POST /api/e2e/preparations/start-seed

Create an in-progress preparation session (for magic message testing):

Schema: { userId: string, preparationSlug?: string }

Steps:

1. Create conversation
2. Insert a canned opening assistant message
3. Create preparationSessions record with status: "in_progress", initial readiness state
4. Return { sessionId, conversationId }

POST /api/e2e/assessments/start-seed

Create an in-progress assessment attempt (for magic message testing):

Schema: { userId: string, assessmentSlug?: string }

Steps:

1. Create conversation with context: "assessment"
2. Insert a canned opening assistant message
3. Create assessmentAttempts record with status: "in_progress", initial evaluator state
4. Return { attemptId, conversationId }

3. Cleanup Fix: apps/api/src/routes/e2e.ts

Add preparationSessions deletion in both cleanup handlers (by-nonce and cleanup-all), BEFORE conversations are deleted (since prep sessions have a FK to conversations).

Import: preparationSessions from @repo/db/schema

In the cleanup loops, add:

await db.delete(preparationSessions).where(eq(preparationSessions.userId, user.id));

4. Add data-testid Attributes to Completion Summaries

apps/web/components/mdx/preparation-chat.tsx

• Outer div: data-testid="preparation-completion-summary"
• Count text: data-testid="preparation-completion-count"
• List: data-testid="preparation-completion-list"

apps/web/app/assessments/[slug]/page.tsx

• Outer div: data-testid="assessment-completion-summary"
• Count text: data-testid="assessment-completion-count"
• List: data-testid="assessment-completion-list"

5. E2E Tests

testing/e2e/tests/completion-visibility.spec.ts (default suite)

Uses seed endpoints (no LLM needed), tests the inline completion visibility feature.

Test: instructor sees preparation completion summary

1. Create instructor + student users
2. Seed a completed preparation for the student via POST /api/e2e/preparations/seed
3. Instructor navigates to /spring2026/readings/understanding-media-ch1
4. Assert preparation-completion-summary is visible
5. Assert preparation-completion-count contains "1 student"
6. Assert preparation-completion-list contains the student's name

Test: instructor sees assessment completion summary with grade

1. Create instructor + student users
2. Seed a completed assessment for the student via existing POST /api/e2e/assessments/seed
3. Instructor navigates to /assessments/turing-test
4. Assert assessment-completion-summary is visible
5. Assert assessment-completion-count contains "1 student"
6. Assert student name and grade badge "S" are visible

Test: completion summaries hidden when viewing as student

1. Create instructor user
2. Seed completed preparation + assessment for another student
3. Instructor enables "view as student" mode (set viewAsStudent cookie)
4. Navigate to reading page → assert preparation-completion-summary not visible
5. Navigate to assessment detail → assert assessment-completion-summary not visible

Test: student does not see completion summaries

1. Create student user + seed completed data for another student
2. Navigate to reading page → assert preparation-completion-summary not visible
3. Navigate to assessment detail → assert assessment-completion-summary not visible

testing/e2e/tests/magic-complete.spec.ts (request-only, not in default suite)

Tests the magic message bypass through the UI. Requires the start to work (LLM needed for initial message generation). Skips gracefully if LLM not configured.

Test: magic message completes preparation

1. Create student, start preparation via API (skip if fails)
2. Navigate to session page, wait for chat UI
3. Type __E2E_COMPLETE_PREPARATION__ and send
4. Wait for preparation-boundary testid to appear
5. Verify session status changed to completed

Test: magic message completes assessment with grade

1. Create student, start assessment via API (skip if fails)
2. Navigate to attempt page, wait for chat UI
3. Type __E2E_COMPLETE_ASSESSMENT_S__ and send
4. Wait for assessment-boundary testid to appear
5. Verify evaluation shows grade "S"

Alternative: testing/e2e/tests/magic-complete-seeded.spec.ts (default suite)

Tests the magic message bypass using start-seed endpoints (no LLM needed at all).

Test: magic message completes seeded preparation

1. Create student, start-seed a preparation via POST /api/e2e/preparations/start-seed
2. Navigate to session page
3. Type __E2E_COMPLETE_PREPARATION__ and send
4. Wait for preparation-boundary to appear

Test: magic message completes seeded assessment with grade

1. Create student, start-seed an assessment via POST /api/e2e/assessments/start-seed
2. Navigate to attempt page
3. Type __E2E_COMPLETE_ASSESSMENT_E__ and send
4. Wait for assessment-boundary to appear
5. Verify evaluation shows grade "E"

Playwright config: testing/e2e/playwright.config.ts

Add projects:

• completion-visibility — default suite (with deps)
• magic-complete — request-only (no deps, like assessment-lifecycle)
• magic-complete-seeded — default suite (with deps)

Key Files to Modify

Existing Code to Reuse

• getPreparation(slug) from @repo/agents — load prep config for seed endpoints
• getAssessment(slug) from @repo/agents — load assessment config
• buildInitialReadinessState() from apps/api/src/services/preparation-evaluator.ts — initial state for start-seed
• buildInitialEvaluatorState() from apps/api/src/services/assessment-evaluator.ts — initial state for start-seed
• Existing e2e/assessments/seed pattern in e2e.ts — reference for preparation seed
• auth.fixture.ts test patterns — user creation, context management

Verification

1. bun run tsc passes
2. CI=true bunx playwright test --project=completion-visibility — tests completion visibility
3. CI=true bunx playwright test --project=magic-complete-seeded — tests magic message bypass
4. CI=true bunx playwright test --project=magic-complete — tests magic message with LLM start (if configured)

If you need specific details from before exiting plan mode (like exact code snippets, error messages, or content you generated), read the full transcript at: ~/.claude/projects/-Users-challen-www-usingandunderstanding-ai/62d83b9f-e7a4-47a5-bad5-b535f132c93f.jsonl

Your task

First, run git status, git diff, and git log --oneline -10 to understand the current state.

Then add and commit all modified files with a descriptive message. Break the changes into multiple commits if appropriate. If there are untracked files, ask if they should be added or added to the appropriate .gitignore file. The user may also want to take over at this point, so provide an abort option as well. Always check changes for unnecessary debugging statements or logging that might have been accidentally included. Prompt the user if you find any, and offer to remove each one by one. Do not use interactive git staging (git add -p) as it does not work.

Can we make the chat window a bit easier to close on the educators page in thin mode? Maybe a close button at the top right?

Nice!

Your task

First, run git status, git diff, and git log --oneline -10 to understand the current state.

Then add and commit all modified files with a descriptive message. Break the changes into multiple commits if appropriate. If there are untracked files, ask if they should be added or added to the appropriate .gitignore file. The user may also want to take over at this point, so provide an abort option as well. Always check changes for unnecessary debugging statements or logging that might have been accidentally included. Prompt the user if you find any, and offer to remove each one by one. Do not use interactive git staging (git add -p) as it does not work.

Are we missing another assest on the remote machine? Here's the error: @repo/api:tsc: @repo/api:tsc: $ tsc --noEmit @repo/api:lint: cache miss, executing b56d8399c4c8b34a @repo/api:lint: @repo/api:lint: $ bunx eslint --max-warnings 0 . @repo/web:tsc: app/page.tsx:10:22 - error TS2307: Cannot find module '@/app/icon-512.png' or its corresponding type declarations. @repo/web:tsc: @repo/web:tsc: 10 import logoFull from "@/app/icon-512.png";

Your task

First, run git status, git diff, and git log --oneline -10 to understand the current state.

Then add and commit all modified files with a descriptive message. Break the changes into multiple commits if appropriate. If there are untracked files, ask if they should be added or added to the appropriate .gitignore file. The user may also want to take over at this point, so provide an abort option as well. Always check changes for unnecessary debugging statements or logging that might have been accidentally included. Prompt the user if you find any, and offer to remove each one by one. Do not use interactive git staging (git add -p) as it does not work.

Your task

First, run git status, git diff, and git log --oneline -10 to understand the current state.

Then add and commit all modified files with a descriptive message. Break the changes into multiple commits if appropriate. If there are untracked files, ask if they should be added or added to the appropriate .gitignore file. The user may also want to take over at this point, so provide an abort option as well. Always check changes for unnecessary debugging statements or logging that might have been accidentally included. Prompt the user if you find any, and offer to remove each one by one. Do not use interactive git staging (git add -p) as it does not work.

tl