@litocodes/persona-test 1.0.0 → 1.1.0

package/README.md

@@ -1,159 +1,139 @@
-# 🎭 Persona - AI-Powered User Testing Tool
+# 🎭 Persona
 
-An automated user-testing MVP that uses AI Agents to "look" at a website (via screenshots) and behave like specific human personas.
+> **Automated User Testing with Personality.**
 
-## 🏗️ Architecture
+Most E2E tests are brittle and boring. They check if a button *works*.  
+**Persona** checks if a button is *frustrating*.
 
+It spawns AI Agents with distinct psychological profiles to use your app — and records everything on video.
+
+[![npm version](https://badge.fury.io/js/@litocodes%2Fpersona-test.svg)](https://www.npmjs.com/package/@litocodes/persona-test)
+
+---
+
+## 🚀 The Agents
+
+| Agent | Personality | Goal |
+|-------|-------------|------|
+| 👴 **Grandpa Joe** | 70yo, low tech literacy, confused by modern UI | Find a phone number to call |
+| 🏎️ **Zoomer Zoe** | 20yo, impatient, rage-clicks, ignores instructions | Sign up in under 5 clicks |
+| 🕵️ **Skeptical Sam** | 40yo, paranoid about privacy, reads fine print | Find and read the Privacy Policy |
+| 💀 **Hacker Harry** | Security researcher, injects SQL/XSS payloads | Test all input fields for vulnerabilities |
+| 🧭 **Explorer Emma** | Curious, methodical, maps the entire site | Understand the site structure |
+
+---
+
+## 📦 Quick Start
+
+```bash
+# Run instantly with npx
+npx @litocodes/persona-test --url="https://your-site.com" --agent="zoomer"
+
+# Or install globally
+npm install -g @litocodes/persona-test
+persona --url="https://example.com" --agent="hacker"
 ```
-┌─────────────────────────────────────────────────────────────┐
-│                         PERSONA                              │
-├─────────────────────────────────────────────────────────────┤
-│                                                              │
-│  ┌──────────┐    ┌──────────┐    ┌──────────┐              │
-│  │  👁️ EYE   │───▶│  🧠 BRAIN │───▶│  🖐️ HAND  │              │
-│  │Playwright│    │ OpenRouter│    │ Locator  │              │
-│  │Screenshot│    │  Vision   │    │ Execute  │              │
-│  └──────────┘    └──────────┘    └──────────┘              │
-│       ▲                                  │                  │
-│       └──────────────────────────────────┘                  │
-│                    REPEAT LOOP                              │
-└─────────────────────────────────────────────────────────────┘
+
+### Requirements
+- Node.js 18+
+- Cerebras API key (free): https://cloud.cerebras.ai/
+
+```bash
+# Set your API key
+export CEREBRAS_API_KEY=csk-xxxxx
 ```
 
-1. **The Eye**: Playwright takes a JPEG screenshot of the current page
-2. **The Brain**: Screenshot + Persona System Prompt sent to Vision LLM
-3. **The Hand**: LLM returns JSON action with visual element description
-4. **The Locator**: Playwright semantic locators find and interact with elements
+---
 
-## 📦 Installation
+## 🎥 Video Recording
 
-```bash
-# Clone or create the project
-cd Persona
+Every session is automatically recorded to `videos/` folder:
 
-# Install dependencies
-npm install
+```
+videos/
+├── HACKER_2026-01-25T23-10-00_SUCCESS.webm
+├── ZOOMER_2026-01-25T23-15-00_ABANDONED.webm
+└── BOOMER_2026-01-25T23-20-00_MAX_ACTIONS.webm
+```
+
+**Pink highlight boxes** flash around elements before the AI clicks them — making the decision-making process visible.
+
+---
 
-# Install Playwright browsers
-npx playwright install chromium
+## 🧠 How It Works
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│   Parser    │ ──▶ │    Brain    │ ──▶ │    Hand     │
+│ (Cheerio)   │     │ (Cerebras)  │     │(Playwright) │
+└─────────────┘     └─────────────┘     └─────────────┘
+      │                   │                   │
+      ▼                   ▼                   ▼
+   DOM → Text         Decides:            Executes:
+   [1] BUTTON         "Click [3]"         page.click()
+   [2] INPUT          "Type XSS"          page.fill()
+   [3] LINK           "Quit"              
 ```
 
-## ⚙️ Configuration
+1. **Parser** converts HTML into a numbered element list
+2. **Brain** uses Cerebras AI (Llama 3.3 70B) to decide actions based on persona psychology
+3. **Hand** uses Playwright to execute actions with human-like behavior
+
+### Self-Healing
+- 🚫 **Blacklist**: Failed elements are marked `[BROKEN]` and avoided
+- 🧠 **Memory**: Last 3 actions tracked to prevent loops
+- 📝 **Form Logic**: AI knows to type before clicking submit
+
+---
 
-Create a `.env` file with your OpenRouter API key:
+## 📋 CLI Options
 
-```env
-OPENAI_API_KEY=your-openrouter-api-key-here
-OPENROUTER_MODEL=google/gemini-2.0-flash-exp:free
+```bash
+persona --url="<URL>" --agent="<AGENT>" [options]
+
+Options:
+  --url, -u       Target website URL (required)
+  --agent, -a     Persona: boomer, zoomer, skeptic, hacker, explorer
+  --record, -r    Record video (default: true)
+  --headless      Run without visible browser
+  --test          Test API connection
+  --help, -h      Show help
 ```
 
-Get your API key from: https://openrouter.ai/keys
+---
 
-## 🚀 Usage
+## 🛠️ Development
 
 ```bash
-# Basic usage
-node index.js --url="https://example.com" --agent="zoomer"
+# Clone
+git clone https://github.com/litocodes/persona-test
+cd persona-test
 
-# With options
-node index.js --url="https://google.com" --agent="boomer" --headless
+# Install dependencies
+npm install
 
-# Test API connection
-node index.js --test
+# Set API key
+echo "CEREBRAS_API_KEY=your-key" > .env
 
-# Show help
-node index.js --help
+# Run locally
+node index.js --url="https://example.com" --agent="zoomer"
 ```
 
-### CLI Options
-
-| Option | Alias | Description |
-|--------|-------|-------------|
-| `--url` | `-u` | Target website URL (required) |
-| `--agent` | `-a` | Persona to simulate (required) |
-| `--headless` | | Run browser without UI |
-| `--test` | | Test OpenRouter connection |
-| `--help` | `-h` | Show help message |
-
-## 👥 Available Personas
-
-### 🧓 Boomer (70yo)
-- Low tech literacy
-- Needs high contrast and large text
-- Quits if frustrated
-- **Goal**: Find the contact phone number
-
-### ⚡ Zoomer (20yo)
-- Extremely impatient
-- Scrolls fast, ignores instructions
-- Prefers social login
-- **Goal**: Sign up as fast as possible
-
-### 🔍 Skeptic (40yo)
-- Paranoid about privacy
-- Refuses all cookies
-- Checks Privacy Policy
-- **Goal**: Evaluate site trustworthiness
-
-### 💻 Hacker (30yo)
-- Security tester mindset
-- Probes input fields
-- Tests for SQL injection, XSS
-- **Goal**: Test inputs for vulnerabilities
-
-## 📝 How It Works
-
-1. Launch Chromium browser and navigate to target URL
-2. Take a compressed JPEG screenshot
-3. Send screenshot + persona prompt to Vision LLM
-4. LLM analyzes the page and returns a JSON action:
-   ```json
-   {
-     "action": "click",
-     "selector": "text=Sign Up",
-     "reason": "Found signup button, clicking to proceed"
-   }
-   ```
-5. Execute the action using Playwright semantic locators
-6. Repeat until goal achieved or max actions reached
-
-## 🎯 Action Types
-
-| Action | Description | Selector Format |
-|--------|-------------|-----------------|
-| `click` | Click an element | `text=Button Text` |
-| `type` | Type into input | `placeholder=Email` |
-| `scroll` | Scroll the page | `down`, `up`, `to=text` |
-| `done` | Goal achieved | N/A |
-| `quit` | Give up | N/A |
-
-## 🔧 Project Structure
+---
 
-```
-Persona/
-├── index.js       # Main CLI entry point
-├── brain.js       # OpenRouter vision client
-├── personas.js    # Persona definitions
-├── package.json   # Dependencies
-├── .env           # API configuration
-└── README.md      # This file
-```
+## 🎯 Use Cases
 
-## 🐛 Troubleshooting
+- **QA Testing**: Find UX issues before users do
+- **Security Audits**: Hacker Harry tests for SQL injection, XSS
+- **Accessibility**: See how confused users navigate your site
+- **Conversion Optimization**: Watch where Zoomers rage-quit your signup flow
 
-**"OPENAI_API_KEY not set"**
-- Create a `.env` file with your OpenRouter API key
+---
 
-**"Element not found"**
-- The AI's selector may not match exactly
-- The element might not be visible
-- Try running with `--headless=false` to see what's happening
+## 📜 License
 
-**"Connection failed"**
-- Check your API key
-- Run `node index.js --test` to verify connection
-- Check OpenRouter status
+MIT © 2026
 
-## 📄 License
+---
 
-MIT
+**Built in one night. Ships value.** 🚀

package/index.js

@@ -1,130 +1,232 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
-// index.js - With Memory State (History + Blacklist)
+// index.js - With Parallel Execution & Network Throttling 🚀
 
 import { chromium } from 'playwright';
 import minimist from 'minimist';
 import dotenv from 'dotenv';
+import fs from 'fs';
+import path from 'path';
 import { parsePage, findElementById } from './parser.js';
 import { getAgentAction, testConnection } from './brain.js';
-import { getPersona, listPersonas } from './personas.js';
+import { getPersona, listPersonas, PERSONAS } from './personas.js';
+import { generateReport } from './reporter.js';
 
 dotenv.config();
 
+// Network throttling presets (simulating real-world conditions)
+const NETWORK_PRESETS = {
+    'wifi': null, // No throttling
+    '4g': {
+        offline: false,
+        downloadThroughput: 4 * 1024 * 1024 / 8, // 4 Mbps
+        uploadThroughput: 3 * 1024 * 1024 / 8,   // 3 Mbps
+        latency: 20
+    },
+    '3g': {
+        offline: false,
+        downloadThroughput: 1.5 * 1024 * 1024 / 8, // 1.5 Mbps
+        uploadThroughput: 750 * 1024 / 8,          // 750 Kbps
+        latency: 100
+    },
+    'lagos-3g': { // Glo Nigeria 3G simulation
+        offline: false,
+        downloadThroughput: 400 * 1024 / 8,  // 400 Kbps (realistic)
+        uploadThroughput: 150 * 1024 / 8,    // 150 Kbps
+        latency: 400  // High latency
+    },
+    'edge': { // 2G/Edge
+        offline: false,
+        downloadThroughput: 50 * 1024 / 8,   // 50 Kbps
+        uploadThroughput: 20 * 1024 / 8,     // 20 Kbps
+        latency: 800
+    }
+};
+
 const argv = minimist(process.argv.slice(2), {
-    string: ['url', 'agent'],
-    boolean: ['headless', 'test', 'help'],
-    default: { headless: false },
-    alias: { u: 'url', a: 'agent', h: 'help' }
+    string: ['url', 'agent', 'network'],
+    boolean: ['headless', 'test', 'help', 'record', 'all'],
+    default: { headless: false, record: true, network: 'wifi' },
+    alias: { u: 'url', a: 'agent', h: 'help', r: 'record', n: 'network' }
 });
 
 if (argv.help) {
     console.log(`
-🎭 PERSONA - AI User Testing (Final Version)
-
-Usage: node index.js --url="<site>" --agent="<persona>"
-Personas: ${listPersonas().join(', ')}
+🎭 PERSONA - AI User Testing (Parallel + Network)
+
+Usage: 
+  persona --url="<site>" --agent="<persona>"
+  persona --url="<site>" --all              # Run ALL agents in parallel!
+
+Options:
+  --url, -u       Target URL (required)
+  --agent, -a     Single persona: ${listPersonas().join(', ')}
+  --all           Run ALL personas in parallel (Mission Control mode)
+  --network, -n   Network: wifi, 4g, 3g, lagos-3g, edge
+  --record, -r    Record video (default: true)
+  --headless      Run headless
+  --test          Test API connection
+
+Examples:
+  persona --url="https://example.com" --agent="zoomer" --network="lagos-3g"
+  persona --url="https://example.com" --all  # 5 browsers at once!
 `);
     process.exit(0);
 }
 
 if (argv.test) { await testConnection(); process.exit(0); }
-if (!argv.url || !argv.agent) { console.error('❌ --url and --agent required'); process.exit(1); }
+if (!argv.url) { console.error('❌ --url required'); process.exit(1); }
+if (!argv.agent && !argv.all) { console.error('❌ --agent or --all required'); process.exit(1); }
 
-const persona = getPersona(argv.agent);
-if (!persona) { console.error(`❌ Unknown: ${argv.agent}`); process.exit(1); }
+// Ensure folders exist
+if (!fs.existsSync('videos')) fs.mkdirSync('videos');
 
-async function main() {
-    console.log(`
-╔══════════════════════════════════════════════════════════════╗
-║           🎭 PERSONA - AI User Testing (Final)               ║
-╚══════════════════════════════════════════════════════════════╝
-`);
-    console.log(`🎯 ${argv.url}`);
-    console.log(`👤 ${persona.name} | Goal: ${persona.goal}\n`);
+/**
+ * Run a single agent session
+ */
+async function runAgent(url, persona, options = {}) {
+    const { network = 'wifi', record = true, headless = false } = options;
+    const networkConfig = NETWORK_PRESETS[network];
 
-    const browser = await chromium.launch({ headless: argv.headless });
-    const page = await browser.newPage({ viewport: { width: 1280, height: 800 } });
+    console.log(`\n🚀 [${persona.name}] Starting... (Network: ${network})`);
 
-    await page.goto(argv.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-    await page.waitForTimeout(2000);
-    console.log('✅ Page loaded\n');
+    const browser = await chromium.launch({ headless });
 
-    // 🧠 MEMORY STATE
-    const actionHistory = []; // Last 3 actions: [{action, id, text}]
-    const failedIds = [];     // Blacklisted IDs
+    const contextOptions = {
+        viewport: { width: 1280, height: 800 },
+        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0'
+    };
 
-    for (let step = 1; step <= persona.maxActions; step++) {
-        console.log(`┌─ Step ${step}/${persona.maxActions} ${'─'.repeat(44)}`);
+    if (record) {
+        contextOptions.recordVideo = { dir: 'videos/', size: { width: 1280, height: 800 } };
+    }
 
+    const context = await browser.newContext(contextOptions);
+    const page = await context.newPage();
+
+    // 🌐 Apply network throttling via CDP
+    if (networkConfig) {
+        const client = await context.newCDPSession(page);
+        await client.send('Network.emulateNetworkConditions', networkConfig);
+        console.log(`  📶 [${persona.name}] Network throttled to ${network}`);
+    }
+
+    try {
+        await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+        await page.waitForTimeout(2000);
+    } catch (e) {
+        console.log(`  ❌ [${persona.name}] Failed to load: ${e.message.substring(0, 50)}`);
+        await browser.close();
+        return { agent: persona.name, outcome: 'LOAD_FAILED' };
+    }
+
+    const actionHistory = [];
+    const failedIds = [];
+    let outcome = 'MAX_ACTIONS';
+
+    for (let step = 1; step <= persona.maxActions; step++) {
         const html = await page.content();
         const { domMap, elements, elementCount } = parsePage(html, failedIds);
-        console.log(`  📊 ${elementCount} elements (${failedIds.length} blacklisted)`);
 
-        if (elementCount === 0) {
-            console.log('  ⚠️ No elements');
-            await page.mouse.wheel(0, 300);
-            continue;
-        }
+        if (elementCount === 0) { await page.mouse.wheel(0, 300); continue; }
 
-        // Pass full history to brain
         const decision = await getAgentAction(domMap, persona, actionHistory);
 
-        console.log(`  🤖 ${decision.action.toUpperCase()} [${decision.elementId}]`);
-        console.log(`  💭 ${decision.reason}`);
-        console.log(`  😤 Frustration: ${decision.frustration}/10`);
+        console.log(`  🤖 [${persona.name}] Step ${step}: ${decision.action} [${decision.elementId}] - ${decision.reason?.substring(0, 40)}`);
 
-        if (decision.action === 'done' || decision.action === 'quit') {
-            console.log(`\n${'═'.repeat(60)}`);
-            console.log(decision.action === 'done' ? '  🎉 GOAL ACHIEVED!' : '  😤 GAVE UP');
-            console.log(`  ${decision.reason}`);
-            console.log(`${'═'.repeat(60)}`);
-            break;
-        }
+        if (decision.action === 'done') { outcome = 'SUCCESS'; break; }
+        if (decision.action === 'quit') { outcome = 'ABANDONED'; break; }
 
         const target = decision.elementId ? findElementById(elements, decision.elementId) : null;
-
-        if (!target) {
-            console.log('  ❌ Invalid ID');
-            continue;
-        }
+        if (!target) continue;
 
         try {
             const locator = page.locator(target.selector).first();
+            await locator.highlight();
+            await page.waitForTimeout(200);
 
             if (decision.action === 'click') {
                 await locator.click({ timeout: 4000 });
-                console.log(`  🖱️ Clicked: "${target.text}"`);
             } else if (decision.action === 'type') {
-                const text = decision.inputText || persona.testStrings?.sql || 'test_user';
-                await locator.fill(text, { timeout: 4000 });
-                console.log(`  ⌨️ Typed: "${text}"`);
-            } else if (decision.action === 'scroll') {
-                await page.mouse.wheel(0, 400);
-                console.log('  📜 Scrolled');
+                await locator.fill(decision.inputText || persona.testStrings?.sql || 'test', { timeout: 4000 });
             }
 
-            // ✅ Add to history (keep last 3)
             actionHistory.push({ action: decision.action, id: decision.elementId, text: target.text });
             if (actionHistory.length > 3) actionHistory.shift();
 
         } catch (e) {
-            const msg = e.message.split('\n')[0].substring(0, 50);
-            console.log(`  ⚠️ FAILED: ${msg}`);
-
-            // 🚨 Add to blacklist
             failedIds.push(decision.elementId);
-            console.log(`  🚫 ID [${decision.elementId}] blacklisted`);
         }
 
-        await page.waitForTimeout(2000);
-        console.log(`└${'─'.repeat(58)}┘`);
+        await page.waitForTimeout(1500);
     }
 
-    console.log('\n📋 History:', actionHistory.map(h => `${h.action}[${h.id}]`).join(' → '));
-    console.log('🚫 Blacklist:', failedIds.length ? failedIds.join(', ') : 'none');
+    // Save video
+    const videoPath = record ? await page.video()?.path() : null;
+    await context.close();
     await browser.close();
-    console.log('✅ Done\n');
+
+    if (record && videoPath && fs.existsSync(videoPath)) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+        const filename = `${persona.name.replace(/\s+/g, '_')}_${network}_${timestamp}_${outcome}.webm`;
+        fs.renameSync(videoPath, path.join('videos', filename));
+        console.log(`  🎥 [${persona.name}] Saved: videos/${filename}`);
+    }
+
+    // 📝 Generate QA Report
+    await generateReport(persona, url, actionHistory, failedIds, outcome, network);
+
+    console.log(`  ✅ [${persona.name}] Finished: ${outcome}`);
+    return { agent: persona.name, outcome, network };
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+    console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║      🎭 PERSONA - AI User Testing (Parallel + Network)       ║
+╚══════════════════════════════════════════════════════════════╝
+`);
+    console.log(`🎯 Target: ${argv.url}`);
+    console.log(`📶 Network: ${argv.network}`);
+
+    const options = {
+        network: argv.network,
+        record: argv.record,
+        headless: argv.headless
+    };
+
+    if (argv.all) {
+        // 🚀 PARALLEL MODE: Run ALL agents at once!
+        console.log(`\n🔥 MISSION CONTROL: Launching ALL ${listPersonas().length} agents in parallel!\n`);
+
+        const agents = listPersonas().map(name => getPersona(name));
+
+        const results = await Promise.all(
+            agents.map(persona => runAgent(argv.url, persona, options))
+        );
+
+        // Summary
+        console.log(`\n${'═'.repeat(60)}`);
+        console.log('📊 MISSION REPORT');
+        console.log('═'.repeat(60));
+        results.forEach(r => {
+            const icon = r.outcome === 'SUCCESS' ? '✅' : r.outcome === 'ABANDONED' ? '😤' : '⏱️';
+            console.log(`  ${icon} ${r.agent}: ${r.outcome} (${r.network})`);
+        });
+        console.log('═'.repeat(60));
+
+    } else {
+        // Single agent mode
+        const persona = getPersona(argv.agent);
+        if (!persona) { console.error(`❌ Unknown: ${argv.agent}`); process.exit(1); }
+
+        await runAgent(argv.url, persona, options);
+    }
+
+    console.log('\n✅ All done!\n');
 }
 
 main().catch(e => console.error('💀', e));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litocodes/persona-test",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "AI User Testing with Personality - Simulate real users breaking your website",
   "main": "index.js",
   "type": "module",
