@fringetools/cli 0.4.0 → 0.4.1

package/README.md

@@ -31,7 +31,8 @@ Prefer a permanent command? `npm install -D @fringetools/cli`, then `npx fringe
 | `fringe check --hook` | One-line `fringe/hook.v1` JSON for CI / pre-commit. Exits `1` on errors. Claude Code does **not** feed this back — use `--claude-hook` for agents. Wins over `--json`. |
 | `fringe check --update-baseline` | Accept today's findings into `fringe.baseline.json` (commit it). Exit `0`. |
 | `fringe check --record [--manifest <path>]` | Also append this run to `.fringe/ledger.jsonl`, optionally merging an agent flow manifest. |
-| `fringe init [path]` | Add the Claude Code hook and install the five skills. Safe to re-run; refuses to touch an invalid `settings.json`. |
+| `fringe` (no arguments) | Checks the current folder, and if the post-edit check is not set up yet, says how to set it up. |
+| `fringe init [path] [--global]` | Add the Claude Code hook and install the six skills. `--global` writes to `~/.claude` so every project is covered. Uses the project's own installed copy of Fringe when there is one (faster), otherwise `npx`. Safe to re-run; refuses to touch an invalid `settings.json`. |
 | `fringe open [path] [--port <n>]` | Serve the ledger as a plain HTML page on `127.0.0.1:4173` (loopback only). Ctrl+C to stop. |
 | `fringe --help` · `--version` | Usage / version. |
 
@@ -87,6 +88,21 @@ Most real problems live in states the first load never shows: an open menu, a mo
 
 For each state Fringe reloads the page, runs the steps, then audits the result (axe-core and the Tab walk). Steps are exactly one of `click`, `fill` (with `value`), `press`, `hover`, `waitFor`, `goto`; selectors are [Playwright selectors](https://playwright.dev/docs/other-locators) (CSS, `text=...`, `role=...`). Findings are labelled `[filters open]` and cluster separately from the same rule on the initial page. A step that fails (selector not found) is reported as `FR-402` ("state could not be reached") and nothing in that state is audited. Use throw-away test data in `fill` values and do not commit real credentials. `plan --scan` uses the same file.
 
+### Stress modes: how the page behaves under real-world conditions
+
+```sh
+npx @fringetools/cli scan http://localhost:3000 --stress                 # all three
+npx @fringetools/cli scan http://localhost:3000 --modes dark,reflow      # a subset
+```
+
+| Mode | What it does | Reports |
+|---|---|---|
+| `dark` | Re-audits with the browser asking for a dark color scheme | contrast and other axe findings that appear only in dark mode |
+| `reduced` | Asks for reduced motion, then looks for animations still looping | `FR-403` (review) |
+| `reflow` | Shrinks to 320px (a 400% zoom of a 1280px window) | `FR-404` (review, WCAG 1.4.10) if the page needs horizontal scrolling, plus new axe findings |
+
+Each mode runs on a fresh page so one mode's emulation never leaks into the next, and only findings the plain page did not already have are kept. Findings are labelled `[dark mode]`, `[reduced motion]`, `[reflow]`. Modes apply to the initial page, not to named states.
+
 Limits, plainly: states are independent (each starts from a fresh load of the URL, so there are no multi-page flows that depend on earlier state beyond `goto`); it needs the page running; findings have no source line (they carry a CSS selector); automated checks only find part of the real problems. `fringe plan --scan <url>` merges it with the static findings into one fix order. It does not feed the baseline or `fringe-ignore` yet, and is not part of the edit hook (it needs a running app and takes seconds).
 
 ## Priority, clusters and fix plans
@@ -152,7 +168,7 @@ The hook also keeps `.fringe/last.json` (the previous run's errors) and tells th
 
 This was verified end to end with real agent runs: the agent receives the findings and fixes them (see [docs/architecture.md](../../docs/architecture.md)). Why `--claude-hook` and not `--hook`: Claude Code only passes a hook's output to the agent as `decision`/`reason` JSON on exit 0 (or stderr on exit 2); the CI contract `--hook` exits 1 and is ignored.
 
-**Skills** — `fringe init` installs five into `.claude/skills/` (sources in [skill/](skill/), one folder each); the Claude Code plugin ships the same folders, namespaced `/fringe:…`: `fringe` (below), `fringe-review` ("review this page": ranked, plain-English findings with fixes), `fringe-audit` (whole-repo plan: top rules and files, a fix order, offers `--update-baseline`), `fringe-debt` (lists `fringe-ignore` suppressions and the baseline) and `fringe-help` (quick reference). Invoke as `/fringe-review` etc. Reviews run `fringe check`, so Claude Code will ask you to approve that command once (or allow `Bash(fringe:*)` / `Bash(npx:*)`).
+**Skills** — `fringe init` installs six into `.claude/skills/` (sources in [skill/](skill/), one folder each); the Claude Code plugin ships the same folders, namespaced `/fringetool:…`: `fringe` (below), `fringe-review` ("review this page": ranked, plain-English findings with fixes), `fringe-audit` (whole-repo plan: top rules and files, a fix order, offers `--update-baseline`), `fringe-debt` (lists `fringe-ignore` suppressions and the baseline), `fringe-setup` (guided onboarding: environment check, hook, baseline offer, critical paths) and `fringe-help` (quick reference). Invoke as `/fringe-review` etc. Reviews run `fringe check`, so Claude Code will ask you to approve that command once (or allow `Bash(fringe:*)` / `Bash(npx:*)`).
 
 **The main skill** (`.claude/skills/fringe/SKILL.md`) teaches the agent the ladder: *Flow* (cut what users don't need, with evidence in `.fringe/manifest.json`) → *Edges* (fix every hook finding, never silence a rule to get green) → *Polish* (tokens, scales, no AI look), then record the run. It is plain Markdown, so any agent platform that reads `AGENTS.md`/skill files can use it as-is.
 

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "./chunk-JSWDIPHX.js";
+} from "./chunk-7ZFEVMML.js";
 
 // src/bin.ts
 process.exitCode = await runCli(process.argv.slice(2));

package/dist/{chunk-JSWDIPHX.js → chunk-7ZFEVMML.js}

@@ -4,7 +4,7 @@ import { existsSync as existsSync3, readFileSync as readFileSync9, statSync } fr
 import { dirname as dirname2, join as join10, resolve } from "path";
 
 // src/version.ts
-var VERSION = "0.4.0";
+var VERSION = "0.4.1";
 
 // src/check.ts
 import { readFileSync as readFileSync5 } from "fs";
@@ -1683,7 +1683,47 @@ async function audit(page, axePath, url) {
   return [...axeToFindings(url, axeRes.violations), ...tabWalkFindings(url, focusables, visits)];
 }
 var inState = (name, url, f) => ({ ...f, message: `[${name}] ${f.message}`, loc: { ...f.loc, file: `${url} [${name}]` }, ...f.cluster ? { cluster: `${f.cluster} [${name}]` } : {} });
-async function scan(url, cwd = process.cwd(), states = []) {
+var MODES = ["dark", "reduced", "reflow"];
+function parseModes(list) {
+  const out = list.split(",").map((m) => m.trim()).filter(Boolean);
+  const bad = out.find((m) => !MODES.includes(m));
+  if (bad || out.length === 0) throw new Error(`unknown scan mode '${bad ?? ""}': use ${MODES.join(", ")}`);
+  return out;
+}
+function onlyNew(base, extra) {
+  const seen = new Set(base.map((f) => `${f.rule}|${f.message}`));
+  return extra.filter((f) => !seen.has(`${f.rule}|${f.message}`));
+}
+var countRunningLoops = `[...document.getAnimations()].filter((a) => a.playState === 'running' && a.effect && a.effect.getComputedTiming().iterations === Infinity).map((a) => { const t = a.effect.target; return t ? t.tagName.toLowerCase() + (t.id ? '#' + t.id : '') + (typeof t.className === 'string' && t.className ? '.' + t.className.trim().split(/\\s+/)[0] : '') : 'unknown'; })`;
+async function stress(browser, axePath, url, mode, base) {
+  const page = await browser.newPage();
+  try {
+    return await stressOn(page, axePath, url, mode, base);
+  } finally {
+    await page.close();
+  }
+}
+async function stressOn(page, axePath, url, mode, base) {
+  const at0 = { file: `${url} [${mode}]`, line: 1, col: 0 };
+  await page.goto(url, { waitUntil: "load", timeout: 3e4 });
+  if (mode === "dark") {
+    await page.emulateMedia({ colorScheme: "dark" });
+    await page.waitForTimeout(150);
+    return onlyNew(base, await audit(page, axePath, url)).map((f) => inState("dark mode", url, f));
+  }
+  if (mode === "reduced") {
+    await page.emulateMedia({ reducedMotion: "reduce" });
+    await page.waitForTimeout(300);
+    const loops = await page.evaluate(countRunningLoops);
+    return loops.length === 0 ? [] : [{ rule: "FR-403", severity: "review", message: `[reduced motion] ${loops.length} animation(s) keep looping when the user asks for reduced motion: ${loops.slice(0, 3).join(", ")}`, hint: "honour prefers-reduced-motion: stop or replace infinite animations under @media (prefers-reduced-motion: reduce)", loc: at0 }];
+  }
+  await page.setViewportSize({ width: 320, height: 256 });
+  await page.waitForTimeout(250);
+  const wide = await page.evaluate(() => document.documentElement.scrollWidth - document.documentElement.clientWidth);
+  const out = wide > 1 ? [{ rule: "FR-404", severity: "review", message: `[reflow] content is ${wide}px wider than a 320px screen, so it needs horizontal scrolling`, hint: "let content reflow to one column at 320px (WCAG 1.4.10); wide tables and code blocks may scroll inside their own container", loc: at0, wcag: "1.4.10" }] : [];
+  return [...out, ...onlyNew(base, await audit(page, axePath, url)).map((f) => inState("reflow", url, f))];
+}
+async function scan(url, cwd = process.cwd(), states = [], modes = []) {
   if (!/^(https?|file):\/\//i.test(url)) throw new Error(`fringe scan takes an http(s):// or file:// URL, got '${url}'`);
   const req = createRequire(join8(cwd, "noop.js"));
   let playwright, axePath;
