@imfusion/web-ui 0.5.1-dev.41.g45c10e85 → 0.5.1-dev.45.gf3889fa8

package/README.md

@@ -69,7 +69,7 @@ skill.
 | `/imf-web-ui-components`  | Component reference — what exists and how it's meant to be used.               |
 | `/imf-web-ui-ux`          | UX guidance for building interfaces with the library.                          |
 | `/imf-web-ui-conventions` | The frontend conventions baseline, including the sanctioned styling seams.     |
-| `/imf-web-ui-audit`       | Read-only health check for a consumer project, with a reviewable audit report. |
+| `/imf-web-ui-audit`       | Read-only health check for a consumer project, ending in a plan you approve.   |
 | `/imf-web-ui-update`      | Update the library, skills, and optional hooks, then verify before committing. |
 
 Start at `/imf-web-ui` — it routes to the rest. Storybook's **User Guide → AI Agents** page covers the whole family.

package/dist/integrations/code-highlight/highlighter.d.ts

@@ -1,6 +1,35 @@
-export declare const SUPPORTED_LANGUAGES: readonly ["tsx", "ts", "css", "shell", "json"];
-declare const LANGUAGE_ALIASES: readonly ["typescript", "bash", "sh", "zsh", "shellscript", "scss"];
-export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number] | (typeof LANGUAGE_ALIASES)[number];
+declare const LANGUAGE_DEFINITIONS: {
+    readonly tsx: {
+        readonly aliases: readonly ["typescriptreact"];
+    };
+    readonly ts: {
+        readonly aliases: readonly ["typescript"];
+    };
+    readonly css: {
+        readonly aliases: readonly ["scss"];
+    };
+    readonly shell: {
+        readonly aliases: readonly ["bash", "sh", "zsh", "shellscript"];
+    };
+    readonly json: {
+        readonly aliases: readonly [];
+    };
+    readonly cpp: {
+        readonly aliases: readonly ["c++", "cc", "cxx", "hpp"];
+    };
+    readonly python: {
+        readonly aliases: readonly ["py"];
+    };
+    readonly cmake: {
+        readonly aliases: readonly [];
+    };
+};
+export declare const SUPPORTED_LANGUAGES: string[];
+type CanonicalLanguage = keyof typeof LANGUAGE_DEFINITIONS;
+type LanguageAlias = {
+    [Language in CanonicalLanguage]: (typeof LANGUAGE_DEFINITIONS)[Language]["aliases"][number];
+}[CanonicalLanguage];
+export type SupportedLanguage = CanonicalLanguage | LanguageAlias;
 export declare function isSupportedLanguage(value: string): value is SupportedLanguage;
 export declare function highlightToHtml(code: string, language: SupportedLanguage): string;
 export {};

package/dist/integrations/code-highlight/language-patterns.d.ts

@@ -0,0 +1,7 @@
+import { HighlightTokenClass, TokenRange } from '@tanstack/highlight/core';
+export type LanguagePattern = {
+    className: HighlightTokenClass;
+    group?: number;
+    regex: RegExp;
+};
+export declare function collectPatternRanges(code: string, patterns: readonly LanguagePattern[]): TokenRange[];

package/dist/integrations/code-highlight/languages/cmake.d.ts

@@ -0,0 +1 @@
+export declare const cmake: import('@tanstack/highlight/core').LanguageDefinition<"cmake">;

package/dist/integrations/code-highlight/languages/cpp.d.ts

@@ -0,0 +1 @@
+export declare const cpp: import('@tanstack/highlight/core').LanguageDefinition<"cpp">;

package/dist/integrations/code-highlight.js

@@ -2,63 +2,192 @@ import { a as e, t } from "../meta-B8C51eyL.js";
 import { i as n, n as r, r as i } from "../code-qBbqAHK-.js";
 import { useMemo as a } from "react";
 import { jsx as o } from "react/jsx-runtime";
