@pyreon/mcp 0.12.13 → 0.12.14

package/lib/index.js

@@ -12750,7 +12750,7 @@ var StdioServerTransport = class {
 
 //#endregion
 //#region package.json
-var version = "0.12.13";
+var version = "0.12.14";
 
 //#endregion
 //#region src/api-reference.ts
@@ -13345,7 +13345,7 @@ await doc.toNotion()   // Notion blocks`,
 		notes: "14+ output formats. JSX primitives: Document, Page, Heading, Text, Table, Image, List, Code, etc. Heavy renderers lazy-loaded."
 	},
 	"flow/createFlow": {
-		signature: "createFlow<TData = Record<string, unknown>>(config: FlowConfig<TData>): FlowInstance<TData>",
+		signature: "<TData = Record<string, unknown>>(config: FlowConfig<TData>) => FlowInstance<TData>",
 		example: `// Generic over node data shape — typed consumers get strong narrowing
 interface WorkflowData {
   kind: 'trigger' | 'filter' | 'transform' | 'notify'
@@ -13364,13 +13364,50 @@ const flow = createFlow<WorkflowData>({
 const trigger = flow.findNodes((n) => n.data.kind === 'trigger')
 
 flow.addNode({ id: '3', type: 'custom', position: { x: 100, y: 200 }, data: { kind: 'transform', label: 'New' } })
-await flow.layout('layered', { direction: 'RIGHT', nodeSpacing: 50, layerSpacing: 100 })  // auto-layout via lazy-loaded elkjs
-// LayoutOptions applicability: direction/layerSpacing/edgeRouting apply to layered/tree only;
+await flow.layout('layered', { direction: 'RIGHT', nodeSpacing: 50, layerSpacing: 100 })
+// LayoutOptions applicability: direction / layerSpacing / edgeRouting apply to layered/tree only;
 // force/stress/radial/box/rectpacking silently ignore them. nodeSpacing applies to all algorithms.
-const json = flow.toJSON(); flow.fromJSON(json)       // round-trip serialization
+const json = flow.toJSON(); flow.fromJSON(json)       // round-trip serialization`,
+		notes: "Create a reactive flow instance. Generic over node data shape — `createFlow<MyData>(...)` returns `FlowInstance<MyData>` so `node.data.kind` narrows correctly without an `[key: string]: unknown` index signature on consumer types. Defaults to `Record<string, unknown>` when no generic is supplied. The returned instance owns signal-native nodes / edges and exposes CRUD, selection, viewport (zoom / pan / fitView), and auto-layout via lazy-loaded elkjs (first `.layout()` call fetches a ~1.4MB chunk). Pan / zoom uses pointer events + CSS transforms — no D3. See also: useFlow, FlowInstance, Flow.",
+		mistakes: `- Forgetting to declare \`@pyreon/runtime-dom\` in consumer app deps — flow's JSX emits \`_tpl()\` which needs runtime-dom imports
+- Reading \`NodeComponentProps.data\` / \`.selected\` / \`.dragging\` as plain values — all three are REACTIVE ACCESSORS: \`props.data()\`, \`props.selected()\`, \`props.dragging()\`
+- Calling \`props.data()\` OUTSIDE a reactive scope — captures the value once at component setup, defeating the per-node reactivity. Read it inside JSX expression thunks, \`effect\`, or \`computed\`
+- Adding \`[key: string]: unknown\` index signature to your node data interface — no longer needed now that \`createFlow\` is generic. Pass \`createFlow<MyData>(...)\` instead
+- Setting \`LayoutOptions.direction\` (or \`layerSpacing\`, or \`edgeRouting\`) on a force / stress / radial / box / rectpacking layout and expecting a directional result — these options are namespaced under ELK's layered / tree pipelines and silently ignored by the geometric algorithms. Dev-mode \`console.warn\` fires when this happens
+- Missing \`<Flow nodeTypes={{ key: Component }}>\` registration — \`node.type\` strings dispatch to that map, unregistered types fall through to the default renderer
+- Using \`createFlow\` inside a component body without \`onUnmount(() => flow.dispose())\` — prefer \`useFlow\` which auto-disposes
+- Using \`direction: 'row'\` on flow's containing Element layout — Pyreon \`Element\` accepts \`'inline'\` / \`'rows'\` / \`'reverseInline'\` / \`'reverseRows'\`, not CSS flex-direction values like \`'row'\` or \`'column'\``
+	},
+	"flow/useFlow": {
+		signature: "<TData = Record<string, unknown>>(config: FlowConfig<TData>) => FlowInstance<TData>",
+		example: `// Component-scoped flow — auto-disposes when the component unmounts.
+// Identical shape to createFlow, plus an implicit onUnmount(() => flow.dispose()).
+const MyDiagram = () => {
+  const flow = useFlow<WorkflowData>({
+    nodes: [{ id: '1', position: { x: 0, y: 0 }, data: { kind: 'trigger', label: 'Start' } }],
+    edges: [],
+  })
+  return (
+    <Flow instance={flow}>
+      <Background />
+    </Flow>
+  )
+}`,
+		notes: `Component-scoped wrapper around \`createFlow\` — identical shape plus an implicit \`onUnmount(() => flow.dispose())\`. Prefer inside component bodies; use \`createFlow\` directly only for flows owned outside the component tree (app stores, singletons, SSR-shared state) where you'll dispose at the correct lifecycle point yourself. See also: createFlow.`,
+		mistakes: `- Using \`useFlow\` outside a component body — the \`onUnmount\` hook registration requires an active component setup context, same constraint as every \`useX\` hook
+- Using \`createFlow\` inside a component and forgetting \`onUnmount(() => flow.dispose())\` — that was the footgun \`useFlow\` exists to prevent
+- Storing the returned instance in a module-level variable — bypasses the auto-dispose guarantee; use \`createFlow\` for that pattern`
+	},
+	"flow/Flow": {
+		signature: "(props: FlowComponentProps) => VNodeChild",
+		example: `<Flow instance={flow} nodeTypes={{ custom: MyNode }} edgeTypes={{ arrow: ArrowEdge }}>
+  <Background variant="dots" gap={20} />
+  <Controls position="bottom-left" />
+  <MiniMap nodeColor={(node) => '#6366f1'} />
+</Flow>
 
 // Custom node renderer — every prop except id is a REACTIVE ACCESSOR
-function CustomNode(props: NodeComponentProps<WorkflowData>) {
+function MyNode(props: NodeComponentProps<WorkflowData>) {
   return (
     <div
       class={() => (props.selected() ? 'selected' : '')}
@@ -13379,21 +13416,61 @@ function CustomNode(props: NodeComponentProps<WorkflowData>) {
       {() => props.data().label}
     </div>
   )
+}`,
+		notes: "Main flow container. Accepts a `FlowInstance` via the `instance` prop plus optional `nodeTypes` / `edgeTypes` maps for custom renderers. Internally uses `<For>` keyed by `node.id` plus per-node reactive accessors that read live state from `instance.nodes()` — each node mounts EXACTLY ONCE across the lifetime of the graph regardless of drags, selection clicks, or `updateNode` mutations. A 60fps drag in a 1000-node graph stays O(1) per frame. JSX components are NOT generic at the call site (`<Flow<MyData> />` is invalid JSX); `FlowProps.instance` is typed as `FlowInstance<any>` so typed consumers can pass `FlowInstance<MyData>` without casting. See also: createFlow, Background, Controls, MiniMap, Handle.",
+		mistakes: `- \`<Flow<MyData> />\` is invalid JSX — the component is not generic at the call site; pass a typed \`FlowInstance<MyData>\` via \`instance\` prop
+- Missing \`nodeTypes\` entry for a \`node.type\` string — falls through to the default renderer
+- Mutating \`instance.nodes()\` return value directly — use \`instance.addNode\` / \`updateNode\` / \`removeNode\` so the internal signals fire`
+	},
+	"flow/Background": {
+		signature: "(props: { variant?: \"dots\" | \"lines\"; gap?: number; color?: string }) => VNodeChild",
+		example: `<Flow instance={flow}>
+  <Background variant="dots" gap={24} color="#e5e7eb" />
+</Flow>`,
+		notes: "Dot or line grid background inside a `<Flow>`. Place as a direct child. `variant` defaults to `\"dots\"`, `gap` controls pattern spacing, `color` sets the pattern color. Renders as an SVG pattern at the back of the z-order. See also: Flow, Controls, MiniMap."
+	},
+	"flow/Controls": {
+		signature: "(props?: { position?: \"top-left\" | \"top-right\" | \"bottom-left\" | \"bottom-right\" }) => VNodeChild",
+		example: `<Flow instance={flow}>
+  <Controls position="bottom-left" />
+</Flow>`,
+		notes: "Zoom in / zoom out / fit-view button cluster. Renders absolutely inside the flow viewport at the configured corner (default `\"bottom-right\"`). Each button dispatches to the corresponding `FlowInstance` viewport method. See also: Flow, Background, MiniMap."
+	},
+	"flow/MiniMap": {
+		signature: "(props?: { nodeColor?: (node: FlowNode) => string; maskColor?: string }) => VNodeChild",
+		example: `<Flow instance={flow}>
+  <MiniMap nodeColor={(node) => node.data.highlighted ? '#f59e0b' : '#6366f1'} />
+</Flow>`,
+		notes: "Overview minimap of the full graph. `nodeColor` is a per-node color function (default grey), `maskColor` fills the area outside the current viewport (default semi-transparent black). Clicks on the minimap recenter the main viewport. See also: Flow, Background, Controls."
+	},
+	"flow/Handle": {
+		signature: "(props: { type: \"source\" | \"target\"; position: Position; id?: string }) => VNodeChild",
+		example: `function CustomNode(props: NodeComponentProps<MyData>) {
+  return (
+    <div>
+      <Handle type="target" position={Position.Left} />
+      {() => props.data().label}
+      <Handle type="source" position={Position.Right} id="out-primary" />
+      <Handle type="source" position={Position.Bottom} id="out-fallback" />
+    </div>
+  )
 }
 
-<Flow instance={flow} nodeTypes={{ custom: CustomNode }}>
-  <Background variant="dots" />
-  <Controls />
-  <MiniMap />
+// Edge referencing a specific source handle by id
+flow.addEdge({ source: '1', sourceHandle: 'out-primary', target: '2' })`,
+		notes: "Connection handle on a custom node — exposes a connectable point that edges attach to. `type` picks direction (`\"source\"` emits edges, `\"target\"` receives), `position` is a `Position` enum (`Top` / `Right` / `Bottom` / `Left`). Provide a distinct `id` when a node has multiple source or target handles so edges can reference the specific one via `edge.sourceHandle` / `edge.targetHandle`. See also: Flow, Position.",
+		mistakes: `- Multiple \`source\` / \`target\` handles on one node without distinct \`id\` values — edges cannot disambiguate which handle they connect to
+- Nesting a \`<Handle>\` inside a non-node component (a \`<Background>\` child, a \`<Panel>\`, etc.) — the connection machinery expects handles to live inside a node renderer`
+	},
+	"flow/Panel": {
+		signature: "(props: { position?: \"top-left\" | \"top-right\" | \"bottom-left\" | \"bottom-right\"; children: VNodeChild }) => VNodeChild",
+		example: `<Flow instance={flow}>
+  <Panel position="top-right">
+    <button onClick={() => flow.fitView()}>Fit</button>
+    <button onClick={() => flow.toJSON()}>Export</button>
+  </Panel>
 </Flow>`,
-		notes: "Signal-native nodes/edges. Generic over node data shape: createFlow<TData> returns FlowInstance<TData> so node.data.kind narrows correctly. Defaults to Record<string, unknown> if no generic supplied. NodeComponentProps has THREE reactive accessors — data: () => TData, selected: () => boolean, dragging: () => boolean — read inside reactive scopes so the node patches in place when ANY underlying state changes. Each node mounts EXACTLY ONCE across the lifetime of the graph regardless of how many drags, selection clicks, or updateNode mutations happen. Internally <Flow> uses <For> keyed by node.id plus per-node accessors that read live state from instance.nodes() — so a 60fps drag in a 1000-node graph is O(1) instead of O(N) per frame. Auto-layout via elkjs (lazy-loaded, ~1.4MB chunk only on first .layout() call). Pan/zoom via pointer events + CSS transforms. No D3. JSX components are NOT generic at the call site (<Flow<MyData> /> is invalid JSX) — FlowProps.instance is typed as FlowInstance<any> so typed consumers can pass FlowInstance<MyData> without casting.",
-		mistakes: `- Forgetting to declare @pyreon/runtime-dom in consumer app deps — flow's JSX emits _tpl() which needs runtime-dom imports
-- Reading props.data, props.selected, or props.dragging as plain values — they're ALL accessors, call them: props.data().kind, props.selected(), props.dragging()
-- Calling props.data() OUTSIDE a reactive scope — captures the value once at component setup, defeating reactivity. Read it inside JSX expression thunks, effect, or computed: {() => props.data().label}
-- Adding [key: string]: unknown index signature to your node data interface — no longer needed now that createFlow is generic. Just pass createFlow<MyData>(...)
-- Using direction: 'row' on flow's containing layout — Pyreon Element accepts 'inline'|'rows'|'reverseInline'|'reverseRows', not 'row'
-- Setting LayoutOptions.direction (or layerSpacing, or edgeRouting) on a force/stress/radial/box/rectpacking layout and expecting a directional result — these options are namespaced under ELK's layered/tree pipelines and silently ignored by the geometric algorithms. Switch the algorithm to 'layered' or 'tree' if you need a directional layout.
-- Missing the <Flow nodeTypes={{ key: Component }}> registration — node.type strings dispatch to that map`
+		notes: "Overlay panel positioned absolutely relative to the flow viewport. Use for toolbars, legend badges, or contextual action buttons. Pass any JSX as children — the panel is a plain positioned container, not a predefined chrome component. See also: Flow, Controls."
 	},
 	"code/createEditor": {
 		signature: "createEditor(config: { value?: string, language?: EditorLanguage, theme?: EditorTheme, onChange?: (val: string) => void, minimap?: boolean, lineNumbers?: boolean, ... }): EditorInstance",
@@ -13509,28 +13586,38 @@ Posts.useTable()   // TanStack Table config`,
 
 const result = lint({ paths: ["src/"], preset: "recommended" })
 console.log(result.totalErrors, result.totalWarnings)
-
-// With config file auto-loading + rule overrides
-lint({ paths: ["."], ruleOverrides: { "pyreon/no-classname": "off" } })`,
-		notes: "Programmatic API. 58 rules across 12 categories. Auto-loads .pyreonlintrc.json. Presets: recommended, strict, app, lib. Uses oxc-parser with AST caching."
+// Config-level diagnostics (malformed rule options, etc.)
+for (const d of result.configDiagnostics) console.log(d.ruleId, d.message)
+
+// Severity overrides + per-rule options overrides
+lint({
+  paths: ["."],
+  ruleOverrides: { "pyreon/no-classname": "off" },
+  ruleOptionsOverrides: {
+    "pyreon/no-window-in-ssr": { exemptPaths: ["src/foundation/"] },
+  },
+})`,
+		notes: "Programmatic API. 59 rules across 12 categories. Auto-loads .pyreonlintrc.json. Presets: recommended, strict, app, lib. Per-rule options via tuple form in config (`[\"error\", { exemptPaths: [...] }]`) or `ruleOptionsOverrides`. Wrong-typed options surface on `result.configDiagnostics`. Uses oxc-parser with AST caching."
 	},
 	"lint/lintFile": {
-		signature: "lintFile(filePath: string, sourceText: string, rules: Rule[], config: LintConfig, cache?: AstCache): LintFileResult",
+		signature: "lintFile(filePath: string, sourceText: string, rules: Rule[], config: LintConfig, cache?: AstCache, configDiagnosticsSink?: ConfigDiagnostic[]): LintFileResult",
 		example: `import { lintFile, allRules, getPreset, AstCache } from "@pyreon/lint"
 
 const cache = new AstCache()
 const config = getPreset("recommended")
-const result = lintFile("app.tsx", source, allRules, config, cache)`,
-		notes: "Low-level single-file API. Optional AstCache for repeat runs (FNV-1a hash keyed)."
+const configSink: ConfigDiagnostic[] = []
+const result = lintFile("app.tsx", source, allRules, config, cache, configSink)`,
+		notes: "Low-level single-file API. Optional AstCache for repeat runs (FNV-1a hash keyed). Optional `configDiagnosticsSink` collects malformed-option diagnostics; without it they print to stderr."
 	},
 	"lint/cli": {
-		signature: "pyreon-lint [--preset name] [--fix] [--format text|json|compact] [--quiet] [--watch] [--list] [--config path] [--ignore path] [--rule id=severity] [path...]",
+		signature: "pyreon-lint [--preset name] [--fix] [--format text|json|compact] [--quiet] [--watch] [--list] [--config path] [--ignore path] [--rule id=severity] [--rule-options id='{json}'] [path...]",
 		example: `pyreon-lint --preset strict --quiet    # CI mode
 pyreon-lint --fix                       # auto-fix
 pyreon-lint --watch src/                # watch mode
-pyreon-lint --list                      # list all 58 rules
-pyreon-lint --format json               # machine-readable`,
-		notes: "CLI entry. Config: .pyreonlintrc.json, package.json 'pyreonlint' field. Ignore: .pyreonlintignore + .gitignore. Watch: fs.watch recursive with 100ms debounce."
+pyreon-lint --list                      # list all 59 rules
+pyreon-lint --format json               # machine-readable
+pyreon-lint --rule-options 'pyreon/no-window-in-ssr={"exemptPaths":["src/foundation/"]}' src/`,
+		notes: "CLI entry. Config: .pyreonlintrc.json (reference schema/pyreonlintrc.schema.json for IDE autocomplete), package.json 'pyreonlint' field. Ignore: .pyreonlintignore + .gitignore. Watch: fs.watch recursive with 100ms debounce. `--rule-options id='{json}'` passes per-rule options on a single run."
 	},
 	"lint/no-process-dev-gate": {
 		signature: "rule: pyreon/no-process-dev-gate (architecture, error, auto-fixable)",
@@ -13548,6 +13635,35 @@ if (__DEV__) console.warn('hello')`,
 - Adding \`process: { env: { ... } }\` polyfills to vite.config.ts as a workaround — fix the source instead
 - Using the rule for server-only packages — they're correctly exempt because Node always has \`process\``
 	},