@@ -1707,6 +1747,7 @@ async function scan(url, cwd = process.cwd(), states = []) {
     const page = await browser.newPage();
     await page.goto(url, { waitUntil: "load", timeout: 3e4 });
     const all = await audit(page, axePath, url);
+    const plain = [...all];
     for (const st of states) {
       await page.goto(url, { waitUntil: "load", timeout: 3e4 });
       let step = 0;
@@ -1718,10 +1759,11 @@ async function scan(url, cwd = process.cwd(), states = []) {
       }
       all.push(...(await audit(page, axePath, url)).map((f) => inState(st.name, url, f)));
     }
+    for (const m of modes) all.push(...await stress(browser, axePath, url, m, plain));
     const { findings, clusters } = rankScan(url, all);
     const counts = { error: 0, review: 0, signal: 0 };
     for (const f of findings) counts[f.severity]++;
-    return { stack: { jsx: false, tailwind: false, vue: false, svelte: false, html: true }, files: 1 + states.length, skipped: [], findings, clusters, counts, score: score(counts, { error: 10, review: 3, signal: 1 }, 1) };
+    return { stack: { jsx: false, tailwind: false, vue: false, svelte: false, html: true }, files: 1 + states.length + modes.length, skipped: [], findings, clusters, counts, score: score(counts, { error: 10, review: 3, signal: 1 }, 1) };
   } finally {
     await browser.close();
   }