@@ -39,4 +39,4 @@
     "openai": "^4.77.0",
     "playwright": "^1.49.1"
   }
-}
+}

package/reporter.js

@@ -0,0 +1,92 @@
+// reporter.js - AI-Generated QA Reports
+// Uses Cerebras to write professional test reports from session data
+
+import OpenAI from 'openai';
+import dotenv from 'dotenv';
+import fs from 'fs';
+import path from 'path';
+
+dotenv.config();
+
+const openai = new OpenAI({
+    baseURL: 'https://api.cerebras.ai/v1',
+    apiKey: process.env.CEREBRAS_API_KEY
+});
+
+const MODEL = process.env.CEREBRAS_MODEL || 'llama-3.3-70b';
+
+/**
+ * Generate a markdown report from test session data
+ */
+export async function generateReport(agent, url, actionHistory, failedIds, outcome, network) {
+    console.log('\n📝 Generating QA Report via Cerebras...');
+
+    const historyStr = actionHistory.length > 0
+        ? actionHistory.map((h, i) => `${i + 1}. ${h.action.toUpperCase()} [${h.id}] "${h.text}"`).join('\n')
+        : 'No actions recorded';
+
+    const prompt = `You are a Senior QA Engineer & UX Specialist.
+You just watched an AI Agent test a website. Write a professional but personality-driven report.
+
+--- AGENT PROFILE ---
+Name: ${agent.name}
+Age: ${agent.age}
+Traits: ${agent.behavior}
+Goal: ${agent.goal}
+
+--- TEST SESSION ---
+URL: ${url}
+Network: ${network}
+Outcome: ${outcome}
+Failed Elements: ${failedIds.length > 0 ? failedIds.join(', ') : 'None'}
+
+Action Log:
+${historyStr}
+
+--- WRITE A MARKDOWN REPORT ---
+Include:
+1. **Result**: Pass/Fail with emoji
+2. **Summary**: 2-3 sentences describing what happened
+3. **Friction Points**: Where did the agent struggle? (loops, failed clicks, confusion)
+4. **Recommendations**: 1-2 specific technical fixes (e.g., "Add loading state", "Fix aria-labels")
+5. **Persona Quote**: A funny one-liner in character (e.g., Zoomer: "ugh why is this so slow")
+
+Keep it concise. Sound like the persona where appropriate.`;
+
+    try {
+        const response = await openai.chat.completions.create({
+            model: MODEL,
+            messages: [
+                { role: 'system', content: 'You are an expert QA reporter who writes concise, actionable test reports.' },
+                { role: 'user', content: prompt }
+            ],
+            max_tokens: 500,
+            temperature: 0.7
+        });
+
+        const reportText = response.choices[0]?.message?.content || 'Report generation failed';
+
+        // Save to file
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+        const agentName = agent.name.replace(/\s+/g, '_');
+        const filename = `REPORT_${agentName}_${timestamp}.md`;
+
+        if (!fs.existsSync('reports')) fs.mkdirSync('reports');
+
+        const filepath = path.join('reports', filename);
+        fs.writeFileSync(filepath, `# QA Report: ${agent.name}\n\n${reportText}`);
+
+        console.log(`✅ Report saved: ${filepath}`);
+        console.log(`\n${'─'.repeat(50)}`);
+        console.log(reportText.substring(0, 400) + (reportText.length > 400 ? '...' : ''));
+        console.log('─'.repeat(50));
+
+        return filepath;
+
+    } catch (error) {
+        console.error('❌ Report generation failed:', error.message);
+        return null;
+    }
+}
+
+export default { generateReport };