+	"lint/require-browser-smoke-test": {
+		signature: "rule: pyreon/require-browser-smoke-test (architecture, error in recommended/strict/lib, off in app)",
+		example: `// Per-package config (optional — defaults cover all known browser packages)
+{
+  "rules": {
+    "pyreon/require-browser-smoke-test": [
+      "error",
+      {
+        "additionalPackages": ["@my-org/my-browser-pkg"],
+        "exemptPaths": ["packages/experimental/"]
+      }
+    ]
+  }
+}`,
+		notes: "Locks in the durability of the T1.1 browser smoke harness (PRs #224, #227, #229, #231). Every browser-categorized package MUST ship at least one `*.browser.test.{ts,tsx}` file under `src/`. Without this rule, new browser packages can quietly ship without smoke coverage and we drift back to the world before T1.1 — happy-dom silently masks environment-divergence bugs (PR #197 mock-vnode metadata drop, PR #200 `typeof process` dead code, multi-word event delegation bug). Default browser-package list mirrors `.claude/rules/test-environment-parity.md`. The rule fires once per package on its `src/index.ts`, walks the package directory looking for `*.browser.test.*`, and reports if none are found. Off in `app` preset because apps don't ship as packages with smoke obligations.",
+		mistakes: `- Adding a new browser-running package without a browser test — the rule will fail your PR
+- Hardcoding the browser-package list in the rule — the list lives in \`.claude/rules/browser-packages.json\` (single source of truth), not in the rule source
+- Disabling the rule globally — use \`exemptPaths\` to exempt specific packages still under construction
+- Shipping a \`sanity.browser.test.ts\` with \`expect(1).toBe(1)\` just to satisfy the rule — it passes but provides zero signal. The rule is a GATE, not a quality check; review actual contents on PR`
+	},
+	"mcp/get_browser_smoke_status": {
+		signature: "tool: get_browser_smoke_status — no args",
+		example: `// Ask the MCP server:
+//   "which Pyreon packages are missing browser smoke coverage?"
+// Tool walks packages/, matches against .claude/rules/browser-packages.json,
+// returns a coverage report.`,
+		notes: "Companion to the `pyreon/require-browser-smoke-test` lint rule. Reports which browser-categorized Pyreon packages have at least one `*.browser.test.{ts,tsx}` file under `src/`. Uses the same `.claude/rules/browser-packages.json` single source of truth as the rule + the CI script. Lets an AI agent check coverage before writing a new browser package (so it adds a smoke test in the same PR) instead of discovering the failure when CI runs. Falls back with a clear message if the JSON isn't present (e.g. consumer apps that don't ship the Pyreon monorepo layout).",
+		mistakes: `- Using the tool's output as a substitute for running the CI script — this tool only checks file existence, not the self-expiring-exemption check that \`bun run lint:browser-smoke\` performs`
+	},
 	"ui-core/PyreonUI": {
 		signature: "PyreonUI(props: { theme?: Theme; mode?: 'light' | 'dark' | 'system'; inversed?: boolean; children: VNodeChild }): VNodeChild",
 		example: `import { PyreonUI } from "@pyreon/ui-core"
@@ -13798,12 +13914,13 @@ const tree = helper.getDocNode()`,
 * to generate, validate, and migrate Pyreon code.
 *
 * Tools:
-*   get_api        — Look up any Pyreon API: signature, usage, common mistakes
-*   validate       — Check a code snippet for Pyreon anti-patterns
-*   migrate_react  — Convert React code to idiomatic Pyreon
-*   diagnose       — Parse an error message into structured fix information
-*   get_routes     — List all routes in the current project
-*   get_components — List all components with their props and signals
+*   get_api                   — Look up any Pyreon API: signature, usage, common mistakes
+*   validate                  — Check a code snippet for Pyreon anti-patterns
+*   migrate_react             — Convert React code to idiomatic Pyreon
+*   diagnose                  — Parse an error message into structured fix information
+*   get_routes                — List all routes in the current project
+*   get_components            — List all components with their props and signals
+*   get_browser_smoke_status  — Report which browser-categorized packages have smoke coverage
 *
 * Usage:
 *   bunx @pyreon/mcp          # stdio transport (for IDE integration)
@@ -13888,6 +14005,112 @@ server.tool("get_components", {}, async () => {
 	}).join("\n");
 	return textResult(`**Components (${ctx.components.length}):**\n\n${compList}`);
 });
