@jahia/agentic 0.4.1 → 0.5.1

package/dist/antigravity/.agents/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/antigravity/.agents/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/{claude/.claude/skills/jahia-dev-review → antigravity/.agents/skills/jahia-review-code}/SKILL.md

@@ -1,10 +1,10 @@
 ---
-name: jahia-dev-review
+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-dev-review
+# 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.
 
@@ -215,7 +215,7 @@ If no issues found in a category, print `✅ None`.
 
 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-dev-define-content-type`, `jahia-dev-create-view`) and run `yarn build && yarn jahia-deploy` to push changes.
+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.
 
 ---
 

package/dist/antigravity/.agents/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/antigravity/.agents/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);
+}

package/dist/antigravity/AGENTS.md

@@ -0,0 +1,62 @@
+# AGENTS.md
+<!-- Generated by APM CLI from distributed .apm/ primitives -->
+<!-- Build ID: 6604f2c9e98d -->
+<!-- APM Version: 0.21.0 -->
+
+## Global Instructions
+
+# Jahia JavaScript Module Development
+
+## Context
+
+You are helping develop a **Jahia JavaScript Module** — a React-based template set for Jahia 8+. The module renders content from Jahia's JCR (Java Content Repository) using server-side React components (`.server.tsx`) and optional client-side islands (`.client.tsx`). Content is modelled in CND files, managed via Page Builder or jContent, and queried with JCR-SQL2 or GraphQL.
+
+## Agent Principles
+
+1. **Always invoke a skill before any Jahia task** — skills are the canonical source of patterns, gotchas, and API syntax. Never operate from memory alone.
+1a. **Always load CND reference files before writing any CND** — Jahia-specific patterns (`choicelist[linkTypeInitializer]`, `mix:title`, child nodes for CTAs, `jmix:image` weakreferences) are not in your training data. Before writing any CND, read the reference files: `find . -maxdepth 4 -name 'cnd-jahia-mixins*' | head -3`. When working interactively through skill chains, prefer `@jahia-cnd-author` (it loads these files for you).
+2. **Never use `yarn dev` from an agent** — it is an interactive file watcher for human developers only. Always deploy with `yarn build && yarn jahia-deploy` (one-shot, non-interactive).
+2a. **Use the TypeScript LSP for API discovery, never grep.** When you need to know a function's signature or what a module exports, call `mcp__ide__getDiagnostics` on the file after writing it — the LSP reads live type definitions and reports mismatches, wrong argument counts, and missing exports. Never run `grep` on `node_modules` to find a function name or signature.
+3. **Never hardcode URLs** — all navigable links must come from contributed content (JCR nodes, `j:linkType`, `buildNodeUrl`). This is a CMS: content owns the URLs.
+4. **Never use `j:linkType: "external"` for internal pages** — use `"internal"` + `j:linknode`. External URLs break on environment changes, language switches, and vanity URL rewrites.
+5. **Always verify before creating** — check that content types are deployed, site keys are correct, and parent area nodes exist before creating content via MCP.
+6. **All props are optional at runtime** — even mandatory CND fields. Always guard against `undefined` in views.
+7. **Use MCP tools for all Jahia operations — never GraphQL curl.** The `jahia` MCP server covers site, page, content, and publication operations. Never fall back to `curl` + GraphQL mutations for anything the MCP server can do. Never write Python scripts — use JavaScript or bash only.
+7a. **`yarn` and `npx` must be run from the module root** — the module is a standalone project, not part of a monorepo. Running `yarn` from a parent directory fails with a workspace boundary error. Always `cd` to the module directory first.
+7b. **Use `grep`, not `ugrep`** — `ugrep` is not available on all systems and does not support the same regex syntax. Use `grep -rn` for plain text, `grep -rn -E` for extended regex, or `grep -rn -P` for Perl-compatible patterns (e.g. lookaheads). Never use `ugrep` or `(?m)` flags.
+8. **Build accessible HTML from the start** — every view must use semantic HTML (`<main>`, `<header>`, `<nav>`, `<footer>`, `<section>`, `<article>`), include exactly one `<h1>` per page (in the template from `jcr:title` — never inside a component), use a strict heading hierarchy (h1 in template → h2 in components → h3 for sub-items), add `alt` text to every `<img>` with a meaningful fallback (`imageAlt || title || 'Image'` — never empty string), ensure sufficient colour contrast (≥ 4.5:1 for body text), include a skip link at the top of the template, and never leave a landmark (`<nav>`, `<footer>`) empty.
+9. **Review quality after each deploy** — after deploying and populating content, write the live page URLs to `pages-to-review.json`, then invoke `/jahia-review` to run a full code and site review via subagents. Fix all reported violations and iterate until `/jahia-review-site` exits 0. The review script writes `pages.json` on pass — never write it manually.
+10. **Deploy iteratively** — deploy after each component with `yarn build && yarn jahia-deploy`, verify it renders, then move to the next. Don't accumulate components before deploying; a broken component is easier to diagnose in isolation.
+11. **Collocate everything per component** — each component lives in `src/components/<Category>/<Name>/` containing its `definition.cnd`, `default.server.tsx`, `component.module.css`, and `types.ts`. Never centralize content types in `settings/definitions.cnd` — that file holds only namespace declarations and the module base mixin.
+12. **Always build a page template first** — every website needs a root template at `src/templates/<ModuleName>Template/default.server.tsx`. It must include: a skip link, a `<nav>` built inline from children of the site's home node using `getChildNodes(renderContext.getSite().getNode('home'), -1, 0, n => n.isNodeType('jnt:page'))` (pages live under `home`, not directly under the site), a `<main id="main-content">` with `<h1>{title}</h1>` and Areas, and a `<footer>` that is never empty. The `<title>` tag must be `{title} | {siteName}` — never set `jcr:title` to the full `Page | Site` string; `jcr:title` is always just the short page name (e.g. "Car Insurance"). Build and deploy before any page-specific components.
+13. **SEO baseline** — every page template must render a `<title>` tag, all `<img>` must have descriptive `alt` text, all links must have visible text (no icon-only links without `aria-label`), and pages must have a single `<h1>` matching the page title.
+
+## Canonical References
+
+Always fetch these when uncertain about version-sensitive topics:
+
+| Topic | URL |
+|-------|-----|
+| Getting started / dev environment | https://academy.jahia.com/tutorials-get-started/front-end-developer/setting-up-your-dev-environment |
+| Hero section tutorial | https://academy.jahia.com/tutorials-get-started/front-end-developer/making-a-hero-section |
+| Blog / content listing | https://academy.jahia.com/tutorials-get-started/front-end-developer/making-a-blog |
+| Page templates | https://academy.jahia.com/tutorials-get-started/front-end-developer/the-about-us-page |
+| i18n (CND attribute, useTranslation, language switcher) | https://academy.jahia.com/documentation/jahia-cms/jahia-8-2/developer/javascript-module-development/preparing-for-internationalization-i18n |
+| GraphQL API | https://academy.jahia.com/documentation/developer/jahia/8/api-documentation/graphql-api |
+| Native Jahia mixins & node types | https://github.com/Jahia/jahia/tree/master/war/src/main/webapp/WEB-INF/etc/repository/nodetypes |
+| JavaScript modules monorepo | https://github.com/Jahia/javascript-modules |
+| Developer training | https://github.com/Jahia/developer-training/blob/main/js-training/slides.md |
+| Integration best practices | https://github.com/Jahia/gautier-braindump/blob/main/articles/integration-best-practices/README.md |
+
+## Local Development URLs
+
+When Jahia is running at `http://localhost:8080` (default credentials: `root` / `root1234`):
+
+- **Login**: http://localhost:8080/cms/login
+- **GraphQL playground**: http://localhost:8080/modules/graphql-dxm-provider/tools/graphql-workspace.jsp
+- **JCR browser**: http://localhost:8080/modules/tools/jcrBrowser.jsp
+- **Definitions browser**: http://localhost:8080/modules/tools/definitionsBrowser.jsp
+
+---
+*This file was generated by APM CLI. Do not edit manually.*
+*To regenerate: `apm compile`*

