cbrowser 8.3.0 → 8.3.1

package/README.md

@@ -579,6 +579,96 @@ mobile-user      | pass    | 28.1s   | 1        | Scroll issue
 
 This helps identify which user groups struggle with your interface and where the friction points are, so you can prioritize UX improvements based on data rather than assumptions.
 
+### Cognitive User Simulation (v8.2.5)
+
+Go beyond timing and click patterns—simulate how users actually **think**. Cognitive journeys model realistic decision-making with abandonment detection, frustration tracking, and genuine cognitive traits.
+
+**Why it matters:** Traditional persona testing simulates motor behavior (slow clicks, typos). Cognitive simulation models mental behavior: "Would a confused first-timer give up here? Would they even notice that button?"
+
+```bash
+# Run a cognitive journey (requires Anthropic API key)
+npx cbrowser config set-api-key
+npx cbrowser cognitive-journey \
+  --persona first-timer \
+  --start "https://example.com" \
+  --goal "sign up for an account"
+
+# With options
+npx cbrowser cognitive-journey \
+  --persona elderly-user \
+  --start "https://example.com" \
+  --goal "find the help page" \
+  --max-steps 50 \
+  --verbose
+```
+
+**Cognitive Traits (7 dimensions):**
+
+| Trait | What it measures | Example impact |
+|-------|------------------|----------------|
+| `patience` | How quickly they give up | Low patience → abandons after 3 failed attempts |
+| `riskTolerance` | Willingness to click unfamiliar elements | Low risk → avoids buttons without clear labels |
+| `comprehension` | Ability to understand UI conventions | Low comprehension → misreads icons |
+| `persistence` | Tendency to retry vs. try something else | High persistence → keeps trying same approach |
+| `curiosity` | Tendency to explore vs. stay focused | High curiosity → clicks interesting sidebars |
+| `workingMemory` | Remembers what they've tried | Low memory → repeats failed actions |
+| `readingTendency` | Reads content vs. scans for CTAs | High reading → notices inline instructions |
+
+**Attention Patterns:**
+
+- `targeted` — Direct path to goal (power users)
+- `f-pattern` — Scans top, then left side (web convention)
+- `z-pattern` — Diagonal scanning (marketing pages)
+- `exploratory` — Random exploration (curious users)
+- `sequential` — Top-to-bottom reading (thorough users)
+- `thorough` — Reads everything carefully (careful users)
+- `skim` — Rapid scanning for keywords (impatient users)
+
+**Abandonment Detection:**
+
+The simulation automatically stops when a realistic user would give up:
+
+| Trigger | Threshold | Monologue |
+|---------|-----------|-----------|
+| Patience depleted | `< 0.1` | "This is taking too long..." |
+| Too confused | `> 0.8` for 30s | "I have no idea what to do..." |
+| Too frustrated | `> 0.85` | "This is so frustrating..." |
+| No progress | 10+ steps, `< 0.1` progress | "I'm not getting anywhere..." |
+| Stuck in loop | Same pages 3x | "I keep ending up here..." |
+
+**Output includes:**
+- Goal achievement status
+- Abandonment reason (if applicable)
+- Step-by-step decision trace with reasoning
+- Friction points with screenshots
+- Cognitive state over time (patience, confusion, frustration)
+- Full internal monologue
+
+**MCP Integration (Claude Desktop/Code):**
+
+For Claude Desktop or Claude Code users, use the MCP tools instead:
+
+```typescript
+// Initialize cognitive journey
+const profile = await mcp.cognitive_journey_init({
+  persona: "first-timer",
+  goal: "sign up as a provider",
+  startUrl: "https://example.com"
+});
+
+// After each action, update state
+const state = await mcp.cognitive_journey_update_state({
+  sessionId: profile.sessionId,
+  patienceChange: -0.05,
+  confusionChange: 0.1,
+  currentUrl: "https://example.com/register"
+});
+
+if (state.shouldAbandon) {
+  console.log(`User gave up: ${state.abandonmentReason}`);
+}
+```
+
 **Custom persona creation:**
 
 ```bash
@@ -704,7 +794,7 @@ Add to Claude Desktop config (`~/.config/claude-desktop/config.json`):
 }
 ```
 
-### Available MCP Tools (33 total)
+### Available MCP Tools (36 total)
 
 | Category | Tools |
 |----------|-------|
