cbrowser 16.10.0 → 16.14.0

package/dist/mcp-server-remote.js

@@ -49,13 +49,15 @@ import { runNLTestSuite, parseNLTestSuite, dryRunNLTestSuite, repairTest, detect
 // Analysis module imports
 import { huntBugs, runChaosTest, comparePersonas, findElementByIntent, runAgentReadyAudit, runCompetitiveBenchmark, runEmpathyAudit, } from "./analysis/index.js";
 // Accessibility personas for empathy audit
-import { listAccessibilityPersonas } from "./personas.js";
+import { listAccessibilityPersonas, getAccessibilityPersona } from "./personas.js";
 // Persona imports for cognitive journey
 import { getPersona, listPersonas, getCognitiveProfile, createCognitivePersona, } from "./personas.js";
 // Import API key check for bridge workflow detection
 import { isApiKeyConfigured } from "./cognitive/index.js";
 // Performance module imports
 import { capturePerformanceBaseline, detectPerformanceRegression, listPerformanceBaselines, } from "./performance/index.js";
+// Values system (Schwartz's 10 Universal Values)
+import { getPersonaValues, PERSONA_VALUE_PROFILES, rankInfluencePatternsForProfile, INFLUENCE_PATTERNS, } from "./values/index.js";
 // Version from package.json - single source of truth
 import { VERSION } from "./version.js";
 // Stealth/Enterprise loader (v16.2.0)
@@ -992,19 +994,56 @@ function configureMcpTools(server) {
         blockUrls: z.array(z.string()).optional().describe("URL patterns to block"),
     }, async ({ url, networkLatency, offline, blockUrls }) => {
         const b = await getBrowser();
-        const result = await runChaosTest(b, url, { networkLatency, offline, blockUrls });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        passed: result.passed,
-                        errors: result.errors,
-                        duration: result.duration,
-                    }, null, 2),
-                },
-            ],
-        };
+        try {
+            const result = await runChaosTest(b, url, { networkLatency, offline, blockUrls });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            passed: result.passed,
+                            errors: result.errors,
+                            duration: result.duration,
+                            // v16.11.0: Include impact analysis in response
+                            impact: result.impact,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            // v16.11.0: Graceful error handling for chaos test crashes
+            // Attempt browser recovery to prevent server crash
+            try {
+                await b.recoverBrowser();
+            }
+            catch {
+                // Browser recovery failed, but continue with error response
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            passed: false,
+                            errors: [`Chaos test crashed: ${error.message}`],
+                            duration: 0,
+                            impact: {
+                                loadTimeMs: 0,
+                                blockedResources: [],
+                                failedResources: [],
+                                delayedResources: [],
+                                pageCompleted: false,
+                                pageInteractive: false,
+                                consoleErrors: 0,
+                                degradationSummary: ["Test crashed - browser recovered"],
+                            },
+                            recovered: true,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
     });
     server.tool("compare_personas", "Compare how different user personas experience a journey. In Claude Code sessions (no API key), use compare_personas_init and compare_personas_complete instead for the bridge workflow.", {
         url: z.string().url().describe("Starting URL"),
@@ -1266,6 +1305,7 @@ Begin with the first persona: ${personas[0]}
         goal: z.string().describe("What the simulated user is trying to accomplish"),
         startUrl: z.string().url().describe("Starting URL for the journey"),
         customTraits: z.object({
+            // Core 7 traits
             patience: z.number().min(0).max(1).optional(),
             riskTolerance: z.number().min(0).max(1).optional(),
             comprehension: z.number().min(0).max(1).optional(),
@@ -1273,7 +1313,26 @@ Begin with the first persona: ${personas[0]}
             curiosity: z.number().min(0).max(1).optional(),
             workingMemory: z.number().min(0).max(1).optional(),
             readingTendency: z.number().min(0).max(1).optional(),
-        }).optional().describe("Override specific cognitive traits"),
+            // v16.11.0: Extended traits (18 more = 25 total)
+            resilience: z.number().min(0).max(1).optional(),
+            selfEfficacy: z.number().min(0).max(1).optional(),
+            satisficing: z.number().min(0).max(1).optional(),
+            trustCalibration: z.number().min(0).max(1).optional(),
+            interruptRecovery: z.number().min(0).max(1).optional(),
+            informationForaging: z.number().min(0).max(1).optional(),
+            changeBlindness: z.number().min(0).max(1).optional(),
+            anchoringBias: z.number().min(0).max(1).optional(),
+            timeHorizon: z.number().min(0).max(1).optional(),
+            attributionStyle: z.number().min(0).max(1).optional(),
+            metacognitivePlanning: z.number().min(0).max(1).optional(),
+            proceduralFluency: z.number().min(0).max(1).optional(),
+            transferLearning: z.number().min(0).max(1).optional(),
+            authoritySensitivity: z.number().min(0).max(1).optional(),
+            emotionalContagion: z.number().min(0).max(1).optional(),
+            fearOfMissingOut: z.number().min(0).max(1).optional(),
+            socialProofSensitivity: z.number().min(0).max(1).optional(),
+            mentalModelRigidity: z.number().min(0).max(1).optional(),
+        }).optional().describe("Override specific cognitive traits (25 available)"),
     }, async ({ persona: personaName, goal, startUrl, customTraits }) => {
         // Get or create persona
         const existingPersona = getPersona(personaName);
@@ -1283,8 +1342,9 @@ Begin with the first persona: ${personas[0]}
             personaObj = createCognitivePersona(personaName, personaName, customTraits || {});
         }
         else if (customTraits) {
-            // Merge custom traits with defaults
+            // v16.11.0: Full 25-trait default set (was only 7, causing trait dropout)
             const defaultTraits = {
+                // Core 7 traits
                 patience: 0.5,
                 riskTolerance: 0.5,
                 comprehension: 0.5,
@@ -1292,6 +1352,26 @@ Begin with the first persona: ${personas[0]}
                 curiosity: 0.5,
                 workingMemory: 0.5,
                 readingTendency: 0.5,
+                // Tier 1: Core (5 more)
+                resilience: 0.5,
+                selfEfficacy: 0.5,
+                satisficing: 0.5,
+                trustCalibration: 0.5,
+                interruptRecovery: 0.5,
+                // Tier 2-6: Extended (13 more)
+                informationForaging: 0.5,
+                changeBlindness: 0.3,
+                anchoringBias: 0.5,
+                timeHorizon: 0.5,
+                attributionStyle: 0.5,
+                metacognitivePlanning: 0.5,
+                proceduralFluency: 0.5,
+                transferLearning: 0.5,
+                authoritySensitivity: 0.5,
+                emotionalContagion: 0.5,
+                fearOfMissingOut: 0.5,
+                socialProofSensitivity: 0.5,
+                mentalModelRigidity: 0.5,
             };
             personaObj = {
                 ...existingPersona,
@@ -1337,6 +1417,11 @@ Begin with the first persona: ${personas[0]}
         // Navigate to start URL
         const b = await getBrowser();
         await b.navigate(startUrl);
+        // v16.12.0: Include persona values for influence pattern analysis
+        const personaValues = getPersonaValues(personaObj.name);
+        const influencePatterns = personaValues
+            ? rankInfluencePatternsForProfile(personaValues).slice(0, 5) // Top 5 most effective patterns
+            : undefined;
         return {
             content: [
                 {
@@ -1346,6 +1431,36 @@ Begin with the first persona: ${personas[0]}
                             name: personaObj.name,
                             description: personaObj.description,
                             demographics: personaObj.demographics,
+                            values: personaValues ? {
+                                schwartz: {
+                                    selfDirection: personaValues.selfDirection,
+                                    stimulation: personaValues.stimulation,
+                                    hedonism: personaValues.hedonism,
+                                    achievement: personaValues.achievement,
+                                    power: personaValues.power,
+                                    security: personaValues.security,
+                                    conformity: personaValues.conformity,
+                                    tradition: personaValues.tradition,
+                                    benevolence: personaValues.benevolence,
+                                    universalism: personaValues.universalism,
+                                },
+                                higherOrder: {
+                                    openness: personaValues.openness,
+                                    selfEnhancement: personaValues.selfEnhancement,
+                                    conservation: personaValues.conservation,
+                                    selfTranscendence: personaValues.selfTranscendence,
+                                },
+                                sdt: {
+                                    autonomyNeed: personaValues.autonomyNeed,
+                                    competenceNeed: personaValues.competenceNeed,
+                                    relatednessNeed: personaValues.relatednessNeed,
+                                },
+                                maslowLevel: personaValues.maslowLevel,
+                            } : undefined,
+                            influenceSusceptibility: influencePatterns?.map(ip => ({
+                                pattern: ip.pattern.name,
+                                susceptibility: ip.susceptibility,
+                            })),
                         },
                         cognitiveProfile: profile,
                         initialState,
@@ -1503,27 +1618,254 @@ Begin the simulation now. Narrate your thoughts as this persona.
             ],
         };
     });