package/dist/claude/.claude/rules/jahia.md

@@ -18,7 +18,7 @@ You are helping develop a **Jahia JavaScript Module** — a React-based template
 7a. **`yarn` and `npx` must be run from the module root** — the module is a standalone project, not part of a monorepo. Running `yarn` from a parent directory fails with a workspace boundary error. Always `cd` to the module directory first.
 7b. **Use `grep`, not `ugrep`** — `ugrep` is not available on all systems and does not support the same regex syntax. Use `grep -rn` for plain text, `grep -rn -E` for extended regex, or `grep -rn -P` for Perl-compatible patterns (e.g. lookaheads). Never use `ugrep` or `(?m)` flags.
 8. **Build accessible HTML from the start** — every view must use semantic HTML (`<main>`, `<header>`, `<nav>`, `<footer>`, `<section>`, `<article>`), include exactly one `<h1>` per page (in the template from `jcr:title` — never inside a component), use a strict heading hierarchy (h1 in template → h2 in components → h3 for sub-items), add `alt` text to every `<img>` with a meaningful fallback (`imageAlt || title || 'Image'` — never empty string), ensure sufficient colour contrast (≥ 4.5:1 for body text), include a skip link at the top of the template, and never leave a landmark (`<nav>`, `<footer>`) empty.