@@ -714,6 +804,7 @@ Add to Claude Desktop config (`~/.config/claude-desktop/config.json`):
 | **Testing** | `generate_tests`, `test_suite`, `repair_tests`, `flaky_check` |
 | **Visual** | `visual_baseline`, `visual_compare`, `responsive_test`, `cross_browser_test`, `ab_compare` |
 | **Personas** | `journey`, `compare_personas`, `create_persona`, `list_personas` |
+| **Cognitive** | `cognitive_journey_init`, `cognitive_journey_update_state`, `list_cognitive_personas` |
 | **Sessions** | `save_session`, `load_session`, `list_sessions`, `delete_session` |
 | **Analysis** | `hunt_bugs`, `chaos_test`, `performance_audit`, `dismiss_overlay` |
 | **Utilities** | `heal_stats`, `list_baselines`, `status` |
@@ -784,6 +875,26 @@ Create `.cbrowserrc.json`:
 }
 ```
 
+### API Key Configuration (for Cognitive Journeys)
+
+Cognitive journeys require an Anthropic API key for standalone CLI usage:
+
+```bash
+# Set your API key (stored in ~/.cbrowserrc.json)
+npx cbrowser config set-api-key
+
+# View configured key (masked)
+npx cbrowser config show-api-key
+
+# Remove API key
+npx cbrowser config remove-api-key
+
+# Set custom model (default: claude-sonnet-4-20250514)
+npx cbrowser config set-model claude-opus-4-20250514
+```
+
+**Note:** MCP users (Claude Desktop/Code) don't need API key configuration—cognitive journeys use the existing Claude session.
+
 ---
 
 ## Multi-Browser Support
@@ -893,6 +1004,7 @@ See the [`examples/`](examples/) directory:
 - [`smart-automation.ts`](examples/smart-automation.ts) - Smart click, assertions, test generation
 - [`visual-testing.ts`](examples/visual-testing.ts) - AI visual regression, cross-browser, responsive, A/B comparison
 - [`remote-mcp.ts`](examples/remote-mcp.ts) - Remote MCP server, Auth0 OAuth, demo server setup
+- [`cognitive-journey.ts`](examples/cognitive-journey.ts) - Cognitive user simulation with personas, abandonment, and friction detection
 
 ### Workflow Recipes
 - [`workflows/e2e-login-checkout.md`](examples/workflows/e2e-login-checkout.md) - End-to-end login and checkout flow with session persistence
@@ -900,6 +1012,7 @@ See the [`examples/`](examples/) directory:
 - [`workflows/accessibility-audit.md`](examples/workflows/accessibility-audit.md) - Accessibility bug hunting with persona-based a11y testing
 - [`workflows/chaos-resilience-testing.md`](examples/workflows/chaos-resilience-testing.md) - Chaos engineering: network failures, slow responses, element removal
 - [`workflows/persona-comparison-report.md`](examples/workflows/persona-comparison-report.md) - Multi-persona comparison with heatmaps and prioritized recommendations
+- [`workflows/cognitive-journey-testing.md`](examples/workflows/cognitive-journey-testing.md) - Cognitive user simulation with abandonment detection and friction analysis
 
 ### CI/CD Integration
 - [`ci-cd/github-actions.yml`](examples/ci-cd/github-actions.yml) - GitHub Actions workflow for NL tests, visual and perf regression
@@ -909,13 +1022,16 @@ See the [`examples/`](examples/) directory:
 ### Natural Language Tests
 - [`natural-language-tests/e-commerce-suite.txt`](examples/natural-language-tests/e-commerce-suite.txt) - E-commerce guest checkout, search, and mobile tests
 - [`natural-language-tests/auth-flow-suite.txt`](examples/natural-language-tests/auth-flow-suite.txt) - Login, invalid credentials, and password reset flows
+- [`natural-language-tests/provider-discovery-journey.txt`](examples/natural-language-tests/provider-discovery-journey.txt) - Cognitive journey for provider discovery and registration
 - [`natural-language-tests/README.md`](examples/natural-language-tests/README.md) - NL test syntax reference and tips
 
 ### Configuration Templates
 - [`journeys/checkout-flow.json`](examples/journeys/checkout-flow.json) - Checkout journey definition
 - [`journeys/signup-flow.json`](examples/journeys/signup-flow.json) - User registration journey
+- [`journeys/cognitive-discovery-journey.json`](examples/journeys/cognitive-discovery-journey.json) - Cognitive journey with custom traits and abandonment thresholds
 - [`personas/custom-persona.json`](examples/personas/custom-persona.json) - QA tester persona template
 - [`personas/accessibility-tester.json`](examples/personas/accessibility-tester.json) - Visual impairment persona with screen magnification
+- [`personas/cognitive-curious-explorer.json`](examples/personas/cognitive-curious-explorer.json) - Full cognitive persona with traits, attention pattern, and internal voice
 
 ## Troubleshooting
 

package/examples/cognitive-journey.ts

@@ -0,0 +1,146 @@
+/**
+ * Cognitive User Simulation Example
+ *
+ * This example demonstrates how to run autonomous, goal-driven user simulations
+ * where the AI acts as a realistic persona with cognitive traits and abandonment detection.
+ *
+ * Cognitive journeys go beyond timing and click patterns—they model how users actually
+ * think, including frustration, confusion, patience depletion, and genuine abandonment.
+ */
+
+import { runCognitiveJourney, setAnthropicApiKey, isApiKeyConfigured } from 'cbrowser';
+
+// Ensure API key is configured
+if (!isApiKeyConfigured()) {
+  console.log('API key not configured. Run: npx cbrowser config set-api-key');
+  process.exit(1);
+}
+
+// Example 1: Basic cognitive journey
+async function basicJourney() {
+  console.log('\n=== Basic Cognitive Journey ===\n');
+
+  const result = await runCognitiveJourney({
+    persona: 'first-timer',
+    startUrl: 'https://example.com',
+    goal: 'sign up for an account',
+    verbose: true,
+  });
+
+  console.log('Goal achieved:', result.goalAchieved);
+  console.log('Steps taken:', result.steps.length);
+
+  if (!result.goalAchieved && result.abandonmentReason) {
+    console.log('User gave up:', result.abandonmentReason);
+    console.log('Final thought:', result.finalThought);
+  }
+
+  // Show friction points
+  if (result.frictionPoints.length > 0) {
+    console.log('\nFriction points detected:');
+    for (const fp of result.frictionPoints) {
+      console.log(`  - ${fp.type}: ${fp.monologue}`);
+    }
+  }
+}
+
+// Example 2: Journey with custom traits
+async function customTraitsJourney() {
+  console.log('\n=== Journey with Custom Traits ===\n');
+
+  const result = await runCognitiveJourney({
+    persona: 'elderly-user',
+    startUrl: 'https://example.com',
+    goal: 'find the help page',
+    customTraits: {
+      patience: 0.3,        // Very patient
+      riskTolerance: 0.2,   // Cautious about clicking unfamiliar things
+      comprehension: 0.4,   // Struggles with UI conventions
+      readingTendency: 0.9, // Reads everything carefully
+    },
+    maxSteps: 30,
+    verbose: true,
+  });
+
+  console.log('Journey completed');
+  console.log('Average confusion level:',
+    result.steps.reduce((sum, s) => sum + s.stateAfter.confusionLevel, 0) / result.steps.length
+  );
+}
+
+// Example 3: Journey with step callbacks
+async function journeyWithCallbacks() {
+  console.log('\n=== Journey with Step Callbacks ===\n');
+
+  const result = await runCognitiveJourney({
+    persona: 'impatient-user',
+    startUrl: 'https://example.com',
+    goal: 'complete checkout',
+    onStep: (step) => {
+      console.log(`Step ${step.stepNumber}: ${step.action}`);
+      console.log(`  Reasoning: ${step.reasoning}`);
+      console.log(`  Patience: ${(step.stateAfter.patienceRemaining * 100).toFixed(0)}%`);
+      console.log(`  Confusion: ${(step.stateAfter.confusionLevel * 100).toFixed(0)}%`);
+
+      if (step.stateAfter.patienceRemaining < 0.3) {
+        console.log('  ⚠️ User patience running low!');
+      }
+    },
+  });
+
+  console.log('\nJourney finished');
+}
+
+// Example 4: Compare cognitive traits across personas
+async function comparePersonas() {
+  console.log('\n=== Comparing Personas ===\n');
+
+  const personas = ['power-user', 'first-timer', 'elderly-user', 'impatient-user'];
+  const results = [];
+
+  for (const persona of personas) {
+    console.log(`Running journey as ${persona}...`);
+
+    const result = await runCognitiveJourney({
+      persona,
+      startUrl: 'https://example.com',
+      goal: 'find pricing information',
+      maxSteps: 20,
+    });
+
+    results.push({
+      persona,
+      goalAchieved: result.goalAchieved,
+      steps: result.steps.length,
+      abandonmentReason: result.abandonmentReason,
+      frictionPoints: result.frictionPoints.length,
+    });
+  }
+
+  console.log('\n=== Comparison Results ===\n');
+  console.log('Persona         | Success | Steps | Friction | Abandonment Reason');
+  console.log('----------------+---------+-------+----------+-------------------');
+
+  for (const r of results) {
+    console.log(
+      `${r.persona.padEnd(15)} | ${r.goalAchieved ? 'pass   ' : 'fail   '} | ${
+        String(r.steps).padStart(5)
+      } | ${String(r.frictionPoints).padStart(8)} | ${r.abandonmentReason || '-'}`
+    );
+  }
+}
+
+// Run examples
+async function main() {
+  try {
+    await basicJourney();
+    // await customTraitsJourney();
+    // await journeyWithCallbacks();
+    // await comparePersonas();
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/examples/journeys/cognitive-discovery-journey.json

@@ -0,0 +1,40 @@
+{
+  "name": "Provider Discovery Journey",
+  "description": "Simulates a provider who found the site organically and explores with curiosity before potentially registering",
+  "persona": "first-timer",
+  "startUrl": "https://example.com",
+  "goal": "explore the site and decide whether to register as a provider",
+  "customTraits": {
+    "patience": 0.7,
+    "riskTolerance": 0.5,
+    "comprehension": 0.6,
+    "persistence": 0.6,
+    "curiosity": 0.8,
+    "workingMemory": 0.7,
+    "readingTendency": 0.6
+  },
+  "options": {
+    "maxSteps": 50,
+    "maxTime": 300000,
+    "verbose": true
+  },
+  "expectedBehaviors": [
+    "Explores homepage to understand what the site offers",
+    "Looks for provider-specific information",
+    "Reads about benefits and pricing",
+    "Investigates trust signals (reviews, testimonials)",
+    "May abandon if value proposition is unclear",
+    "May proceed to registration if convinced"
+  ],
+  "successCriteria": [
+    "Reaches provider registration page",
+    "OR makes informed decision to not register (legitimate abandonment)"
+  ],
+  "frictionPointsToWatch": [
+    "Unclear provider vs customer distinction",
+    "Hidden pricing information",
+    "Confusing navigation",
+    "Aggressive signup prompts",
+    "Missing social proof"
+  ]
+}

package/examples/natural-language-tests/provider-discovery-journey.txt

@@ -0,0 +1,74 @@
+# Test: Provider Discovery Journey
+# Simulates a provider who found the site organically and explores before registering
+# Uses cognitive journey concepts - tests what a real curious first-timer would do
+
+# Initial landing
+go to https://example.com
+wait 2 seconds
+verify page contains "Welcome" or "Home"
+take screenshot
+
+# Explore to understand what the site offers
+click the main navigation or menu
+wait 1 second
+verify page contains navigation links
+take screenshot
+
+# Look for provider-specific information
+click "Providers" or "For Providers" or "Become a Provider"
+wait 2 seconds
+verify url contains "provider" or page contains "provider"
+take screenshot
+
+# Read about benefits (curiosity behavior)
+scroll down 3 times
+verify page contains "benefits" or "features" or "why join"
+take screenshot
+
+# Look for pricing information
+click "Pricing" or "Plans" or scroll to pricing section
+wait 1 second
+verify page contains "$" or "pricing" or "cost" or "free"
+take screenshot
+
+# Check trust signals (reviews, testimonials)
+scroll down
+verify page contains "review" or "testimonial" or "trusted by"
+take screenshot
+
+# Make decision - proceed to registration
+click "Sign Up" or "Register" or "Get Started" or "Join"
+wait 2 seconds
+verify url contains "register" or "signup" or page contains "Create"
+take screenshot
+
+# Test: Provider Discovery - Confused Path
+# Tests abandonment behavior when value proposition is unclear
+
+go to https://example.com
+wait 1 second
+
+# Try to find provider info through unclear navigation
+click "Services" or "About" or first navigation link
+wait 2 seconds
+take screenshot
+
+# User gets confused - not finding provider-specific content
+scroll down
+verify page contains some content
+take screenshot
+
+# Back to try again (persistence behavior)
+click browser back or "Home" or logo
+wait 1 second
+take screenshot
+
+# Try a different path
+click "Contact" or "Help" or "FAQ"
+wait 1 second
+verify page loaded
+take screenshot
+
+# Note: In a real cognitive journey, the AI would evaluate
+# whether the user would abandon at this point based on
+# patience depletion and confusion level

package/examples/personas/cognitive-curious-explorer.json

@@ -0,0 +1,48 @@
+{
+  "name": "curious-explorer",
+  "displayName": "Curious Explorer",
+  "description": "A user who found the site through search and wants to understand everything before committing. High curiosity, moderate patience, reads content thoroughly.",
+  "behaviorProfile": {
+    "avgReactionTime": 1200,
+    "reactionTimeVariance": 400,
+    "typoRate": 0.02,
+    "doubleClickRate": 0.01,
+    "missClickRate": 0.03,
+    "scrollSpeed": "slow",
+    "readingSpeed": "slow",
+    "focusDuration": 8000,
+    "mouseJitter": 3,
+    "pauseBeforeAction": 1500
+  },
+  "cognitiveTraits": {
+    "patience": 0.7,
+    "riskTolerance": 0.4,
+    "comprehension": 0.7,
+    "persistence": 0.5,
+    "curiosity": 0.9,
+    "workingMemory": 0.6,
+    "readingTendency": 0.8
+  },
+  "attentionPattern": "exploratory",
+  "decisionStyle": "deliberate",
+  "viewport": {
+    "width": 1440,
+    "height": 900
+  },
+  "abandonmentThresholds": {
+    "minPatience": 0.15,
+    "maxConfusion": 0.75,
+    "maxFrustration": 0.80,
+    "maxStepsWithoutProgress": 12,
+    "loopDetectionThreshold": 3
+  },
+  "internalVoice": {
+    "style": "thoughtful",
+    "examples": [
+      "Hmm, let me see what this section is about...",
+      "Interesting, but I'm not sure if this applies to me",
+      "I wonder what happens if I click here",
+      "This is taking a while, but I want to understand fully"
+    ]
+  }
+}

package/examples/workflows/cognitive-journey-testing.md

@@ -0,0 +1,199 @@
+# Cognitive Journey Testing Workflow
+
+This workflow demonstrates how to use CBrowser's cognitive user simulation to test whether real users can complete tasks on your site.
+
+## Why Cognitive Testing?
+
+Traditional persona testing simulates **motor behavior**: slow clicks, typos, mobile viewport. Cognitive testing simulates **mental behavior**:
+
+- "Would a confused user notice that button?"
+- "Would an impatient user give up at this step?"
+- "Does the UI communicate clearly enough for a first-timer?"
+
+## Prerequisites
+
+```bash
+# Install CBrowser
+npm install cbrowser
+
+# Configure API key (for standalone CLI usage)
+npx cbrowser config set-api-key
+
+# Or use via MCP with Claude Desktop/Code (no API key needed)
+```
+
+## Basic Cognitive Journey
+
+```bash
+# Run a cognitive journey as a first-timer
+npx cbrowser cognitive-journey \
+  --persona first-timer \
+  --start "https://your-site.com" \
+  --goal "sign up for an account"
+```
+
+## Understanding the Output
+
+A cognitive journey produces:
+
+1. **Goal Status**: Did the simulated user achieve their goal?
+2. **Abandonment Reason**: If they gave up, why?
+3. **Decision Trace**: Step-by-step reasoning with internal monologue
+4. **Friction Points**: Moments where the user struggled
+5. **Cognitive State Over Time**: Patience, confusion, frustration levels
+
+## Cognitive Traits Explained
+
+Each persona has 7 cognitive traits that affect their behavior:
+
+| Trait | Low Value Behavior | High Value Behavior |
+|-------|-------------------|---------------------|
+| `patience` | Gives up quickly | Keeps trying for a long time |
+| `riskTolerance` | Only clicks obvious, safe elements | Clicks unfamiliar buttons |
+| `comprehension` | Misinterprets UI conventions | Understands quickly |
+| `persistence` | Tries something different after failure | Keeps retrying same approach |
+| `curiosity` | Stays focused on goal | Explores interesting sidebars |
+| `workingMemory` | Forgets what they tried, repeats failures | Remembers and avoids repetition |
+| `readingTendency` | Scans for buttons, ignores text | Reads instructions carefully |
+
+## Testing Strategy
+
+### 1. Test Critical Flows with Multiple Personas
+
+```bash
+# Test signup with different user types
+for persona in first-timer elderly-user impatient-user power-user; do
+  npx cbrowser cognitive-journey \
+    --persona $persona \
+    --start "https://your-site.com" \
+    --goal "complete signup"
+done
+```
+
+### 2. Identify Abandonment Points
+
+Watch for patterns where multiple personas give up:
+
+```bash
+npx cbrowser cognitive-journey \
+  --persona impatient-user \
+  --start "https://your-site.com" \
+  --goal "find pricing" \
+  --verbose
+```
+
+If the impatient user abandons at step 3 with "This is taking too long," you have a friction point to fix.
+
+### 3. Test with Custom Traits
+
+Create a custom persona that represents your target user:
+
+```bash
+# Save to examples/personas/target-customer.json
+{
+  "name": "target-customer",
+  "cognitiveTraits": {
+    "patience": 0.5,
+    "riskTolerance": 0.3,
+    "comprehension": 0.6,
+    "persistence": 0.4,
+    "curiosity": 0.7,
+    "workingMemory": 0.6,
+    "readingTendency": 0.4
+  }
+}
+```
+
+### 4. Compare Personas Side-by-Side
+
+```bash
+npx cbrowser compare-personas \
+  --start "https://your-site.com" \
+  --goal "complete checkout" \
+  --personas power-user,first-timer,elderly-user,mobile-user
+```
+
+## MCP Integration (Claude Desktop/Code)
+
+For Claude users, cognitive journeys integrate via MCP tools:
+
+```typescript
+// Initialize the journey
+const profile = await mcp.cognitive_journey_init({
+  persona: "first-timer",
+  goal: "sign up as a provider",
+  startUrl: "https://your-site.com"
+});
+
+// Claude now acts as the persona, making decisions
+// After each action, update the cognitive state:
+const state = await mcp.cognitive_journey_update_state({
+  sessionId: profile.sessionId,
+  patienceChange: -0.05,  // Small depletion
+  confusionChange: 0.1,   // Got a bit confused
+  currentUrl: "https://your-site.com/register"
+});
+
+// Check if user would abandon
+if (state.shouldAbandon) {
+  console.log(`User gave up: ${state.abandonmentReason}`);
+  console.log(`Final thought: ${state.finalThought}`);
+}
+```
+
+## Interpreting Results
+
+### Successful Journey
+```
+Goal achieved: true
+Steps: 8
+Time: 45s
+Final thought: "That was pretty straightforward!"
+```
+
+### Abandoned Journey
+```
+Goal achieved: false
+Abandonment reason: patience_depleted
+Final thought: "This is taking too long, I'll try another site."
+Step 12: Confusion peaked at 0.72 when trying to find the signup button
+```
+
+### Friction Points
+```json
+{
+  "frictionPoints": [
+    {
+      "step": 5,
+      "type": "confusion",
+      "monologue": "I'm not sure if 'Get Started' means signup or just learning more...",
+      "screenshot": "friction-step-5.png"
+    }
+  ]
+}
+```
+
+## Best Practices
+
+1. **Test early, test often**: Run cognitive journeys during design, not just before launch
+2. **Focus on abandonment reasons**: These reveal UX issues
+3. **Watch confusion levels**: Sustained confusion > 0.6 indicates unclear UI
+4. **Check the monologue**: The internal thoughts reveal what users are thinking
+5. **Compare across personas**: If only one persona struggles, it's a specific accessibility issue
+
+## Common Abandonment Patterns
+
+| Pattern | Typical Cause | Fix |
+|---------|---------------|-----|
+| "Taking too long" | Too many steps, slow loading | Simplify flow |
+| "No idea what to do" | Unclear navigation, missing labels | Improve signposting |
+| "So frustrating" | Repeated failures, errors | Better error messages |
+| "Not getting anywhere" | Circular navigation, dead ends | Improve information architecture |
+| "Keep ending up here" | Confusing back navigation | Better breadcrumbs |
+
+## Next Steps
+
+- Review friction points and prioritize fixes
+- Re-run journeys after changes to verify improvement
+- Add cognitive journey tests to CI/CD pipeline
+- Create custom personas that match your user research

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cbrowser",
-  "version": "8.3.0",
+  "version": "8.3.1",
   "description": "AI-powered browser automation with constitutional safety, AI visual regression, persona testing, and natural language test suites. Modular architecture for visual, testing, analysis, and performance modules.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",