cbrowser 18.75.1 → 18.75.3

package/dist/mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":";AACA;;;;GAIG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAgvIpE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAE1D;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAWvE;AAED,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAWpD"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":";AACA;;;;GAIG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAo0IpE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAE1D;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAWvE;AAED,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAWpD"}

package/dist/mcp-server.js

@@ -12,6 +12,7 @@
  * Or: npx cbrowser mcp-server
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { PERSONA_CATEGORIES } from "./persona-questionnaire.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { CBrowser } from "./browser.js";
@@ -230,6 +231,33 @@ const VALUES_QUESTIONS = [
     },
 ];
 const questionnaireSessionsMap = new Map();
+/**
+ * Group a flat Schwartz/SDT value record into the nested schema every other
+ * values-returning path uses (schwartz / higherOrder / sdt / maslowLevel).
+ *
+ * persona_questionnaire_build emitted `values` FLAT, with Schwartz and SDT
+ * merged and no higherOrder grouping — so the C4b nested-schema fix never
+ * reached the creation path, and a persona built through the questionnaire had
+ * a different value shape from the same persona loaded back. Three sites
+ * already hand-write this grouping; this is the shared one. (2026-07-29)
+ */
+function nestPersonaValues(values) {
+    if (!values)
+        return undefined;
+    const pick = (...keys) => {
+        const out = {};
+        for (const k of keys)
+            if (values[k] !== undefined)
+                out[k] = values[k];
+        return out;
+    };
+    return {
+        schwartz: pick("selfDirection", "stimulation", "hedonism", "achievement", "power", "security", "conformity", "tradition", "benevolence", "universalism"),
+        higherOrder: pick("openness", "selfEnhancement", "conservation", "selfTranscendence"),
+        sdt: pick("autonomyNeed", "competenceNeed", "relatednessNeed"),
+        maslowLevel: values.maslowLevel,
+    };
+}
 function getQuestionnaireSession(sessionId) {
     return questionnaireSessionsMap.get(sessionId);
 }
@@ -942,6 +970,37 @@ async function registerCBrowserTools() {
                         url: result.url,
                         overallStatus: result.overallStatus,
                         summary: result.summary,
+                        // The evidence used to be collapsed to two integers —
+                        // screenshotCount / comparisonCount — while `result` carried every
+                        // screenshot path, every pairwise similarity score, and
+                        // problematicBrowsers. So the caller received an absolute verdict
+                        // ("renders consistently across all tested browsers") with every
+                        // number that could falsify it removed, and no way to open the
+                        // screenshots it said it had taken.
+                        //
+                        // It also explains the contradiction with cross_browser_diff: this
+                        // tool compares ABOVE-THE-FOLD PIXELS at a forced 1920x1080, while
+                        // the diff compares FULL-PAGE TEXT at 1280x720. Two different
+                        // measurements reported in language that claims to settle the same
+                        // question. `scope` now says which one you are reading.
+                        // (2026-07-29)
+                        scope: "above-the-fold pixels at 1920x1080; page TEXT is not compared — use cross_browser_diff for content",
+                        screenshots: result.screenshots.map((s) => ({
+                            browser: s.browser,
+                            path: s.screenshotPath,
+                            viewport: s.viewport,
+                        })),
+                        comparisons: result.comparisons.map((c) => ({
+                            browserA: c.browserA,
+                            browserB: c.browserB,
+                            status: c.analysis?.overallStatus,
+                            similarity: c.analysis?.similarityScore,
+                            changes: (c.analysis?.changes ?? []).map((ch) => ({
+                                severity: ch.severity,
+                                description: ch.description,
+                            })),
+                        })),
+                        ...(result.problematicBrowsers?.length ? { problematicBrowsers: result.problematicBrowsers } : {}),
                         screenshotCount: result.screenshots.length,
                         comparisonCount: result.comparisons.length,
                         ...(result.missingBrowsers?.length ? { missingBrowsers: result.missingBrowsers } : {}),
@@ -987,6 +1046,24 @@ async function registerCBrowserTools() {
                         url: result.url,
                         overallStatus: result.overallStatus,
                         summary: result.summary,
+                        // `result.issues` and `problematicViewports` were both computed and
+                        // then dropped here, so the caller got "13 issues: 7 overflow, 2
+                        // unreadable text..." with no way to learn WHICH viewport or WHICH
+                        // element — a count they could not act on. Same computed-then-
+                        // discarded shape as the cross-browser handler above. (2026-07-29)
+                        issues: (result.issues ?? []).map((i) => ({
+                            type: i.type,
+                            severity: i.severity,
+                            description: i.description,
+                            affectedViewports: i.affectedViewports,
+                            ...(i.breakpointRange ? { breakpointRange: i.breakpointRange } : {}),
+                        })),
+                        ...(result.problematicViewports?.length ? { problematicViewports: result.problematicViewports } : {}),
+                        viewports: result.screenshots.map((s) => ({
+                            name: s.viewport
+                                ?? s.name,
+                            path: s.screenshotPath,
+                        })),
                         viewportsCount: result.screenshots.length,
                     }, null, 2),
                 },