package/reports/REPORT_Zoomer_Zoe_2026-01-25T22-25-42.md

@@ -0,0 +1,8 @@
+# QA Report: Zoomer Zoe
+
+### Test Report: Zoomer Zoe on Hacker News
+#### **Result**: 🚫 Fail
+#### **Summary**: Zoomer Zoe attempted to login to Hacker News, but ended up in a password reset loop. The agent clicked "login", then "Forgot your password?", and finally "Send reset email" without completing the intended sign-up process. This behavior indicates frustration with the login process.
+#### **Friction Points**: The agent struggled with the login form, ignoring instructions and getting stuck in a loop. The presence of a "Forgot your password?" link before even attempting to login suggests the agent was already looking for an escape route.
+#### **Recommendations**: Add a clear "Sign up" or "Create account" button on the initial page to streamline the onboarding process. Consider simplifying the login form to reduce friction.
+#### **Persona Quote**: Zoomer Zoe: "Ugh, can't I just use Google to login already?!"

package/.env

@@ -1,11 +0,0 @@
-# Cerebras API Configuration
-# Get your API key from: https://cloud.cerebras.ai/
-
-# Your Cerebras API Key (required)
-CEREBRAS_API_KEY=csk-fptmf5m4hxn84c3jx95yw9tce2v6yxkhpjkwjpkxd88cmrjp
-
-# Model to use (Cerebras models - very fast!)
-# Options:
-#   - llama-3.3-70b (recommended - smart and fast)
-#   - llama-3.1-8b (lightweight, fastest)
-CEREBRAS_MODEL=llama-3.3-70b