-    server.tool("list_cognitive_personas", "List all available personas with their cognitive traits", {}, async () => {
-        const names = listPersonas();
-        const personas = names.map(name => {
+    server.tool("list_cognitive_personas", "List all available personas with their cognitive traits (includes accessibility and emotional personas)", {}, async () => {
+        // v16.11.0: Include all persona types - BUILTIN + ACCESSIBILITY + EMOTIONAL
+        const builtinNames = listPersonas();
+        const accessibilityNames = listAccessibilityPersonas();
+        // Built-in personas (power-user, first-timer, etc.)
+        const builtinPersonas = builtinNames.map(name => {
             const p = getPersona(name);
             if (!p)
                 return null;
             const profile = getCognitiveProfile(p);
+            // v16.12.0: Include Schwartz values for each persona
+            const values = getPersonaValues(p.name);
             return {
                 name: p.name,
                 description: p.description,
+                category: "builtin",
                 demographics: p.demographics,
                 cognitiveTraits: profile.traits,
                 attentionPattern: profile.attentionPattern,
                 decisionStyle: profile.decisionStyle,
+                values: values ? {
+                    schwartz: {
+                        selfDirection: values.selfDirection,
+                        stimulation: values.stimulation,
+                        hedonism: values.hedonism,
+                        achievement: values.achievement,
+                        power: values.power,
+                        security: values.security,
+                        conformity: values.conformity,
+                        tradition: values.tradition,
+                        benevolence: values.benevolence,
+                        universalism: values.universalism,
+                    },
+                    higherOrder: {
+                        openness: values.openness,
+                        selfEnhancement: values.selfEnhancement,
+                        conservation: values.conservation,
+                        selfTranscendence: values.selfTranscendence,
+                    },
+                    sdt: {
+                        autonomyNeed: values.autonomyNeed,
+                        competenceNeed: values.competenceNeed,
+                        relatednessNeed: values.relatednessNeed,
+                    },
+                    maslowLevel: values.maslowLevel,
+                } : undefined,
+            };
+        }).filter(Boolean);
+        // Accessibility personas (motor-tremor, low-vision, adhd, etc.)
+        const accessibilityPersonas = accessibilityNames.map(name => {
+            const p = getAccessibilityPersona(name);
+            if (!p)
+                return null;
+            // v16.11.0: Compute disabilityType and barrierTypes from accessibilityTraits
+            const traits = p.accessibilityTraits;
+            let disabilityType = "General accessibility";
+            const barrierTypes = [];
+            if (traits?.tremor) {
+                disabilityType = "Motor impairment (tremor)";
+                barrierTypes.push("motor_precision", "touch_target");
+            }
+            if (traits?.visionLevel !== undefined && traits.visionLevel < 0.5) {
+                disabilityType = "Low vision";
+                barrierTypes.push("visual_clarity", "contrast");
+            }
+            if (traits?.colorBlindness) {
+                disabilityType = `Color blindness (${traits.colorBlindness})`;
+                barrierTypes.push("sensory");
+            }
+            if (traits?.processingSpeed !== undefined && traits.processingSpeed < 0.6) {
+                disabilityType = "Cognitive (Processing)";
+                barrierTypes.push("cognitive_load", "temporal");
+            }
+            if (traits?.attentionSpan !== undefined && traits.attentionSpan < 0.5) {
+                if (!disabilityType.includes("Cognitive")) {
+                    disabilityType = "Cognitive (ADHD/Attention)";
+                }
+                barrierTypes.push("cognitive_load");
+            }
+            // Name-based fallback
+            if (disabilityType === "General accessibility") {
+                if (p.name.includes("deaf") || p.name.includes("hearing"))
+                    disabilityType = "Hearing impairment";
+                else if (p.name.includes("motor"))
+                    disabilityType = "Motor impairment";
+                else if (p.name.includes("vision") || p.name.includes("blind"))
+                    disabilityType = "Vision impairment";
+                else if (p.name.includes("cognitive") || p.name.includes("adhd"))
+                    disabilityType = "Cognitive";
+            }
+            // v16.12.0: Include Schwartz values for accessibility personas
+            const values = getPersonaValues(p.name);
+            return {
+                name: p.name,
+                description: p.description,
+                category: "accessibility",
+                disabilityType,
+                demographics: p.demographics,
+                cognitiveTraits: p.cognitiveTraits || {},
+                barrierTypes: [...new Set(barrierTypes)], // Deduplicate
+                values: values ? {
+                    schwartz: {
+                        selfDirection: values.selfDirection,
+                        stimulation: values.stimulation,
+                        hedonism: values.hedonism,
+                        achievement: values.achievement,
+                        power: values.power,
+                        security: values.security,
+                        conformity: values.conformity,
+                        tradition: values.tradition,
+                        benevolence: values.benevolence,
+                        universalism: values.universalism,
+                    },
+                    higherOrder: {
+                        openness: values.openness,
+                        selfEnhancement: values.selfEnhancement,
+                        conservation: values.conservation,
+                        selfTranscendence: values.selfTranscendence,
+                    },
+                    sdt: {
+                        autonomyNeed: values.autonomyNeed,
+                        competenceNeed: values.competenceNeed,
+                        relatednessNeed: values.relatednessNeed,
+                    },
+                    maslowLevel: values.maslowLevel,
+                } : undefined,
             };
         }).filter(Boolean);
+        const allPersonas = [...builtinPersonas, ...accessibilityPersonas];
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({ personas, count: personas.length }, null, 2),
+                    text: JSON.stringify({
+                        personas: allPersonas,
+                        count: allPersonas.length,
+                        categories: {
+                            builtin: builtinPersonas.length,
+                            accessibility: accessibilityPersonas.length,
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    // =========================================================================
+    // Values System Tools (v16.12.0)
+    // Schwartz's 10 Universal Values, Self-Determination Theory, Maslow
+    // =========================================================================
+    server.tool("persona_values_lookup", "Look up the values profile for a persona (Schwartz's 10 Universal Values, SDT needs, Maslow level). Values describe WHO the persona is at a deeper motivational level, informing influence susceptibility.", {
+        persona: z.string().describe("Persona name (e.g., 'first-timer', 'power-user', 'anxious-user')"),
+        includeInfluencePatterns: z.boolean().optional().default(true).describe("Include ranked influence patterns this persona is susceptible to"),
+    }, async ({ persona, includeInfluencePatterns }) => {
+        const values = getPersonaValues(persona);
+        if (!values) {
+            const availablePersonas = PERSONA_VALUE_PROFILES.map(p => p.personaName);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: `No values profile found for persona: ${persona}`,
+                            availablePersonas,
+                            note: "Values are defined for all built-in personas. Custom personas can have values added via the questionnaire.",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        const profile = PERSONA_VALUE_PROFILES.find(p => p.personaName.toLowerCase() === persona.toLowerCase());
+        let influencePatterns;
+        if (includeInfluencePatterns) {
+            const ranked = rankInfluencePatternsForProfile(values);
+            influencePatterns = ranked.slice(0, 7).map(r => ({
+                pattern: r.pattern.name,
+                susceptibility: r.susceptibility,
+                description: r.pattern.description,
+            }));
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        persona,
+                        rationale: profile?.rationale,
+                        schwartzValues: {
+                            selfDirection: { value: values.selfDirection, meaning: "Independent thought, creativity, freedom" },
+                            stimulation: { value: values.stimulation, meaning: "Excitement, novelty, challenge" },
+                            hedonism: { value: values.hedonism, meaning: "Pleasure, sensuous gratification" },
+                            achievement: { value: values.achievement, meaning: "Personal success through competence" },
+                            power: { value: values.power, meaning: "Social status, prestige, control" },
+                            security: { value: values.security, meaning: "Safety, harmony, stability" },
+                            conformity: { value: values.conformity, meaning: "Restraint of actions that harm others" },
+                            tradition: { value: values.tradition, meaning: "Respect for customs, heritage" },
+                            benevolence: { value: values.benevolence, meaning: "Welfare of close others" },
+                            universalism: { value: values.universalism, meaning: "Tolerance, social justice, environment" },
+                        },
+                        higherOrderValues: {
+                            openness: { value: values.openness, meaning: "(selfDirection + stimulation) / 2" },
+                            selfEnhancement: { value: values.selfEnhancement, meaning: "(achievement + power) / 2" },
+                            conservation: { value: values.conservation, meaning: "(security + conformity + tradition) / 3" },
+                            selfTranscendence: { value: values.selfTranscendence, meaning: "(benevolence + universalism) / 2" },
+                        },
+                        selfDeterminationTheory: {
+                            autonomyNeed: { value: values.autonomyNeed, meaning: "Need for choice and control" },
+                            competenceNeed: { value: values.competenceNeed, meaning: "Need to feel capable" },
+                            relatednessNeed: { value: values.relatednessNeed, meaning: "Need for connection" },
+                        },
+                        maslowLevel: {
+                            level: values.maslowLevel,
+                            meaning: values.maslowLevel === "physiological" ? "Basic survival needs"
+                                : values.maslowLevel === "safety" ? "Security and stability"
+                                    : values.maslowLevel === "belonging" ? "Social connection and love"
+                                        : values.maslowLevel === "esteem" ? "Achievement and recognition"
+                                            : "Self-fulfillment and growth",
+                        },
+                        influencePatterns,
+                        researchBasis: {
+                            schwartz: "Schwartz, S. H. (1992, 2012). Theory of Basic Human Values. DOI: 10.1016/S0065-2601(08)60281-6",
+                            sdt: "Deci, E. L., & Ryan, R. M. (1985, 2000). Self-Determination Theory. DOI: 10.1037/0003-066X.55.1.68",
+                            maslow: "Maslow, A. H. (1943). A Theory of Human Motivation. DOI: 10.1037/h0054346",
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("list_influence_patterns", "List all research-backed influence/persuasion patterns and which persona values make someone susceptible to each pattern. Based on Cialdini, Kahneman, and behavioral economics research.", {}, async () => {
+        // INFLUENCE_PATTERNS is an array of InfluencePattern objects
+        const patterns = INFLUENCE_PATTERNS.map(pattern => ({
+            name: pattern.name,
+            description: pattern.description,
+            researchBasis: pattern.researchBasis,
+            targetValues: pattern.targetValues,
+            mechanism: pattern.mechanism,
+            examples: pattern.examples,
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        count: patterns.length,
+                        patterns,
+                        usage: "Use persona_values_lookup to see which patterns a specific persona is susceptible to",
+                        note: "These patterns describe psychological influence mechanisms. Use ethically for UX optimization, not manipulation.",
+                    }, null, 2),
                 },
             ],
         };
@@ -1532,11 +1874,12 @@ Begin the simulation now. Narrate your thoughts as this persona.
     // Persona Questionnaire Tools (v16.5.0)
     // Research-based persona generation via questionnaire
     // =========================================================================
-    server.tool("persona_questionnaire_get", "Get the persona questionnaire for building a custom persona. Returns research-backed questions that map to cognitive traits. Use comprehensive=true for all 25 traits, or leave false for 8 core traits.", {
+    server.tool("persona_questionnaire_get", "Get the persona questionnaire for building a custom persona. Returns research-backed questions that map to cognitive traits. Use comprehensive=true for all 25 traits, or leave false for 8 core traits. v16.12.0: Now includes optional category question for disability-specific value safeguards.", {
         comprehensive: z.boolean().optional().default(false).describe("Include all 25 traits (true) or just 8 core traits (false)"),
         traits: z.array(z.string()).optional().describe("Specific trait names to include (overrides comprehensive)"),
-    }, async ({ comprehensive, traits }) => {
-        const { generatePersonaQuestionnaire, formatForAskUserQuestion } = await import("./persona-questionnaire.js");
+        includeCategory: z.boolean().optional().default(true).describe("Include category question for disability-aware values (v16.12.0)"),
+    }, async ({ comprehensive, traits, includeCategory }) => {
+        const { generatePersonaQuestionnaire, formatForAskUserQuestion, CATEGORY_QUESTION } = await import("./persona-questionnaire.js");
         const questions = generatePersonaQuestionnaire({
             comprehensive,
             traits: traits,
@@ -1547,25 +1890,39 @@ Begin the simulation now. Narrate your thoughts as this persona.
                 {
                     type: "text",
                     text: JSON.stringify({
-                        instructions: "Present these questions to the user one at a time or all at once. Each answer maps to a trait value. After collecting answers, use persona_questionnaire_build to create the persona.",
+                        instructions: "Present these questions to the user one at a time or all at once. Each answer maps to a trait value. After collecting answers, use persona_questionnaire_build to create the persona. v16.12.0: Start with the category question to enable disability-aware value safeguards.",
                         questionCount: questions.length,
                         questions: formatted,
                         rawQuestions: questions, // Include raw for programmatic use
+                        ...(includeCategory && {
+                            categoryQuestion: CATEGORY_QUESTION,
+                            categoryInstructions: "Ask this FIRST to determine persona category. The category affects which values are applied and provides research-based safeguards for disability simulations.",
+                        }),
                     }, null, 2),
                 },
             ],
         };
     });
-    server.tool("persona_questionnaire_build", "Build a custom persona from questionnaire answers. Answers should be a map of trait names to values (0-1). Missing traits will use intelligent defaults based on research correlations.", {
+    server.tool("persona_questionnaire_build", "Build a custom persona from questionnaire answers with category-aware value safeguards. Answers should be a map of trait names to values (0-1). Missing traits will use intelligent defaults based on research correlations. v16.12.0: Optionally specify category for disability-specific value handling.", {
         name: z.string().describe("Name for the new persona"),
         description: z.string().describe("Description of the persona"),
         answers: z.record(z.string(), z.number()).describe("Map of trait names to values (0-1), e.g. {patience: 0.25, riskTolerance: 0.75}"),
+        category: z.enum(["cognitive", "physical", "sensory", "emotional", "general"]).optional().describe("Persona category for value safeguards (v16.12.0)"),
+        valueOverrides: z.record(z.string(), z.number()).optional().describe("Override specific values (0-1) if different from category defaults"),
         save: z.boolean().optional().default(true).describe("Save the persona to disk for future use"),
-    }, async ({ name, description, answers, save }) => {
-        const { buildTraitsFromAnswers, getTraitLabel, getTraitBehaviors } = await import("./persona-questionnaire.js");
+    }, async ({ name, description, answers, category, valueOverrides, save }) => {
+        const { buildTraitsFromAnswers, getTraitLabel, getTraitBehaviors, detectPersonaCategory, buildValuesFromCategory, validateCategoryValues, } = await import("./persona-questionnaire.js");
         const { createCognitivePersona, saveCustomPersona } = await import("./personas.js");
-        // Build traits from answers with research-based correlations
+        // Detect or use provided category
+        const detectedCategory = category || detectPersonaCategory(name, description);
+        // Build traits from answers with research-based correlations (moved up for v16.14.0)
         const traits = buildTraitsFromAnswers(answers);
+        // Build category-appropriate values with optional overrides
+        // v16.14.0: Pass traits for trait_based categories (general, emotional)
+        const categoryResult = buildValuesFromCategory(detectedCategory, valueOverrides, traits // v16.14.0: Pass traits for trait-based value derivation
+        );
+        // Validate values match category guidelines
+        const warnings = validateCategoryValues(detectedCategory, categoryResult.values);
         // Create the persona
         const persona = createCognitivePersona(name, description, traits, {});
         // Save if requested
@@ -1597,6 +1954,19 @@ Begin the simulation now. Narrate your thoughts as this persona.
                         },
                         cognitiveTraits: traits,
                         traitSummary,
+                        // v16.12.0: Category-aware values
+                        category: {
+                            detected: detectedCategory,
+                            strategy: categoryResult.valueStrategy,
+                            guidance: categoryResult.guidance,
+                        },
+                        values: categoryResult.values,
+                        researchBasis: categoryResult.researchBasis,
+                        // v16.14.0: Show how traits influenced values for trait_based categories
+                        ...(categoryResult.derivations && categoryResult.derivations.length > 0 && {
+                            valueDerivations: categoryResult.derivations,
+                        }),
+                        ...(warnings.length > 0 && { warnings }),
                         savedPath,
                         usage: `Use persona "${name}" with cognitive-journey or other commands`,
                     }, null, 2),
@@ -1647,6 +2017,47 @@ Begin the simulation now. Narrate your thoughts as this persona.
             ],
         };
     });
+    server.tool("persona_category_guidance", "Get guidance for value assignment based on persona category. (v16.12.0) Explains research basis for why cognitive, physical, sensory, and emotional disability categories require different value handling approaches.", {
+        category: z.enum(["cognitive", "physical", "sensory", "emotional", "general"]).describe("Persona category to get guidance for"),
+    }, async ({ category }) => {
+        const { CATEGORY_VALUE_PRESETS, COGNITIVE_SUBTYPES } = await import("./persona-questionnaire.js");
+        const preset = CATEGORY_VALUE_PRESETS.find(p => p.category === category);
+        if (!preset) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: `Unknown category: ${category}`,
+                            availableCategories: ["cognitive", "physical", "sensory", "emotional", "general"],
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        category: preset.category,
+                        description: preset.description,
+                        valueStrategy: preset.valueStrategy,
+                        guidance: preset.guidance,
+                        defaultValues: preset.defaultValues,
+                        researchBasis: preset.researchBasis,
+                        ...(category === "cognitive" && {
+                            subtypes: Object.entries(COGNITIVE_SUBTYPES).map(([key, subtype]) => ({
+                                name: key,
+                                values: subtype.values,
+                                researchBasis: subtype.researchBasis,
+                            })),
+                        }),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
     // =========================================================================
     // Performance Tools (v6.4.0+)
     // =========================================================================
@@ -1656,6 +2067,8 @@ Begin the simulation now. Narrate your thoughts as this persona.
         runs: z.number().optional().default(3).describe("Number of runs to average"),
     }, async ({ url, name, runs }) => {
         const result = await capturePerformanceBaseline(url, { name, runs });
+        // v16.11.0: Return all available metrics, not just core 4
+        const m = result.metrics;
         return {
             content: [
                 {
@@ -1663,19 +2076,47 @@ Begin the simulation now. Narrate your thoughts as this persona.
                     text: JSON.stringify({
                         name: result.name,
                         url: result.url,
-                        lcp: result.metrics.lcp,
-                        fcp: result.metrics.fcp,
-                        ttfb: result.metrics.ttfb,
-                        cls: result.metrics.cls,
+                        // Core Web Vitals
+                        coreWebVitals: {
+                            lcp: m.lcp,
+                            lcpRating: m.lcpRating,
+                            fid: m.fid,
+                            fidRating: m.fidRating,
+                            cls: m.cls,
+                            clsRating: m.clsRating,
+                        },
+                        // Additional timing metrics
+                        timingMetrics: {
+                            fcp: m.fcp,
+                            fcpRating: m.fcpRating,
+                            ttfb: m.ttfb,
+                            ttfbRating: m.ttfbRating,
+                            tti: m.tti,
+                            tbt: m.tbt,
+                            domContentLoaded: m.domContentLoaded,
+                            load: m.load,
+                        },
+                        // Resource metrics
+                        resourceMetrics: {
+                            resourceCount: m.resourceCount,
+                            transferSize: m.transferSize,
+                        },
+                        // Flat copy for backward compatibility
+                        metrics: {
+                            lcp: m.lcp,
+                            fcp: m.fcp,
+                            ttfb: m.ttfb,
+                            cls: m.cls,
+                        },
                     }, null, 2),
                 },
             ],
         };
     });
-    server.tool("perf_regression", "Detect performance regression against baseline with configurable sensitivity. Uses dual thresholds: both percentage AND absolute change must be exceeded. Profiles: strict (CI/CD, FCP 10%/50ms), normal (default, FCP 20%/100ms), lenient (dev, FCP 30%/200ms). Sub-50ms FCP variations ignored by default.", {
+    server.tool("perf_regression", "Detect performance regression against baseline with configurable sensitivity. Uses dual thresholds: both percentage AND absolute change must be exceeded. Profiles: strict (perf envs, FCP 10%/50ms), normal (default, FCP 20%/100ms), ci (automated pipelines, FCP 25%/150ms), lenient (dev, FCP 30%/200ms).", {
         url: z.string().url().describe("URL to test"),
         baselineName: z.string().describe("Name of baseline to compare against"),
-        sensitivity: z.enum(["strict", "normal", "lenient"]).optional().default("normal").describe("Sensitivity profile: strict (CI/CD), normal (default), lenient (development)"),
+        sensitivity: z.enum(["strict", "normal", "ci", "lenient"]).optional().default("normal").describe("Sensitivity profile: strict (perf testing), normal (local dev), ci (automated pipelines), lenient (development)"),
         thresholdLcp: z.number().optional().describe("Override LCP threshold percentage"),
     }, async ({ url, baselineName, sensitivity, thresholdLcp }) => {
         const result = await detectPerformanceRegression(url, baselineName, {