-import { createHighlighter as s, renderNodesToHtml as c, renderTokens as l } from "@tanstack/highlight/core";
-import { css as u } from "@tanstack/highlight/languages/css";
-import { json as d } from "@tanstack/highlight/languages/json";
-import { plaintext as f } from "@tanstack/highlight/languages/plaintext";
-import { shell as p } from "@tanstack/highlight/languages/shell";
-import { ts as m } from "@tanstack/highlight/languages/ts";
-import { tsx as h } from "@tanstack/highlight/languages/tsx";
-//#region src/integrations/code-highlight/highlighter.ts
-var g = [
-	"tsx",
-	"ts",
-	"css",
-	"shell",
-	"json"
-], _ = [
-	"typescript",
-	"bash",
-	"sh",
-	"zsh",
-	"shellscript",
-	"scss"
-], v = [...g, ..._];
-function y(e) {
-	return v.includes(e);
+import { createHighlighter as s, defineLanguage as c, renderNodesToHtml as l, renderTokens as u } from "@tanstack/highlight/core";
+import { css as d } from "@tanstack/highlight/languages/css";
+import { json as f } from "@tanstack/highlight/languages/json";
+import { plaintext as p } from "@tanstack/highlight/languages/plaintext";
+import { python as m } from "@tanstack/highlight/languages/python";
+import { shell as h } from "@tanstack/highlight/languages/shell";
+import { ts as g } from "@tanstack/highlight/languages/ts";
+import { tsx as _ } from "@tanstack/highlight/languages/tsx";
+//#region src/integrations/code-highlight/language-patterns.ts
+function v(e, t) {
+	let n = [], r = new Uint8Array(e.length);
+	for (let i of t) {
+		let t = new RegExp(i.regex.source, i.regex.flags.includes("g") ? i.regex.flags : `${i.regex.flags}g`), a;
+		for (; (a = t.exec(e)) !== null;) {
+			let e = i.group == null ? a[0] : a[i.group];
+			if (e === "") {
+				a[0] === "" && (t.lastIndex += 1);
+				continue;
+			}
+			let o = i.group == null ? 0 : a[0].indexOf(e), s = a.index + o, c = s + e.length;
+			if (s < c) {
+				let e = !1;
+				for (let t = s; t < c; t += 1) if (r[t]) {
+					e = !0;
+					break;
+				}
+				e || (n.push({
+					start: s,
+					end: c,
+					className: i.className
+				}), r.fill(1, s, c));
+			}
+		}
+	}
+	return n;
+}
+//#endregion
+//#region src/integrations/code-highlight/languages/cmake.ts
+var y = [
+	{
+		className: "string",
+		regex: /"(?:\\.|[^"\\\n])*"|\[(=*)\[[\s\S]*?\]\1\]/g
+	},
+	{
+		className: "comment",
+		regex: /#[^\n]*/g
+	},
+	{
+		className: "variable",
+		regex: /\$(?:ENV|CACHE)?\{[^}\n]+\}/g
+	},
+	{
+		className: "keyword",
+		regex: /\b(?:break|continue|else|elseif|endforeach|endfunction|endif|endmacro|endwhile|if|include|macro|return|while)\b/gi
+	},
+	{
+		className: "literal",
+		regex: /\b(?:FALSE|IGNORE|NOTFOUND|NO|OFF|ON|TRUE|YES)\b/gi
+	},
+	{
+		className: "function",
+		regex: /\b[A-Za-z_][\w-]*(?=\s*\()/g
+	},
+	{
+		className: "number",
+		regex: /\b\d+(?:\.\d+)?\b/g
+	},
+	{
+		className: "operator",
+		regex: /(?:LESS_EQUAL|GREATER_EQUAL|STREQUAL|IN_LIST|MATCHES|EQUAL|LESS|GREATER|AND|OR|NOT|[=<>+*/!-])/gi
+	}
+], b = c({
+	name: "cmake",
+	tokenize(e) {
+		return v(e, y);
+	}
+}), x = [
+	{
+		className: "comment",
+		regex: /\/\/[^\n]*|\/\*[\s\S]*?\*\//g
+	},
+	{
+		className: "string",
+		regex: /"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'/g
+	},
+	{
+		className: "meta",
+		regex: /^[ \t]*#[ \t]*(?:include|define|if|ifdef|ifndef|elif|else|endif|pragma|undef|error|warning)\b/gm
+	},
+	{
+		className: "keyword",
+		regex: /\b(?:alignas|alignof|and|asm|atomic_cancel|atomic_commit|atomic_noexcept|auto|bitand|bitor|break|case|catch|co_await|co_return|co_yield|class|compl|concept|const|consteval|constexpr|constinit|const_cast|continue|default|delete|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|goto|if|inline|mutable|namespace|new|noexcept|not|operator|or|private|protected|public|reflexpr|register|reinterpret_cast|requires|return|sizeof|static|static_assert|static_cast|struct|switch|synchronized|template|this|thread_local|throw|try|typedef|typeid|typename|union|using|virtual|volatile|while|xor)\b/g
+	},
+	{
+		className: "type",
+		regex: /\b(?:bool|char|char8_t|char16_t|char32_t|double|float|int|long|short|signed|unsigned|void|wchar_t)\b/g
+	},
+	{
+		className: "literal",
+		regex: /\b(?:NULL|nullptr|true|false)\b/g
+	},
+	{
+		className: "function",
+		regex: /\b[A-Za-z_]\w*(?=\s*\()/g
+	},
+	{
+		className: "number",
+		regex: /\b(?:0[xX][\da-fA-F']+|0[bB][01']+|\d[\d']*(?:\.\d[\d']*)?(?:[eE][+-]?\d[\d']*)?[uUlLfF]*)\b/g
+	},
+	{
+		className: "operator",
+		regex: /(?:<<=?|>>=?|->\*|->|\+\+|--|&&|\|\||==|!=|<=|>=|::|\+=|-=|\*=|\/=|%=|&=|\|=|\^=|[-+*/%=&|^!<>?:~])/g
+	}
+], S = c({
+	name: "cpp",
+	aliases: [
+		"c++",
+		"cc",
+		"cxx",
+		"hpp"
+	],
+	tokenize(e) {
+		return v(e, x);
+	}
+}), C = {
+	tsx: { aliases: ["typescriptreact"] },
+	ts: { aliases: ["typescript"] },
+	css: { aliases: ["scss"] },
+	shell: { aliases: [
+		"bash",
+		"sh",
+		"zsh",
+		"shellscript"
+	] },
+	json: { aliases: [] },
+	cpp: { aliases: [
+		"c++",
+		"cc",
+		"cxx",
+		"hpp"
+	] },
+	python: { aliases: ["py"] },
+	cmake: { aliases: [] }
+}, w = Object.keys(C), T = [...w, ...Object.values(C).flatMap(({ aliases: e }) => e)];
+function E(e) {
+	return T.includes(e);
+}
+function D(e, t) {
+	return e.aliases.includes(t);
 }
-var b = {
-	shellscript: "shell",
-	scss: "css"
-}, x = s({
+function O(e) {
+	for (let [t, n] of Object.entries(C)) if (D(n, e)) return t;
+	return e;
+}
+var k = s({
 	languages: [
+		_,
+		g,
+		d,
 		h,
+		f,
+		S,
 		m,
-		u,
-		p,
-		d,
-		f
+		b,
+		p
 	],
 	fallbackLanguage: "plaintext"
 });
-function S(e, t) {
-	let n = b[t] ?? t, { tokens: r } = x.tokenize(e, { lang: n });
-	return c(l(r));
+function A(e, t) {
+	let n = O(t), { tokens: r } = k.tokenize(e, { lang: n });
+	return l(u(r));
 }
 //#endregion
 //#region src/integrations/code-highlight/code-highlight.tsx
-var C = /* @__PURE__ */ e({
-	Block: () => T,
-	Inline: () => E,
+var j = /* @__PURE__ */ e({
+	Block: () => N,
+	Inline: () => P,
 	InlineLink: () => n
 });
-function w(e, t) {
+function M(e, t) {
 	return a(() => {
-		if (!(t == null || e === "")) return /* @__PURE__ */ o("span", { dangerouslySetInnerHTML: { __html: S(e, t) } });
+		if (!(t == null || e === "")) return /* @__PURE__ */ o("span", { dangerouslySetInnerHTML: { __html: A(e, t) } });
 	}, [e, t]);
 }
-function T({ language: e, children: t, ...n }) {
-	let i = w(t, e);
+function N({ language: e, children: t, ...n }) {
+	let i = M(t, e);
 	return /* @__PURE__ */ o(r, {
 		...n,
 		language: e,
@@ -66,19 +195,19 @@ function T({ language: e, children: t, ...n }) {
 		children: t
 	});
 }
-T.displayName = "Code.Block";
-function E({ language: e, children: t, ...n }) {
-	let r = w(t, e);
+N.displayName = "Code.Block";
+function P({ language: e, children: t, ...n }) {
+	let r = M(t, e);
 	return /* @__PURE__ */ o(i, {
 		...n,
 		highlighted: r,
 		children: t
 	});
 }
-E.displayName = "Code.Inline";
+P.displayName = "Code.Inline";
 //#endregion
 //#region src/integrations/code-highlight/code-highlight.meta.ts
-var D = {
+var F = {
 	name: "CodeHighlight",
 	category: t.display,
 	status: "experimental",
@@ -94,4 +223,4 @@ var D = {
 	}
 };
 //#endregion
-export { C as Code, g as SUPPORTED_LANGUAGES, D as codeHighlightMeta, y as isSupportedLanguage };
+export { j as Code, w as SUPPORTED_LANGUAGES, F as codeHighlightMeta, E as isSupportedLanguage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imfusion/web-ui",
-  "version": "0.5.1-dev.41.g45c10e85",
+  "version": "0.5.1-dev.45.gf3889fa8",
   "description": "The official Web UI component library for ImFusion web apps",
   "author": "ImFusion GmbH",
   "license": "UNLICENSED",

package/src/llms/skills/imf-web-ui-audit/SKILL.md

@@ -4,49 +4,76 @@ description:
   "Read-only health check for an ImFusion frontend against the conventions baseline. Audit the full project or any topic,
   including library-setup, tooling, git, npm-project, authentication, project-structure, docs-structure, data, testing,
   React, TypeScript, class names, validation, components, styling, assets, library-boundary, and tokens. Reports broken
-  pieces, missing pieces, working deviations, present evidence, and unverified state in AUDIT_REPORT.md."
+  pieces, missing pieces, working deviations, present evidence, and unverified state, then turns them into an actionable
+  plan."
 argument-hint: "[full|<topic>]"
 allowed-tools: Read Glob Grep
 ---
 
 # imf-web-ui-audit
 
-You are the frontend health-check auditor. Investigate the repository statically, record every supported conclusion in
-`AUDIT_REPORT.md`, and return the report path and a short verdict. Follow the applicable `imf-web-ui-conventions` topics,
-cite repository evidence, distinguish defects from working deviations, and never present the baseline as universal best
-practice.
+You are the frontend health-check auditor, and you run as an orchestrator: one investigator per topic gathers the evidence,
+you merge their findings and turn them into an actionable plan. Follow the applicable `imf-web-ui-conventions` topics, cite
+repository evidence, distinguish defects from working deviations, and never present the baseline as universal best practice.
+
+An audit belongs in plan mode: it ends in work to approve, not in files to write.
 
 ## Workflow
 
 1. Resolve the argument. Bare means `full`; a topic selects one row below. If no topic matches, list every available topic
    instead of guessing or widening the scope.
-2. Read every applicable convention topic and inspect the repository with `Read`, `Glob`, and `Grep` only.
-3. Work through the shared [convention audit checklist](../imf-web-ui-conventions/templates/AUDIT_CHECKLIST.md), checking
-   every row for a full audit and the requested row plus dependencies for a scoped audit.
-4. Check the complete installed skill bundle, version markers, AGENTS fence, lifecycle hooks, registrations, and staleness
-   wiring when `agent-tooling` is in scope. Compare the declared version in `package.json`, the installed
-   `node_modules/@imfusion/web-ui/package.json`, and every `.imf-web-ui-skill-version.json` marker. Report drift and point at
-   `imf-web-ui-update`. The registry is unreachable from this audit, so a line saying that a newer version may exist is
-   unverified.
-5. Write or refresh `AUDIT_REPORT.md` from the shared report contract at
-   [`../imf-web-ui-conventions/templates/REPORT.md`](../imf-web-ui-conventions/templates/REPORT.md), changing the mode label
-   to `audit`. The template is the report contract. Preserve everything under `## Reviewer notes` verbatim.
+2. Enter the host's plan mode, unless one of the exceptions after step 5 applies. If plan mode is not already active, use the
+   host plan-mode control before dispatching anything.
+3. Dispatch one investigator per in-scope topic, using the host's subagent mechanism, as concurrently as the host allows.
+   Investigators are cheap and narrow: each one gets a single topic and reports back. A host with no subagent mechanism is
+   not a blocker — work the topics inline in this session, in the same order, to the same contract.
+4. Merge what comes back. Findings you did not gather yourself are the report; do not re-inspect files an investigator
+   covered. Reconcile conflicts by reading the cited evidence, and drop any finding whose citation does not hold.
+5. Deliver the merged report and the plan in the host plan, from the shared report contract at
+   [`../imf-web-ui-conventions/templates/REPORT.md`](../imf-web-ui-conventions/templates/REPORT.md), with the mode label
+   `audit`. The plan's ordered steps are the `Next action` lines of the findings, grouped by topic and cheapest-first;
+   `Present` findings produce no steps.
+
+Some runs take the report somewhere other than a plan. When the human asks for the durable file, or the host has no plan
+mode, write the same content to `AUDIT_REPORT.md` and preserve everything under `## Reviewer notes` verbatim. When another
+skill invokes the audit as its verification step, report the findings to that caller and stay out of plan mode — the caller
+owns the flow, and the human has usually just left plan mode to let its work happen.
+
+## Dispatching an investigator
+
+Each investigator prompt carries, in full:
+
+- the topic name and the path of its convention topic file;
+- the topic's block from the shared [convention audit checklist](../imf-web-ui-conventions/templates/AUDIT_CHECKLIST.md), and
+  the instruction to check every box in it;
+- the safety constraint below, verbatim — an investigator that reaches for a shell breaks the audit's only guarantee;
+- the report contract's entry format, so findings arrive mergeable: severity, reference, short title, `path:line` evidence,
+  impact, next action;
+- the instruction to report findings back as its result and write no files.
+
+An investigator reports on its topic alone. Anything it notices outside that topic goes back as a note for the orchestrator
+to route, not as a finding it rules on.
 
 ## Checklist
 
-Use the shared [convention audit checklist](../imf-web-ui-conventions/templates/AUDIT_CHECKLIST.md) as the working checklist.
-The report is not complete until the applicable rows have been inspected and their evidence is reflected in the report. The
+The shared [convention audit checklist](../imf-web-ui-conventions/templates/AUDIT_CHECKLIST.md) is the working checklist: a
+full audit covers every block, a scoped audit covers the requested block plus its dependencies. The audit is not complete
+until every in-scope box has been checked by the investigator that owns it and its evidence appears in the report. The
 checklist itself is not edited during an audit.
 
 ## Safety
 
 Use only static inspection: Read, Glob, Grep, and equivalent non-executing search tools. Do not use a shell or invoke Node,
 npm, npx, package scripts, hooks, config imports, linters, tests, builds, Git commands, or project binaries. Read config as
-text and report runtime or machine-local state that cannot be established statically as unverified.
+text and report runtime or machine-local state that cannot be established statically as unverified. This binds every
+investigator too — a dispatched agent inherits the audit's constraint, not the host's default freedom, so the prompt that
+dispatches it repeats this paragraph verbatim.
 
-Only `AUDIT_REPORT.md` may be written. Write is intentionally not pre-approved in `allowed-tools`; the report follows the
-host's ordinary write approval. Host-managed hooks may run after that write; the skill neither invokes nor suppresses them,
-but it does report broken or unexpected hook behavior found during static inspection.
+An audit writes at most one file: `AUDIT_REPORT.md`, in the two cases named in the workflow. Investigators write nothing.
+Neither Write nor the host's dispatch tool is pre-approved in `allowed-tools` — `allowed-tools` names what an audit needs on
+every run, and both of these follow the host's ordinary approval when a run needs them. Host-managed hooks may run after that
+write; the skill neither invokes nor suppresses them, but it does report broken or unexpected hook behavior found during
+static inspection.
 
 ## Topics
 
@@ -83,5 +110,10 @@ three injection hooks, the stop gate, plus `baseline-staleness.sh` — are drift
 `baseline-staleness.sh`. Read files and settings as text—do not run installers, hooks, or local config queries during
 assessment.
 
+Version drift is part of this topic: compare the declared version in `package.json`, the installed
+`node_modules/@imfusion/web-ui/package.json`, and every `.imf-web-ui-skill-version.json` marker, then report the drift and
+point at `imf-web-ui-update`. The registry is unreachable from a static audit, so a line saying that a newer version may
+exist is unverified.
+
 Use the shared report template as the report contract. It defines the headings, ordering, empty-section marker, evidence
 format, and reviewer-note preservation rules; do not duplicate that contract here.

package/src/llms/skills/imf-web-ui-setup/SKILL.md

@@ -18,20 +18,36 @@ report file as a substitute for the host plan.
 
 ## Workflow
 
-1. Resolve the argument. Bare means `full`; a topic selects one supported setup topic. For an unsupported topic, list the
-   available setup topics and point the human to `imf-web-ui-audit` for a read-only report.
+1. Resolve the argument, not the prose. Bare means `full`; a topic argument selects one supported setup topic. A prompt that
+   merely _mentions_ one area ("wire up the tooling", "get the project set up") is still a `full` run — the words describe a
+   starting point, not a scope that excludes the rest. For a greenfield `full` run the application boundary (router, route
+   groups, current-user query, AppShell) is part of the deliverable even when the prompt never names it; propose it and let
+   the human remove it, never silently defer it as "out of scope." For an unsupported topic argument, list the available
+   setup topics and point the human to `imf-web-ui-audit` for a read-only report.
 2. Enter the host's plan mode. If it is not already active, use the host plan-mode control before inspecting and planning.
 3. Read the selected convention topics and inspect the repository with `Read`, `Glob`, and `Grep` only.
 4. Build the complete proposal in the host plan from the shared report contract at
    [`../imf-web-ui-conventions/templates/REPORT.md`](../imf-web-ui-conventions/templates/REPORT.md). Include the concrete
    content of every file the approved setup would create or change, with repository evidence for each decision.
-5. For a greenfield project, propose the minimal branded `AppShell` in the authenticated route group by default. If the human
-   explicitly says the product has no persistent authenticated navigation, ask whether to omit the shell before finalizing
-   the proposal; keep the `_app/` boundary either way. Existing projects keep their working shell choice. This ticket
-   documents the starter shape but does not copy a full starter template.
+5. A greenfield `full` setup proposes the whole starter skeleton, not just tooling — tooling without the application boundary
+   is an unfinished setup. Include, as concrete files in the plan:
+   - the TanStack Router **package added to `package.json`** (with its router devtools as a dev dependency), not just
+     imported — code that imports an uninstalled package is an incomplete setup
+     ([project-structure.md](../imf-web-ui-conventions/topics/project-structure.md));
+   - pathless `_public/` and `_app/` route groups behind one server-backed current-user boundary
+     ([authentication.md](../imf-web-ui-conventions/topics/authentication.md));
+   - the minimal branded `AppShell` in `_app/` by default — omit the shell only when the human explicitly says the product
+     has no persistent authenticated navigation (ask first), but keep the `_app/` boundary either way;
+   - a per-topic `api/` folder for any data the first screen shows, never an inline fixture in the component
+     ([data.md](../imf-web-ui-conventions/topics/data.md)).
+
+   The plan documents this starter shape as concrete file content; it does not copy a full external starter template.
+   Existing projects keep their working choices — propose only the gaps.
+
 6. Keep the plan as the approval gate. After the host approves and exits plan mode, write only the listed files. Complete any
-   immediately requested bootstrap work covered by that approved plan, then invoke `imf-web-ui-audit full` and review its
-   `AUDIT_REPORT.md` before declaring the setup complete.
+   immediately requested bootstrap work covered by that approved plan, then invoke `imf-web-ui-audit full` as a verification
+   step and review the findings it reports back before declaring the setup complete. The audit stays out of plan mode here —
+   the human has just left it to let this work happen.
 
 Installer and hook runs stay with the human: an `agent-tooling` proposal lists the `npx web-ui-install` commands as human
 steps, applies the judgment from the topic (read existing registrations first, never stack a hook on a covered event), and

package/src/llms/skills/imf-web-ui-update/SKILL.md

@@ -135,8 +135,8 @@ If no findings exist, report that the installed update has no detected compatibi
 candidates. Do not create an empty migration commit.
 
 Whatever the migration outcome, close the phase by asking whether to run `imf-web-ui-audit full`: an update can shift the
-baseline (new components, hooks, conventions), and the audit report shows where the project now stands against it. Run it
-only on an explicit yes.
+baseline (new components, hooks, conventions), and the audit shows where the project now stands against it. Run it only on an
+explicit yes.
 
 ## Migration approval