@@ -1953,7 +2030,7 @@ This ensures personas are grounded in research, not stereotypes.
         };
     });
     server.tool("persona_category_guidance", "Get research-based guidance for a specific persona category. Explains what values are appropriate and why, with citations. Use before building a persona to understand category constraints.", {
-        category: z.enum(["cognitive", "physical", "sensory", "emotional", "general"]).describe("Persona category to get guidance for"),
+        category: z.enum(PERSONA_CATEGORIES).describe("Persona category to get guidance for"),
     }, async ({ category }) => {
         const { getCategoryValuePreset, COGNITIVE_SUBTYPES, } = await import("./persona-questionnaire.js");
         const preset = getCategoryValuePreset(category);
@@ -1983,6 +2060,11 @@ This ensures personas are grounded in research, not stereotypes.
                             sensory: "Use neutral (0.5) values. Sensory perception ≠ motivational psychology. Color-blindness doesn't make someone more/less achievement-oriented.",
                             emotional: "Apply trait-based values from personality psychology (e.g., anxiety = high security-seeking).",
                             general: "Use population baselines. Specific characteristics come from cognitive traits, not disability-based value shifts.",
+                            // Added 2026-07-29: this table covered five of the six
+                            // categories, and TypeScript flagged it the moment the enum
+                            // stopped silently excluding "agent". An unlisted key would have
+                            // yielded `undefined` guidance beside a populated preset.
+                            agent: "Agent personas are not human — motivational values do not apply. Use trait-based capability values (parsing, retrieval, tool use) and do NOT project human needs like security or belonging onto them.",
                         }[category],
                     }, null, 2),
                 },
@@ -1993,7 +2075,7 @@ This ensures personas are grounded in research, not stereotypes.
         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. Auto-detected from name/description if not provided."),
+        category: z.enum(PERSONA_CATEGORIES).optional().describe("Persona category for value safeguards. Auto-detected from name/description if not provided."),
         valueOverrides: z.record(z.string(), z.number()).optional().describe("Override specific Schwartz values (0-1), e.g. {security: 0.8, stimulation: 0.3}"),
         save: z.boolean().optional().default(true).describe("Save the persona to disk for future use"),
     }, async ({ name, description, answers, category, valueOverrides, save }) => {
@@ -2047,7 +2129,10 @@ This ensures personas are grounded in research, not stereotypes.
                             strategy: categoryResult.valueStrategy,
                             guidance: categoryResult.guidance,
                         },
+                        // Flat shape retained for callers that already read it; the nested
+                        // grouping is what every other values-returning path emits.
                         values: categoryResult.values,
+                        valuesNested: nestPersonaValues(categoryResult.values),
                         researchBasis: subtypeValues
                             ? [...categoryResult.researchBasis, subtypeValues.researchBasis]
                             : categoryResult.researchBasis,