-9. **Review quality after each deploy** — after deploying and populating content, run `/jahia-dev-site-review` to get a scored a11y + SEO report. Fix any critical/serious violations before moving on. Do not write `pages.json` until the review passes.
+9. **Review quality after each deploy** — after deploying and populating content, write the live page URLs to `pages-to-review.json`, then invoke `/jahia-review` to run a full code and site review via subagents. Fix all reported violations and iterate until `/jahia-review-site` exits 0. The review script writes `pages.json` on pass — never write it manually.
 10. **Deploy iteratively** — deploy after each component with `yarn build && yarn jahia-deploy`, verify it renders, then move to the next. Don't accumulate components before deploying; a broken component is easier to diagnose in isolation.
 11. **Collocate everything per component** — each component lives in `src/components/<Category>/<Name>/` containing its `definition.cnd`, `default.server.tsx`, `component.module.css`, and `types.ts`. Never centralize content types in `settings/definitions.cnd` — that file holds only namespace declarations and the module base mixin.
 12. **Always build a page template first** — every website needs a root template at `src/templates/<ModuleName>Template/default.server.tsx`. It must include: a skip link, a `<nav>` built inline from children of the site's home node using `getChildNodes(renderContext.getSite().getNode('home'), -1, 0, n => n.isNodeType('jnt:page'))` (pages live under `home`, not directly under the site), a `<main id="main-content">` with `<h1>{title}</h1>` and Areas, and a `<footer>` that is never empty. The `<title>` tag must be `{title} | {siteName}` — never set `jcr:title` to the full `Page | Site` string; `jcr:title` is always just the short page name (e.g. "Car Insurance"). Build and deploy before any page-specific components.

package/dist/claude/.claude/skills/jahia-dev-build-component/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: jahia-dev-build-component
-description: Builds a complete Jahia component (content type + view + CSS) from a description. Meta-skill that orchestrates jahia-dev-define-content-type and jahia-dev-create-view. Use when asked to build a new UI component or section.
+description: Builds a complete Jahia component (content type + view + CSS) from a description. Meta-skill that orchestrates jahia-cnd-author and jahia-dev-create-view. Use when asked to build a new UI component or section.
 ---
 
 ## Overview
 
 This meta-skill builds a complete **Single Directory Component (SDC)** — the standard Jahia component pattern — by sequencing two atomic skills:
 
-1. `jahia-dev-define-content-type` → create the CND definition and `types.ts`
+1. `jahia-cnd-author` → create the CND definition and `types.ts`
 2. `jahia-dev-create-view` → implement the React view and CSS Module
 
 Run these steps in order. Do not skip to the view before the content type is defined.

package/dist/claude/.claude/skills/jahia-dev-create-view/SKILL.md

@@ -144,7 +144,7 @@ Always import `Props` from `./types.js` (not `./types.ts` — use `.js` extensio
 import type { Props } from "./types.js";
 ```
 
-If `types.ts` doesn't exist yet, create it first (see `jahia-dev-define-content-type` skill).
+If `types.ts` doesn't exist yet, create it first (see `jahia-cnd-author` skill).
 
 ---
 
@@ -294,7 +294,7 @@ jahiaComponent(
 );
 ```
 
-The `Props` type must be a discriminated union (see `jahia-dev-define-content-type` skill).
+The `Props` type must be a discriminated union (see `jahia-cnd-author` skill).
 
 ### Cache properties — controlling fragment caching
 

package/dist/claude/.claude/skills/jahia-dev-import-from/SKILL.md

@@ -106,7 +106,7 @@ Report findings, then ask: **"Should I import any of these? (yes / no / specific
 
 ### Step 5a — CND and view
 
-Using the confirmed field split from Step 3, run the `jahia-dev-define-content-type` and `jahia-dev-create-view` patterns to create:
+Using the confirmed field split from Step 3, run the `jahia-cnd-author` and `jahia-dev-create-view` patterns to create:
 
 - `src/components/<Category>/<Name>/definition.cnd`
 - `src/components/<Category>/<Name>/types.ts`

package/dist/claude/.claude/skills/jahia-dev-properties/SKILL.md

@@ -143,5 +143,5 @@ See [references/all-properties.md](references/all-properties.md) for all ~90 pro
 
 Search tip:
 ```bash
-grep -i "keyword" ~/.claude/skills/jahia-properties/references/all-properties.md
+grep -i "keyword" $(find .claude .agents -name "all-properties.md" 2>/dev/null | head -1)
 ```

package/dist/claude/.claude/skills/jahia-dev-query-content/SKILL.md

@@ -200,5 +200,5 @@ Use `ISDESCENDANTNODE` to cover nested folder trees automatically. Switch to `IS
 
 - `/jahia-jcr-sql2` — SQL2 syntax, full-text, joins, pagination, and performance
 - `/jahia-dev-build-component` — build the listing component that renders query results
-- `/jahia-dev-define-content-type` — create the queried content type and folder types
+- `/jahia-cnd-author` — create the queried content type and folder types
 

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

@@ -253,6 +253,5 @@ If a user can choose the sort field, validate it against a whitelist before inte
 ## Related skills
 
 - `/jahia-dev-query-content` — apply SQL2 inside Page Builder queries and JS module views
-- `/jahia-dev-define-content-type` — define the content types you will query
-- `/jahia-java-jcr` — implement back-end JCR logic around the query
+- `/jahia-cnd-author` — define the content types you will query