@jahia/agentic 0.4.1 → 0.5.1

package/dist/kiro/.kiro/skills/jahia-jcr-sql2/SKILL.md

@@ -0,0 +1,257 @@
+---
+name: jahia-jcr-sql2
+description: JCR-SQL2 reference for Jahia queries. Use when building, reviewing, or debugging SQL2 statements for content listings, full-text search, sorting, pagination, or Java back-end query code.
+---
+
+# Skill: jahia-jcr-sql2
+
+Use this skill when you need the JCR-SQL2 language itself: selectors, path constraints, filters, ordering, full-text syntax, joins, pagination rules, and performance guardrails.
+
+---
+
+## When to use JCR-SQL2
+
+JCR-SQL2 is the standard Jahia query language for:
+
+- listing pages or content with filtering and sorting
+- querying a folder subtree
+- searching by property value, date, or reference
+- full-text search across indexed content
+- back-end Java code using `QueryManagerWrapper`
+- template-set listings that use `useJCRQuery` or the Page Builder query component
+
+---
+
+## Basic syntax
+
+### Select by node type
+
+```sql
+SELECT * FROM [jnt:page] AS page
+SELECT * FROM [jnt:content] AS content
+SELECT * FROM [jnt:file] AS file
+```
+
+The selector matches the named type and its subtypes.
+
+### Common node types
+
+| Type | Meaning |
+|------|---------|
+| `jnt:page` | pages |
+| `jnt:content` | editorial content |
+| `jnt:file` | files |
+| `jnt:virtualsite` | sites |
+| `jmix:searchable` | general searchable content |
+| `nt:base` | all nodes — avoid unless paired with a strict path |
+
+---
+
+## Path constraints
+
+### Recursive subtree
+
+```sql
+SELECT * FROM [jnt:page] AS page
+WHERE ISDESCENDANTNODE(page, '/sites/luxe/home')
+```
+
+### Direct children only
+
+```sql
+SELECT * FROM [jnt:page] AS page
+WHERE ISCHILDNODE(page, '/sites/luxe/home')
+```
+
+**Guardrail:** always constrain by path to avoid repository-wide scans.
+
+---
+
+## Property constraints
+
+### Exact match
+
+```sql
+WHERE page.[j:templateName] = 'home'
+WHERE node.[jcr:title] = 'My Title'
+```
+
+### Pattern match
+
+```sql
+WHERE node.[jcr:title] LIKE '%keyword%'
+WHERE node.[j:nodename] LIKE '%.png'
+```
+
+### Null checks
+
+```sql
+WHERE page.[jcr:title] IS NOT NULL
+```
+
+### Boolean
+
+```sql
+WHERE node.[j:published] = CAST('true' AS BOOLEAN)
+```
+
+### Date comparison
+
+```sql
+WHERE page.[jcr:lastModified] > CAST('2026-01-01T00:00:00.000Z' AS DATE)
+```
+
+Use the millisecond form `yyyy-MM-dd'T'HH:mm:ss.SSSX` for SQL2 date casts.
+
+### Multiple conditions
+
+```sql
+WHERE ISDESCENDANTNODE(page, '/sites/luxe')
+  AND page.[jcr:lastModified] > CAST('2026-01-01T00:00:00.000Z' AS DATE)
+```
+
+### OR conditions
+
+```sql
+WHERE node.[jcr:primaryType] = 'jnt:bigText'
+   OR node.[jcr:primaryType] = 'jnt:article'
+```
+
+---
+
+## Ordering
+
+```sql
+ORDER BY page.[jcr:lastModified] DESC
+ORDER BY page.[jcr:created] ASC
+ORDER BY node.[jcr:title]
+```
+
+Multiple columns:
+
+```sql
+ORDER BY page.[j:templateName] ASC, page.[jcr:lastModified] DESC
+```
+
+---
+
+## Full-text search
+
+### Search indexed content
+
+```sql
+WHERE CONTAINS(node.*, 'digital')
+```
+
+### Search one property
+
+```sql
+WHERE CONTAINS(node.[jcr:title], 'welcome')
+```
+
+### Expression syntax
+
+| Syntax | Meaning |
+|--------|---------|
+| `term` | must contain the term |
+| `term1 term2` | implicit AND |
+| `term1 OR term2` | either term |
+| `"exact phrase"` | exact phrase |
+| `-term` | exclude term |
+
+### Relevance sort
+
+```sql
+SELECT * FROM [jnt:content] AS n
+WHERE ISDESCENDANTNODE(n, '/sites/luxe')
+  AND CONTAINS(n.*, 'digital')
+ORDER BY SCORE(n) DESC
+```
+
+Combine full-text with path constraints for performance.
+
+---
+
+## Joins
+
+```sql
+SELECT * FROM [jnt:imageReferenceLink] AS img
+INNER JOIN [jnt:file] AS file
+ON img.[j:node] = file.[jcr:uuid]
+WHERE img.[j:node] = 'UUID'
+```
+
+Jahia supports inner joins, but keep them focused and path-constrained whenever possible.
+
+---
+
+## Using SQL2 in Jahia code
+
+### Template-set listing with `useJCRQuery`
+
+```tsx
+const posts = useJCRQuery({
+  query: `SELECT * FROM [namespace:blogPost] AS post
+          WHERE ISDESCENDANTNODE(post, '/sites/${siteKey}/contents/blog')
+          ORDER BY post.[publicationDate] DESC`,
+});
+```
+
+### Java back-end query execution
+
+```java
+QueryManagerWrapper qm = session.getWorkspace().getQueryManager();
+QueryWrapper query = qm.createQuery(sql2Statement, Query.JCR_SQL2);
+query.setLimit(limit);
+query.setOffset(offset);
+JCRNodeIteratorWrapper nodes = query.execute().getNodes();
+```
+
+**Guardrail:** never embed `LIMIT` or `OFFSET` inside the SQL2 string. Use `setLimit()` and `setOffset()`.
+
+---
+
+## Security and validation
+
+### Escape user input
+
+In Java back-end code, escape user-provided values with `JCRContentUtils.sqlEncode()` before interpolating them into a SQL2 string.
+
+```java
+String safeValue = JCRContentUtils.sqlEncode(userInput);
+```
+
+### Validate dynamic sort fields
+
+If a user can choose the sort field, validate it against a whitelist before interpolating it into `ORDER BY`.
+
+---
+
+## Performance best practices
+
+1. Always constrain by path.
+2. Use the most specific node type possible.
+3. Keep result sets small.
+4. Prefer indexed equality filters over broad `LIKE '%...%'` patterns.
+5. Use full-text sparingly on large trees.
+6. Sort on common indexed fields such as `jcr:lastModified` or `jcr:created`.
+7. Cap API result limits to a sane maximum.
+
+---
+
+## Quick checklist
+
+- [ ] Query has a path constraint
+- [ ] Node type is specific
+- [ ] Sort field is intentional and safe
+- [ ] Full-text is combined with a subtree path
+- [ ] Dates use `yyyy-MM-dd'T'HH:mm:ss.SSSX`
+- [ ] Java code uses `setLimit()` and `setOffset()` instead of inline SQL clauses
+
+---
+
+## Related skills
+
+- `/jahia-dev-query-content` — apply SQL2 inside Page Builder queries and JS module views
+- `/jahia-cnd-author` — define the content types you will query
+