+server.tool("get_browser_smoke_status", {}, async () => {
+	const fs = await import("node:fs");
+	const path = await import("node:path");
+	const cwd = process.cwd();
+	let browserPackages = [];
+	{
+		let dir = cwd;
+		for (let i = 0; i < 30; i++) {
+			const candidate = path.join(dir, ".claude", "rules", "browser-packages.json");
+			if (fs.existsSync(candidate)) {
+				try {
+					const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+					if (Array.isArray(parsed.packages)) browserPackages = parsed.packages.filter((p) => typeof p === "string");
+				} catch {}
+				break;
+			}
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	}
+	if (browserPackages.length === 0) return textResult("No `.claude/rules/browser-packages.json` found in the current project. This tool reports browser-smoke coverage for Pyreon monorepos that ship the single-source-of-truth list. Consumer apps can still opt in via the lint rule's `additionalPackages` option.");
+	function hasBrowserTest(dir) {
+		let entries;
+		try {
+			entries = fs.readdirSync(dir);
+		} catch {
+			return false;
+		}
+		for (const name of entries) {
+			if (name.startsWith(".") || name === "node_modules" || name === "lib" || name === "dist") continue;
+			const full = path.join(dir, name);
+			let isDir = false;
+			try {
+				isDir = fs.statSync(full).isDirectory();
+			} catch {
+				continue;
+			}
+			if (isDir) {
+				if (hasBrowserTest(full)) return true;
+				continue;
+			}
+			if (/\.browser\.test\.(?:ts|tsx)$/.test(name)) return true;
+		}
+		return false;
+	}
+	const pkgDirs = /* @__PURE__ */ new Map();
+	function walkPkgs(dir, depth = 0) {
+		if (depth > 4) return;
+		let entries;
+		try {
+			entries = fs.readdirSync(dir);
+		} catch {
+			return;
+		}
+		for (const name of entries) {
+			if (name.startsWith(".") || name === "node_modules") continue;
+			const full = path.join(dir, name);
+			let isDir = false;
+			try {
+				isDir = fs.statSync(full).isDirectory();
+			} catch {
+				continue;
+			}
+			if (!isDir) continue;
+			const pkgJsonPath = path.join(full, "package.json");
+			if (fs.existsSync(pkgJsonPath)) try {
+				const parsed = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+				if (typeof parsed.name === "string") pkgDirs.set(parsed.name, full);
+			} catch {}
+			else walkPkgs(full, depth + 1);
+		}
+	}
+	walkPkgs(path.join(cwd, "packages"));
+	const covered = [];
+	const missing = [];
+	const unknown = [];
+	for (const name of browserPackages) {
+		const dir = pkgDirs.get(name);
+		if (!dir) {
+			unknown.push(name);
+			continue;
+		}
+		if (hasBrowserTest(dir)) covered.push(name);
+		else missing.push(name);
+	}
+	const parts = [];
+	parts.push(`**Browser smoke coverage** (${covered.length} / ${browserPackages.length}):`);
+	parts.push("");
+	if (covered.length > 0) {
+		parts.push(`✓ Covered (${covered.length}):`);
+		for (const n of covered) parts.push(`  - ${n}`);
+		parts.push("");
+	}
+	if (missing.length > 0) {
+		parts.push(`✗ Missing \`*.browser.test.*\` (${missing.length}):`);
+		for (const n of missing) parts.push(`  - ${n}`);
+		parts.push("");
+		parts.push("Add a `*.browser.test.{ts,tsx}` file under `src/` in each missing package. See `.claude/rules/test-environment-parity.md` for the setup recipe.");
+	}
+	if (unknown.length > 0) {
+		parts.push(`? Listed in browser-packages.json but not found in this repo (${unknown.length}):`);
+		for (const n of unknown) parts.push(`  - ${n}`);
+	}
+	return textResult(parts.join("\n"));
+});
 async function main() {
 	const transport = new StdioServerTransport();
 	await server.connect(transport);