@@ -1751,6 +1793,18 @@ import { dirname, join as join9 } from "path";
 import { fileURLToPath } from "url";
 var HOOK = "npx -y @fringetools/cli check --claude-hook";
 var SKILL_DIR = fileURLToPath(new URL("../skill/", import.meta.url));
+function hookCommand(root) {
+  return existsSync2(join9(root, "node_modules", "@fringetools", "cli", "package.json")) ? "npx --no-install fringe check --claude-hook" : HOOK;
+}
+function isWired(root, home) {
+  for (const dir of [root, home]) {
+    try {
+      if (/claude-hook|fringe(tool)?@/.test(readFileSync8(join9(dir, ".claude", "settings.json"), "utf8"))) return true;
+    } catch {
+    }
+  }
+  return false;
+}
 function initProject(root) {
   const done = [];
   const settingsPath = join9(root, ".claude", "settings.json");
@@ -1765,7 +1819,7 @@ function initProject(root) {
   const post = (settings.hooks ??= {}).PostToolUse ??= [];
   if (/(fringe|@fringetools\/cli) check/.test(JSON.stringify(post))) done.push("hook already present");
   else {
-    post.push({ matcher: "Edit|Write", hooks: [{ type: "command", command: HOOK }] });
+    post.push({ matcher: "Edit|Write", hooks: [{ type: "command", command: hookCommand(root) }] });
     mkdirSync3(dirname(settingsPath), { recursive: true });
     writeFileSync3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     done.push(`hook added to ${settingsPath}`);
@@ -1782,6 +1836,9 @@ function initProject(root) {
   return done;
 }
 
+// src/index.ts
+import { homedir } from "os";
+
 // src/patterns.ts
 var PATTERNS = {
   form: {
@@ -1958,15 +2015,19 @@ function loadStates(cwd, rest) {
   }
   return parseStates(raw);
 }
+function loadModes(rest) {
+  const i = rest.indexOf("--modes");
+  return i !== -1 ? parseModes(rest[i + 1] ?? "") : rest.includes("--stress") ? [...MODES] : [];
+}
 var weakEvidence = (e) => typeof e !== "string" || e.trim().length < 12 || /^(n\/?a|none|tbd|obvious|unnecessary|clutter|unused)\.?$/i.test(e.trim());
 var HELP = `fringe check [--json] [--hook] [--record] [--manifest <path>] [path]
 fringe check --claude-hook [path]       for Claude Code hooks (feeds errors back to the agent)
 fringe check --update-baseline [path]   accept today's findings; only new ones gate
-fringe scan <url> [--states f] [--json]               runtime check in a real browser (axe-core + keyboard walk); needs playwright-core and axe-core
+fringe scan <url> [--states f] [--stress | --modes dark,reduced,reflow] [--json]               runtime check in a real browser (axe-core + keyboard walk); needs playwright-core and axe-core
 fringe plan [dir|file] [--scan url] [--json] [--limit n]   ordered fix batches with recipes; --scan adds the live page
 fringe explain pattern [form]           best-practice checklist for a component type
 fringe explain [FR-203]                 why a rule matters and how to fix it well
-fringe init [path]                       add the Claude Code hook + skill
+fringe init [path] [--global]          add the Claude Code hook + skills (--global: every project)
 fringe open [path] [--port <n>]   serve the .fringe ledger on 127.0.0.1
 fringe --help | --version`;
 var KNOWN_FLAGS = /* @__PURE__ */ new Set(["--json", "--hook", "--claude-hook", "--record", "--manifest", "--update-baseline"]);
@@ -1989,6 +2050,11 @@ function parseArgs(rest, warn) {
 }
 async function runCli(argv, opts = {}) {
   const [cmd, ...rest] = argv;
+  if (cmd === void 0) {
+    const code = await runCli(["check"], opts);
+    if (!isWired(opts.cwd ?? process.cwd(), opts.home ?? homedir())) log(opts)("\nfringe: not checking after your agent's edits yet. Run `npx @fringetools/cli init` (this project) or `init --global` (every project).");
+    return code;
+  }
   if (cmd === "--version" || cmd === "-v") {
     log(opts)(VERSION);
     return 0;
@@ -2039,13 +2105,13 @@ async function runCli(argv, opts = {}) {
   }
   if (cmd === "scan") {
     try {
-      const url = rest.find((a, i) => !a.startsWith("--") && rest[i - 1] !== "--states");
+      const url = rest.find((a, i) => !a.startsWith("--") && rest[i - 1] !== "--states" && rest[i - 1] !== "--modes");
       if (!url) {
         err(opts)("fringe: scan needs a URL, e.g. fringe scan http://localhost:3000\n");
         return 2;
       }
       const cwd = opts.cwd ?? process.cwd();
-      const result = await scan(url, cwd, loadStates(cwd, rest));
+      const result = await scan(url, cwd, loadStates(cwd, rest), loadModes(rest));
       log(opts)(rest.includes("--json") ? toJson(result) : toPretty(result));
       return result.counts.error > 0 ? 1 : 0;
     } catch (e) {
@@ -2064,14 +2130,14 @@ async function runCli(argv, opts = {}) {
       }
       const li = rest.indexOf("--limit");
       const limit = li !== -1 ? Number(rest[li + 1]) || void 0 : void 0;
-      const paths = parseArgs(rest.filter((a, i) => a !== "--limit" && rest[i - 1] !== "--limit" && a !== "--json" && a !== "--scan" && rest[i - 1] !== "--scan" && a !== "--states" && rest[i - 1] !== "--states"), err(opts));
+      const paths = parseArgs(rest.filter((a, i) => a !== "--limit" && rest[i - 1] !== "--limit" && a !== "--json" && a !== "--scan" && rest[i - 1] !== "--scan" && a !== "--states" && rest[i - 1] !== "--states" && a !== "--stress" && a !== "--modes" && rest[i - 1] !== "--modes"), err(opts));
       const arg = resolve(opts.cwd ?? process.cwd(), paths[0] ?? ".");
       const { root, only } = resolveTarget(arg);
       const cfg = loadConfig(root);
       let result = await runCheck(root, cfg, true, only);
       if (scanUrl) {
         const cwd = opts.cwd ?? process.cwd();
-        result = mergeScan(result, await scan(scanUrl, cwd, loadStates(cwd, rest)), cfg.weights);
+        result = mergeScan(result, await scan(scanUrl, cwd, loadStates(cwd, rest), loadModes(rest)), cfg.weights);
       }
       log(opts)(rest.includes("--json") ? toPlanJson(result, limit) : toPlanMarkdown(result, paths[0] ?? ".", limit));
       return 0;
@@ -2103,7 +2169,10 @@ async function runCli(argv, opts = {}) {
   }
   if (cmd === "init") {
     try {
-      for (const line of initProject(resolve(opts.cwd ?? process.cwd(), rest[0] ?? "."))) log(opts)(`fringe: ${line}`);
+      const global = rest.includes("--global") || rest.includes("-g");
+      const target = global ? opts.home ?? homedir() : resolve(opts.cwd ?? process.cwd(), rest.find((a) => !a.startsWith("-")) ?? ".");
+      for (const line of initProject(target)) log(opts)(`fringe: ${line}`);
+      if (global) log(opts)("fringe: set up for your user, so every project is covered (run without --global to set up one project only)");
       return 0;
     } catch (e) {
       err(opts)(`fringe: ${e.message}

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 interface CliOpts {
     log?: (s: string) => void;
     cwd?: string;
-    err?: (s: string) => void;
+    err?: (s: string) => void; /** Home directory for `init --global` (tests override it). */
+    home?: string;
 }
 declare function runCli(argv: string[], opts?: CliOpts): Promise<number>;
 

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   runCli
-} from "./chunk-JSWDIPHX.js";
+} from "./chunk-7ZFEVMML.js";
 export {
   runCli
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fringetools/cli",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "license": "MIT",
   "type": "module",
   "bin": {

package/skill/fringe/SKILL.md

@@ -5,7 +5,7 @@ description: Use when writing or changing frontend code (JSX/TSX, HTML, CSS, Vue
 
 # Fringe
 
-Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli` in its place (e.g. `npx -y @fringetools/cli check --json .`).
+Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli@0.4.0` in its place (e.g. `npx -y @fringetools/cli@0.4.0 check --json .`).
 
 Ponytail trims your code. Fringe handles your edges. Work the ladder in order.
 

package/skill/fringe-audit/SKILL.md

@@ -5,7 +5,7 @@ description: Use when the user wants a whole-repo UX/accessibility audit, a plan
 
 # Fringe audit
 
-Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli` in its place (e.g. `npx -y @fringetools/cli check --json .`).
+Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli@0.4.0` in its place (e.g. `npx -y @fringetools/cli@0.4.0 check --json .`).
 
 1. Run `fringe plan --json --limit 5` (or `fringe plan` for Markdown). It already orders the work: P0 errors in shared components or critical paths, P1 other errors with mechanical fixes first, P2 review, P3 polish, each cluster with its recipe. Use that order; do not re-derive it. Add `"critical": ["src/checkout/**"]` to `fringe.config.json` if the user names the pages that matter most. Do not print every finding.
 2. Summarize as a plan:

package/skill/fringe-debt/SKILL.md

@@ -7,7 +7,7 @@ description: Use when the user asks what Fringe findings have been silenced or d
 
 Fringe has two ways to defer a finding: an inline `fringe-ignore` comment and the `fringe.baseline.json` file. This lists both so a deferral can't quietly become permanent.
 
-Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli` in its place.
+Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli@0.4.0` in its place.
 
 1. **Inline suppressions.** `git grep --no-index --exclude-standard -nE 'fringe-ignore +FR-[0-9]+'`. One row per hit: `<file>:<line>, <rule> — <why, if the comment or nearby code says>`. Skip hits that are only prose mentioning the convention.
 2. **Baseline.** If `fringe.baseline.json` exists, count entries per rule (each entry is `rule|file|message`) and list the files with the most. If it is missing, say there is no baseline.

package/skill/fringe-help/SKILL.md

@@ -15,9 +15,10 @@ Fringe checks agent-written frontends for accessibility, state, dark-pattern and
 | `/fringe-review` | Review a page or component: ranked findings with plain-English fixes |
 | `/fringe-audit` | Audit the whole repo: top rules and files, a fix order, offer a baseline |
 | `/fringe-debt` | List silenced findings (`fringe-ignore`, baseline) |
+| `/fringe-setup` | Guided onboarding: wire the hook, offer a baseline, set critical paths |
 | `/fringe-help` | This reference |
 
-**Commands** (`fringe`, or `npx -y @fringetools/cli`)
+**Commands** (`fringe`, or `npx -y @fringetools/cli@0.4.0`)
 
 | Command | What it does |
 |---|---|

package/skill/fringe-review/SKILL.md

@@ -5,7 +5,7 @@ description: Use when the user asks to review, check or critique a UI, page or c
 
 # Fringe review
 
-Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli` in its place (e.g. `npx -y @fringetools/cli check --json .`).
+Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli@0.4.0` in its place (e.g. `npx -y @fringetools/cli@0.4.0 check --json .`).
 
 1. Run `fringe check --json <file or folder>` from the project root: the file or page the user named, else `.`. Each finding already carries `priority` and `fixability`; report highest priority first. For the fix text use `fringe explain <rule>` (why, recipe, what to avoid) rather than improvising.
 2. Report in plain English, no jargon left unexplained:

package/skill/fringe-setup/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: fringe-setup
+description: Use when the user wants to set up or get started with Fringe, or asks why it is not checking their edits ("set up fringe", "get started", "install fringe", /fringe-setup). Guided onboarding: checks the environment, wires the hook, offers a baseline, and records the critical pages.
+---
+
+# Fringe setup
+
+Command: use `fringe` if it is on the PATH, otherwise `npx -y @fringetools/cli` in its place. Ask before each step that changes a file, and say what it will change.
+
+1. **Environment.** Run `node -v` (needs 18 or newer). If it is missing or older, stop and tell the user to install Node first.
+2. **Where things stand.** Run `fringe check .` and report the counts. If it says it is not checking after edits, the hook is not wired.
+3. **Wire the hook (skip if the Fringe plugin is already installed, or the check above reported it is set up).** Ask: this project only, or every project? Then run `fringe init` or `fringe init --global`. Both add the post-edit hook and the skills without touching other settings.
+4. **Existing problems.** If there are more than a handful of errors, explain that `fringe check --update-baseline` records today's findings so only new ones block, and offer it. Do not run it without a yes. Remind the user to commit `fringe.baseline.json`.
+5. **What matters most.** Ask which folders are most important to users (checkout, sign-up, login). Add them to `fringe.config.json` as `"critical": ["src/checkout/**", ...]`, merging into the file if it exists, never overwriting other keys.
+6. **Optional.** Mention `fringe scan <url>` (needs `npm i -D playwright-core axe-core` and Chrome) for real contrast and keyboard checks; install nothing unless asked.
+7. **Finish** with one short summary of what was changed and the commands to remember: `/fringe-review`, `/fringe-audit`, `fringe plan`, `fringe explain FR-203`.
+
+If anything fails, report the exact message; do not retry blindly or edit `.claude/settings.json` by hand.