package/dist/kiro/.kiro/skills/jahia-review/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: jahia-review
+description: Full quality review of a Jahia JavaScript module — runs code review and live site review in parallel via subagents. Use after deploying to get a complete pass/fail signal before finalizing work.
+allowed-tools: Agent, Bash, Read
+---
+
+# Skill: jahia-review
+
+Runs both `/jahia-review-code` and `/jahia-review-site` in parallel via independent subagents, then consolidates their findings. Use this before writing `pages.json` or marking work complete.
+
+---
+
+## Step 1 — Collect live URLs
+
+Read `pages.json` to get the list of live page URLs:
+
+```bash
+cat pages.json
+```
+
+---
+
+## Step 2 — Spawn review subagents in parallel
+
+Invoke two subagents simultaneously:
+
+**Subagent A — code review:**
+> Invoke `/jahia-review-code` on this module. Scan all CND files, TypeScript views, and page templates. Report every issue found (critical, warning, suggestion) with file locations and fix guidance.
+
+**Subagent B — site review:**
+> Invoke `/jahia-review-site` against the URLs in `pages.json`. Run the review script and report every a11y and SEO violation found.
+
+---
+
+## Step 3 — Consolidate and report
+
+Combine findings from both subagents into a single report:
+
+```
+## Review Results
+
+### Code (jahia-review-code)
+[findings from subagent A]
+
+### Site (jahia-review-site)
+[findings from subagent B]
+
+### Verdict
+✅ PASS — no violations found.
+❌ FAIL — N issue(s) must be fixed before finalizing.
+```
+
+---
+
+## Step 4 — Fix and iterate
+
+If any violations were found:
+
+1. Fix every reported issue
+2. Redeploy: `yarn build && yarn jahia-deploy`
+3. Re-run `/jahia-review` until the verdict is ✅ PASS
+
+Only proceed (write `pages.json`, mark work complete) once the review passes.

package/dist/kiro/.kiro/skills/jahia-review-code/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: jahia-review-code
+description: Reviews a Jahia JavaScript module for generic and Jahia-specific best practices. Scans CND definitions, TypeScript views, and page templates. Reports issues in order of importance with fix suggestions. Covers 8 critical checks, 9 warnings, and 10 suggestions.
+allowed-tools: Bash, Read
+---
+
+# Skill: jahia-review-code
+
+Reviews a Jahia JavaScript module for correctness and best practices. Scans real files, reports issues in order of severity (🔴 Critical → 🟡 Warning → 🔵 Suggestion), and proposes fixes.
+
+---
+
+## Step 1 — Locate the module
+
+Find the module root: look for `package.json` with `@jahia/javascript-modules-library`. Determine the `src/` directory.
+
+```bash
+find . -name "package.json" -not -path "*/node_modules/*" | xargs grep -l "javascript-modules-library" 2>/dev/null | head -1
+```
+
+---
+
+## Step 2 — Collect files to review
+
+```bash
+find src/ -name "definition.cnd" | sort
+find src/ -name "*.server.tsx" | sort
+find src/ -name "*.client.tsx" | sort
+find src/ -name "types.ts" | sort
+find src/templates/ -name "*.server.tsx" | sort
+cat settings/definitions.cnd
+```
+
+Read ALL collected files before starting the review.
+
+---
+
+## Step 3 — Run checks in order of severity
+
+### 🔴 CRITICAL — Will cause broken editor UX, broken pages, or security issues
+
+**C1 — `jmix:droppableContent` used directly**
+Check: any CND type (not mixin declarations in settings/definitions.cnd) extending `jmix:droppableContent` directly.
+Fix: extend the module's custom component mixin (e.g. `namespacemix:component`) instead.
+
+**C2 — `fullPage` view uses `componentType: "template"`**
+Check: any `name: "fullPage"` view that also has `componentType: "template"`.
+Fix: change to `componentType: "view"`. The `src/templates/MainResource/default.server.tsx` template already routes `jmix:mainResource` nodes to the `fullPage` view.
+
+**C3 — `j:linknode` or `j:url` explicitly declared in CND**
+Check: any CND type that explicitly declares `j:linknode` or `j:url` fields alongside `choicelist[linkTypeInitializer]`.
+Fix: remove those two fields from the CND. They are injected automatically by Jahia's mixins at runtime. Only declare `- j:linkType (string, choicelist[linkTypeInitializer])`. The fields remain available in `types.ts` and in the view.
+
+**C4 — `j:linkType` used as a URL in a view**
+Check: any `.server.tsx` or `.client.tsx` file that uses `props["j:linkType"]` or `j:linkType` directly as an `href`.
+Fix: use a `switch (props["j:linkType"])` with `buildNodeUrl(props["j:linknode"])` for internal and `props["j:url"]` for external.
+
+**C5 — Weakreference node properties read directly in a view (cache issue)**
+Check: views that access `.getPropertyAsString()`, `.getProperty(...)`, or property destructuring from a weakreference prop (other than `buildNodeUrl`).
+Fix: render the referenced node via `<Render node={refNode} view="..." />` to get proper cache invalidation.
+
+**C6 — Client component imports server-only APIs**
+Check: any `.client.tsx` file that imports from `@jahia/javascript-modules-library` (except `Island` which is re-exported).
+Fix: move server-side logic to the `.server.tsx` wrapper and pass results as serializable props to the Island.
+
+**C7 — Cache explicitly disabled (`cache.expiration="0"`)**
+Check: any `jahiaComponent` call with `properties: { "cache.expiration": "0" }`.
+Fix: never set expiration to 0. If truly fresh data is needed, use a small value like `"5"` (5 seconds) to still protect under load.
+
+**C8 — Generic area type used for every Area**
+Check: page templates where every `<Area>` uses the same generic area type (e.g. `nodeType="namespace:pageArea"` everywhere). This means editors see ALL `pageComponent` types as droppable options in every area — a hero section will appear as an option in a feature card grid.
+Fix: create **one typed area node per section** in `settings/definitions.cnd`, each with a tight child constraint:
+```cnd
+[namespace:heroArea] > jnt:content, jmix:list, jmix:hiddenType orderable
+ + * (namespace:heroSection)
+
+[namespace:featuresArea] > jnt:content, jmix:list, jmix:hiddenType orderable
+ + * (namespace:featureCard)
+```
+Only use a generic `pageArea` for flexible areas (e.g. footer) where any component is valid.
+
+---
+
+### 🟡 WARNING — Will likely cause editor confusion, stale content, or runtime errors
+
+**W1 — User-facing string fields without `i18n`**
+Check: CND string/textarea/richtext properties that don't have `i18n` (exclude system properties like `j:linkType`, `j:url`, non-user-facing fields).
+Fix: add `i18n` to all user-visible text properties.
+
+**W2 — `jmix:mainResource` on non-content types**
+Check: CND types that have `jmix:mainResource` but no richtext body or no obvious "detail page" use case (e.g. a visual composition type like a card or hero).
+Fix: only use `jmix:mainResource` for content that genuinely needs both a listing card AND a full-page detail view.
+
+**W3 — Structural container types missing `jmix:hiddenType`**
+Check: CND types that have no `namespacemix:component` mixin (so they can't be dropped as components) but also don't have `jmix:hiddenType` — editors would never see them but they don't show up with a clear "hidden" intent.
+Fix: add `jmix:hiddenType` to structural/container types. Do NOT use `jmix:studioOnly` — it can interfere with area rendering.
+
+**W4 — Props not typed as optional (`?:`) / not guarded in views**
+Check: (a) `types.ts` props typed as required (`title: string`) — all props must use `?:` because Jahia does not guarantee values are present at render time. (b) Views that use props without null/undefined guards, especially `buildNodeUrl(prop)` — passing `undefined` throws `"Expected a node in buildNodeUrl, received undefined"`.
+Fix: use `?:` for all props in `types.ts`. Add conditional rendering (`{prop && <span>{prop}</span>}`) and guard node URLs (`prop ? { backgroundImage: \`url(${buildNodeUrl(prop)})\` } : undefined`).
+
+**W5 — `weakreference multiple` not null-filtered before `.map()`**
+Check: views mapping over a `weakreference multiple` prop without `.filter(x => x !== null)`.
+Fix: `items?.filter(item => item !== null).map(...)`.
+
+**W6 — Cache not configured for views using external/dynamic data**
+Check: views that call external functions, use `Date.now()`, or fetch data, without `properties: { "cache.expiration": "..." }`.
+Fix: add `cache.expiration` to the `jahiaComponent` properties.
+
+**W7 — Missing `import.xml` or no homepage defined**
+Check: look for `import.xml` at the module root. If absent or if it doesn't contain `j:isHomePage="true"`, editors won't have a default homepage.
+Fix: add an `import.xml` with a homepage node (`j:isHomePage="true"`). Also add "Offline pages/Models", "Offline pages/Drafts", "Offline pages/Archive" folders with `jmix:systemNameReadonly` and `jmix:nolive` mixins. Add content folders with `jmix:contributeMode` restrictions where appropriate.
+
+**W8 — Node type extends something other than `jnt:content`**
+Check: CND types that extend anything other than `jnt:content`, `jnt:page`, `jmix:*`, or standard Jahia base types.
+Fix: extend only `jnt:content` (or `jnt:page` for page types). To add fields to a type you don't control, use a mixin with `extends=<targetType>`. Unusual inheritance chains break edition interfaces in unpredictable ways.
+
+**W9 — Hardcoded link URLs in views**
+Check: any `.server.tsx`, `.client.tsx`, or template file containing a literal `href="http`, `href="/"`, or `href="/en/` (except in edit-mode chrome helpers). Also flag plain string `src="http` for non-bundled assets. Also flag any content data with `j:linkType: "external"` pointing to a path that looks like an internal Jahia URL (e.g. `/sites/`, `/cms/`, `/en/`).
+Fix: **All navigable URLs must come from contributed content.** Use `j:linkType`/`j:linknode`/`j:url` props for editorial links, `buildNodeUrl(node)` for JCR node links.
+🚫 **NEVER use `j:linkType: "external"` to link to an internal Jahia page** — use `"internal"` + `j:linknode`. An external URL pointing internally breaks on environment changes, language switches, live/preview workspace toggling, and vanity URL rewrites. If no target page exists yet, omit the link; do not substitute an external workaround.
+
+---
+
+### 🔵 SUGGESTION — Quality improvements
+
+**S1 — Non-semantic HTML**
+Check: views that use `<div>` where `<article>`, `<section>`, `<nav>`, `<header>`, or `<footer>` would be more appropriate.
+Fix: use semantic HTML for better accessibility and SEO.
+
+**S2 — Images without meaningful alt text**
+Check: `<img>` tags with `alt=""` or no `alt` attribute (unless there's a comment saying it's decorative).
+Fix: add descriptive alt text. Decorative images should have `alt=""` with a comment.
+
+**S3 — Accessibility violations (axe-core audit)**
+Check: run `/jahia-dev-accessibility` against all live pages. A clean module has zero `critical` or `serious` violations.
+Common issues in Jahia modules:
+- `color-contrast`: hardcoded colours with insufficient contrast ratio — check with https://webaim.org/resources/contrastchecker/
+- `image-alt`: `<img>` missing a meaningful `alt` prop sourced from CND
+- `button-name`: icon-only `<button>` or `<a>` without `aria-label`
+- `landmark-one-main`: page template missing a `<main>` wrapper
+- `page-has-heading-one`: no `<h1>` rendered on any page
+- `heading-order`: skipped heading levels between components (e.g. h1 → h3)
+- `html-has-lang`: template not setting `lang` via `useServerContext().currentLanguage`
+- `focus-visible` suppressed: global `* { outline: none }` in CSS kills keyboard navigation
+
+Fix: identify each violating component by matching the axe target selector to a `.server.tsx` file, apply the fix, rebuild, and re-run the audit.
+
+**S4 — Types using `any`**
+Check: `types.ts` files or view files using TypeScript `any`.
+Fix: use `JCRNodeWrapper` for node references, `string` / `number` / `boolean` for primitives.
+
+**S5 — Bare `<Area>` without a `nodeType`**
+Check: page templates using `<Area name="..." />` without a `nodeType` prop.
+Fix: create a custom area type with `jmix:list`, `jmix:hiddenType`, and `orderable`, and reference it with `nodeType="namespace:areaType"`.
+
+**S6 — `mix:title` inherited but `jcr:title` not in `types.ts`**
+Check: CND types that extend `mix:title` but whose `types.ts` doesn't include `"jcr:title": string`.
+Fix: add `"jcr:title"?: string` to the Props type.
+
+**S7 — Missing `.properties` file entries or icon for new content types**
+Check: for each node type found in `definition.cnd` files, verify that `settings/resources/<module>.properties` has a label (`cndNamespace_typeName=...`) and a corresponding icon exists at `settings/content-types-icons/<cndNamespace>_<typeName>.png`. The prefix must be the CND namespace (e.g. `ns_heroSection.png`), **not** the module name with hyphens (e.g. `my-module_heroSection.png` is wrong — the archetype generates wrong names that must be manually corrected).
+Fix: add labels (and optionally `ui.tooltip` for fields) to the properties files. Rename any icons that use the module name with hyphens to use the CND namespace. Create a 32×32 PNG icon (free source: [flaticon.com](https://www.flaticon.com/)). Without these, editors see raw technical names and blank icon squares in the content picker.
+
+**S8 — Hardcoded user-visible strings in views**
+Check: `.server.tsx` / `.client.tsx` files with JSX string literals that are not coming from props or i18n functions (e.g. `<p>Learn more</p>`, `<button>Submit</button>`).
+Fix: move UI labels to `settings/locales/en.json` and `fr.json` and resolve them with `useTranslation()`. Hardcoded strings break multilingual sites.
+
+**S9 — Content list queries not using `ISDESCENDANTNODE` (non-recursive)**
+Check: JCR-SQL2 queries using `jcr:path LIKE '/sites/.../content/%'` or a fixed path to limit results, instead of `ISDESCENDANTNODE(node, '/sites/.../content')`.
+Fix: use `ISDESCENDANTNODE` to ensure queries work correctly even if editors reorganize content into sub-folders.
+
+**S10 — No escape hatch when using a custom component mixin**
+Check: a custom section type that restricts children to a custom mixin (e.g. `+ * (namespacemix:component)`) but the module provides no "content stack" escape hatch type that itself accepts `jmix:droppableContent`.
+Fix: add a `namespace:contentStack > jnt:content, namespacemix:component + * (jmix:droppableContent)` type so power editors can still add arbitrary content when needed.
+
+**S11 — Scaffold/boilerplate components still present**
+Check: components under `src/components/Hello/` (or any other archetype-generated boilerplate) that are no longer referenced in `settings/import.xml` and no longer used by any view or page template.
+```bash
+# Check if Hello components are still referenced anywhere
+grep -r "helloWorld\|helloCard\|Hello/" src/templates/ settings/ --include="*.tsx" --include="*.xml" --include="*.cnd"
+```
+Fix: once `import.xml` no longer provisions Hello World content and no template uses them, delete the entire `src/components/Hello/` directory, remove their entries from `.properties` files, and delete their icons from `settings/content-types-icons/`. Keeping dead components inflates the content picker and confuses editors.
+
+---
+
+## Step 4 — Report results
+
+Format the output as:
+
+```
+## Jahia Module Review — <module name>
+
+### 🔴 Critical (N issues)
+[C1] src/components/Hero/Section/definition.cnd — `jmix:droppableContent` used directly
+     Fix: extend `namespacemix:component` instead
+
+### 🟡 Warnings (N issues)
+...
+
+### 🔵 Suggestions (N issues)
+...
+
+### ✅ Summary
+- N critical issues (must fix before shipping)
+- N warnings (fix before sharing with editors)
+- N suggestions (improve when time allows)
+```
+
+If no issues found in a category, print `✅ None`.
+
+---
+
+## Step 5 — Ask to fix
+
+After the report, ask: **"Would you like me to fix any of these issues?"**
+
+If yes, fix them — use the guidance from the relevant skill (`jahia-cnd-author`, `jahia-dev-create-view`) and run `yarn build && yarn jahia-deploy` to push changes.
+
+---
+
+## References
+
+- Native Jahia mixins & node types: https://github.com/Jahia/jahia/tree/master/war/src/main/webapp/WEB-INF/etc/repository/nodetypes
+- Integration best practices: https://github.com/Jahia/gautier-braindump/blob/main/articles/integration-best-practices/README.md
+- Developer training: https://github.com/Jahia/developer-training/blob/main/js-training/slides.md
+
+> If a check result is uncertain (e.g. "does this mixin exist?"), fetch the nodetypes directory above before reporting.

package/dist/kiro/.kiro/skills/jahia-review-site/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: jahia-review-site
+description: Scores live pages for accessibility and SEO.
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# Skill: jahia-review-site
+
+Reads URLs from `pages-to-review.json`, runs automated a11y and SEO checks, and — only if all checks pass — writes `pages.json`. Exits non-zero without writing `pages.json` if any violation is found.
+
+**A11y:** axe-core full ruleset (WCAG + best-practice) — any violation fails.
+
+**SEO:** Lighthouse SEO category — any failing audit fails. Violations reported by audit ID (e.g. `document-title`, `meta-description`, `hreflang`, `is-crawlable`, `link-text`, `image-alt`).
+
+---
+
+## Step 1 — Ensure tooling is installed
+
+```bash
+node -e "require('@axe-core/playwright'); require('playwright')" 2>/dev/null || \
+  npm install --no-save @axe-core/playwright playwright && npx playwright install chromium --with-deps
+```
+
+---
+
+## Step 2 — Run the review
+
+```bash
+SCRIPT=$(find .claude .agents -name "review-pages.mjs" 2>/dev/null | head -1)
+node "$SCRIPT" 2>&1 | tee /tmp/site-review.txt
+```
+
+---
+
+## Step 3 — Interpret and fix
+
+The script exits 1 if any page has any a11y violation or any failing Lighthouse SEO audit.
+
+After fixing, redeploy and re-run:
+
+```bash
+yarn build && yarn jahia-deploy
+node "$SCRIPT"
+```
+
+Iterate until the script exits 0 and `pages.json` is written.
+
+---
+
+## Validation checklist
+- [ ] Script exits 0 (zero a11y violations, zero failing SEO audits)
+- [ ] `pages.json` exists (created by the script on pass)

package/dist/kiro/.kiro/skills/jahia-review-site/scripts/review-pages.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// Reads URLs from pages-to-review.json, runs a11y (axe-core) + SEO (Lighthouse) checks.
+// On pass: writes pages.json and exits 0. On fail: exits 1 without writing pages.json.
+import { chromium } from "playwright";
+import { AxeBuilder } from "@axe-core/playwright";
+import lighthouse from "lighthouse";
+import { readFileSync, writeFileSync } from "fs";
+
+const SCORED_MODES = new Set(["binary", "numeric"]);
+
+const draft = readFileSync("pages-to-review.json", "utf-8");
+const urls = JSON.parse(draft);
+const port = 9222;
+const browser = await chromium.launch({
+  args: ["--no-sandbox", `--remote-debugging-port=${port}`],
+});
+const context = await browser.newContext();
+const page = await context.newPage();
+
+const results = [];
+
+for (const url of urls) {
+  process.stdout.write(`\nChecking ${url} … `);
+  await page.goto(url, { waitUntil: "networkidle", timeout: 30_000 });
+
+  // A11y
+  const axe = await new AxeBuilder({ page }).analyze();
+
+  // SEO — Lighthouse reuses the already-open browser via the debug port
+  const lhr = (await lighthouse(url, { port, output: "json", onlyCategories: ["seo"] }))?.lhr;
+  const seoViolations = lhr
+    ? Object.values(lhr.audits).filter(
+        a => SCORED_MODES.has(a.scoreDisplayMode) && a.score !== null && a.score < 1,
+      )
+    : [];
+
+  process.stdout.write(`a11y=${axe.violations.length} violation(s) seo=${seoViolations.length} violation(s)\n`);
+  results.push({ url, violations: axe.violations, seoViolations });
+}
+
+await browser.close();
+
+// ── Report ──────────────────────────────────────────────────────────────────
+let failed = false;
+
+for (const r of results) {
+  const pageOk = r.violations.length === 0 && r.seoViolations.length === 0;
+  if (!pageOk) failed = true;
+
+  console.log(`\n${"─".repeat(70)}`);
+  console.log(`${pageOk ? "✅" : "❌"} ${r.url}`);
+
+  for (const v of r.violations) {
+    console.log(`   ❌ A11y [${v.id}] — ${v.description} (${v.nodes.length} node${v.nodes.length !== 1 ? "s" : ""})`);
+    for (const node of v.nodes.slice(0, 3)) {
+      console.log(`        ${node.html.slice(0, 100)}`);
+    }
+  }
+
+  for (const a of r.seoViolations) {
+    console.log(`   ❌ SEO  [${a.id}] — ${a.title}`);
+    if (a.description) console.log(`        ${a.description.slice(0, 120)}`);
+  }
+}
+
+console.log(`\n${"═".repeat(70)}`);
+if (failed) {
+  console.log("\n❌ FAIL — fix the issues above, redeploy, and re-run.");
+  process.exit(1);
+} else {
+  writeFileSync("pages.json", draft);
+  console.log("\n✅ PASS — pages.json written.");
+  process.exit(0);
+}