@jahia/agentic 0.2.0 → 0.4.0

package/dist/windsurf/.windsurf/skills/jahia-dev-review-cnd/scripts/check-cnd.mjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+function findCndFiles(dir) {
+  const results = [];
+  function walk(current) {
+    try {
+      const stat = statSync(current);
+      if (stat.isFile()) {
+        if (current.endsWith(".cnd")) results.push(current);
+        return;
+      }
+      for (const entry of readdirSync(current, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
+          walk(join(current, entry.name));
+        } else if (entry.isFile() && entry.name.endsWith(".cnd")) {
+          results.push(join(current, entry.name));
+        }
+      }
+    } catch {
+      // skip unreadable paths
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+function checkFile(filePath, content) {
+  const issues = [];
+  const lines = content.split("\n");
+
+  lines.forEach((line, i) => {
+    const lineNum = i + 1;
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//") || trimmed.startsWith("<")) return;
+
+    // rawStringLink
+    if (
+      /^-\s+\w*(Url|Href|Link)\s+\(string[,)]/i.test(trimmed) &&
+      !/choicelist\[linkTypeInitializer\]/.test(trimmed)
+    ) {
+      const propName = trimmed.match(/^-\s+(\w+)/)?.[1] ?? "unknown";
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "rawStringLink",
+        message: `"${propName}" uses (string) for a link/url — use choicelist[linkTypeInitializer]`,
+        fix: "Replace with: - j:linkType (string, choicelist[linkTypeInitializer]) mandatory",
+      });
+    }
+
+    // rawTitleProp
+    if (/^-\s+(title|heroTitle|pageTitle|sectionTitle)\s+\(string[,)]/i.test(trimmed)) {
+      const propName = trimmed.match(/^-\s+(\w+)/)?.[1] ?? "unknown";
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "rawTitleProp",
+        message: `"${propName}" is a plain string — extend mix:title instead`,
+        fix: "Add mix:title to the type declaration and remove this property",
+      });
+    }
+
+    // weakrefNoConstraint: (weakreference) with no < constraint on same line
+    if (/\(weakreference[,)]/.test(trimmed) && !/<\s*\S/.test(trimmed)) {
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "weakrefNoConstraint",
+        message: "Unconstrained weakreference — add a type constraint",
+        fix: "Add e.g. (weakreference, picker[type='image']) < jmix:image",
+      });
+    }
+
+    // weakrefWrongConstraint
+    if (/< ['"]jnt:file['"]/.test(trimmed)) {
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "weakrefWrongConstraint",
+        message: "< 'jnt:file' (quoted) does not enforce image type",
+        fix: "Replace with < jmix:image for images",
+      });
+    }
+
+    // missingI18n: user-visible string without i18n
+    if (
+      /^-\s+\w+\s+\(string(,\s*(textarea|richtext))?[,)]/.test(trimmed) &&
+      !/ i18n/.test(trimmed) &&
+      !/^-\s+j:/.test(trimmed) &&
+      /(title|text|label|description|subtitle|caption|alt|heading|summary|excerpt|body)/i.test(trimmed)
+    ) {
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "missingI18n",
+        message: "User-visible string property missing i18n",
+        fix: "Add i18n keyword after the type declaration",
+      });
+    }
+
+    // directDroppable: concrete type (not mixin) extending jmix:droppableContent
+    if (trimmed.startsWith("[") && /jmix:droppableContent/.test(trimmed) && !/\bmixin\b/.test(trimmed)) {
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "directDroppable",
+        message: "Extends jmix:droppableContent directly — always extend the module component mixin",
+        fix: "Replace jmix:droppableContent with nsmix:component (or your module's equivalent)",
+      });
+    }
+
+    // studioOnly
+    if (/jmix:studioOnly/.test(trimmed)) {
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "studioOnly",
+        message: "jmix:studioOnly causes silent rendering issues",
+        fix: "Replace with jmix:hiddenType",
+      });
+    }
+
+    // redundantImageAlt: imageAlt as plain string — image node already has jcr:title
+    if (/^-\s+imageAlt\s+\(string[,)]/i.test(trimmed)) {
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "redundantImageAlt",
+        message: '"imageAlt" is redundant — the image node\'s jcr:title (mix:title) serves as alt text',
+        fix: 'Remove imageAlt. In the view, use image.getPropertyAsString("jcr:title") for alt text',
+      });
+    }
+
+    // missingRatingConstraint: rating (long) without a range constraint
+    if (/^-\s+rating\s+\(long[,)]/i.test(trimmed) && !/<\s*"?\[/.test(trimmed)) {
+      issues.push({
+        file: filePath, line: lineNum,
+        pattern: "missingRatingConstraint",
+        message: '"rating" (long) has no range constraint — unconstrained ratings cause data integrity issues',
+        fix: 'Add: < "[1,5]"',
+      });
+    }
+  });
+
+  // singleHardcodedCta: check whole-file type blocks
+  const typeBlocks = content.split(/(?=^\[)/m);
+  for (const block of typeBlocks) {
+    if (!block.trim().startsWith("[")) continue;
+    const hasCtaLabel = /^\s*-\s+cta(Text|Label|ButtonText|ButtonLabel)\s+\(/im.test(block);
+    const hasCtaLink = /^\s*-\s+cta(Link|Url|Href|ButtonLink|ButtonUrl)\s+\(/im.test(block);
+    const hasChildNodes = /^\s*\+\s+/.test(block);
+    if (hasCtaLabel && hasCtaLink && !hasChildNodes) {
+      const typeName = block.match(/^\[(\S+)\]/m)?.[1] ?? "unknown";
+      const typeLineIdx = lines.findIndex((l) => l.includes(`[${typeName}]`));
+      issues.push({
+        file: filePath,
+        ...(typeLineIdx >= 0 ? { line: typeLineIdx + 1 } : {}),
+        pattern: "singleHardcodedCta",
+        message: `${typeName}: flat ctaText+ctaLink forces a single CTA — model as child nodes`,
+        fix: "Remove ctaText and ctaLink. Add: + * (ns:cta). Create a [ns:cta] type with label + j:linkType",
+      });
+    }
+  }
+
+  return issues;
+}
+
+export function checkCndFiles(projectDir) {
+  const files = findCndFiles(projectDir);
+  const allIssues = [];
+
+  for (const file of files) {
+    try {
+      const content = readFileSync(file, "utf-8");
+      allIssues.push(...checkFile(file, content));
+    } catch {
+      // skip unreadable files
+    }
+  }
+
+  return { score: Math.exp(-allIssues.length * 0.5), issues: allIssues, filesChecked: files.length };
+}
+
+if (import.meta.main) {
+  const targetPath = resolve(process.argv[2] ?? ".");
+  const { score, issues, filesChecked } = checkCndFiles(targetPath);
+
+  console.log(`\nCND Review: ${filesChecked} file${filesChecked !== 1 ? "s" : ""} checked\n`);
+
+  if (issues.length > 0) {
+    console.log(`ISSUES (${issues.length}):`);
+    for (const issue of issues) {
+      const loc = issue.line ? `${issue.file}:${issue.line}` : issue.file;
+      console.log(`  [${issue.pattern}] ${loc}`);
+      console.log(`    ${issue.message}`);
+      console.log(`    Fix: ${issue.fix}`);
+    }
+    console.log();
+  }
+
+  const verdict = issues.length > 0 ? "FAIL" : "PASS";
+  console.log(`Result: ${verdict} (score=${score.toFixed(2)})`);
+  process.exit(issues.length > 0 ? 1 : 0);
+}

package/dist/windsurf/.windsurf/skills/jahia-dev-site-review/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: jahia-dev-site-review
+description: Scores live pages for accessibility (WCAG 2.1 AA via axe-core) and SEO (title, meta description, h1, alt). Use after deploying to get a pass/fail signal with per-violation detail before completing development.
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# Skill: jahia-dev-site-review
+
+Runs automated a11y and SEO checks against every URL in `pages.json`. Reports a numeric score per page, lists violations by severity, and exits non-zero on any critical/serious a11y violation or missing SEO baseline.
+
+**A11y scoring:** `Math.exp(-Σ impact_weights)` where `critical=1, serious=0.5, moderate=0.25, minor=0.1`. Score of 1.0 = perfect; 0.607 = one serious violation.
+
+---
+
+## 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:
+- A `🔴 [critical]` or `🔴 [serious]` a11y violation
+- A `🔍 SEO` issue (missing title, meta description, h1, or img alt)
+
+`🟡 [moderate]` and `🟡 [minor]` violations are reported but do not fail the run — fix them for a higher score.
+
+**Common violations and where to fix them:**
+
+| Violation | Fix location |
+|---|---|
+| `landmark-*` empty nav or footer | Page template — ensure `<nav>` has inline content, `<footer>` has fallback text |
+| `page-has-heading-one` | Page template — add `<h1>{title}</h1>` |
+| `image-alt` | Component `.server.tsx` — use `imageAlt \|\| title \|\| 'Image'` |
+| `color-contrast` | Component `.module.css` — check foreground/background ratio ≥ 4.5:1 |
+| `heading-order` | Component — components start at `<h2>`, sub-items at `<h3>` |
+| Missing `<title>` | Page template `<head>` |
+| Missing meta description | Page template `<head>` — add `<meta name="description" content={…} />` |
+| Multiple `<h1>` | Remove `<h1>` from components; only the template renders one |
+
+After fixing, redeploy and re-run:
+
+```bash
+yarn build && yarn jahia-deploy
+node "$SCRIPT"
+```
+
+Iterate until the script exits 0.
+
+---
+
+## Validation checklist
+- [ ] Script exits 0 (no critical/serious violations, no SEO issues)
+- [ ] Average a11y score ≥ 0.8
+- [ ] Every page has a unique, non-empty `<title>`
+- [ ] Every page has `<meta name="description">`
+- [ ] Every page has exactly one `<h1>`

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

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// Runs a11y (axe-core) + SEO checks on every URL in pages.json.
+// Exits 1 if any page has critical/serious a11y violations or missing SEO basics.
+import { chromium } from "playwright";
+import { AxeBuilder } from "@axe-core/playwright";
+import { readFileSync } from "fs";
+
+const IMPACTS = { minor: 0.1, moderate: 0.25, serious: 0.5, critical: 1 };
+
+const urls = JSON.parse(readFileSync("pages.json", "utf-8"));
+const browser = await chromium.launch({ args: ["--no-sandbox"] });
+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 })
+    .withTags(["wcag2a", "wcag2aa", "wcag21aa"])
+    .analyze();
+
+  const a11yScore = Math.exp(
+    -axe.violations.reduce((t, v) => t + (IMPACTS[v.impact] ?? 0), 0),
+  );
+
+  // SEO
+  const title = await page.title();
+  const metaDesc = await page
+    .$eval('meta[name="description"]', el => el.getAttribute("content"))
+    .catch(() => null);
+  const h1s = await page.$$eval("h1", els => els.map(e => e.textContent?.trim()));
+  const imgsMissingAlt = await page.$$eval(
+    "img",
+    els => els.filter(e => !e.getAttribute("alt")).map(e => e.outerHTML.slice(0, 80)),
+  );
+
+  const seoIssues = [];
+  if (!title) seoIssues.push("missing <title>");
+  if (!metaDesc) seoIssues.push("missing <meta name=description>");
+  if (h1s.length === 0) seoIssues.push("no <h1>");
+  if (h1s.length > 1) seoIssues.push(`${h1s.length} <h1> elements (must be exactly 1)`);
+  if (imgsMissingAlt.length > 0)
+    seoIssues.push(`${imgsMissingAlt.length} <img> missing alt attribute`);
+
+  process.stdout.write(`a11y=${a11yScore.toFixed(3)}\n`);
+  results.push({ url, a11yScore, violations: axe.violations, seoIssues });
+}
+
+await browser.close();
+
+// ── Report ──────────────────────────────────────────────────────────────────
+let failed = false;
+
+for (const r of results) {
+  const critical = r.violations.filter(v => v.impact === "critical" || v.impact === "serious");
+  const pageOk = critical.length === 0 && r.seoIssues.length === 0;
+  if (!pageOk) failed = true;
+
+  console.log(`\n${"─".repeat(70)}`);
+  console.log(`${pageOk ? "✅" : "❌"} ${r.url}`);
+  console.log(`   A11y score : ${r.a11yScore.toFixed(3)}  (1.0 = perfect)`);
+
+  for (const v of r.violations) {
+    const marker = v.impact === "critical" || v.impact === "serious" ? "🔴" : "🟡";
+    console.log(`   ${marker} [${v.impact}] ${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 issue of r.seoIssues) {
+    console.log(`   🔍 SEO: ${issue}`);
+  }
+}
+
+console.log(`\n${"═".repeat(70)}`);
+const avg = results.reduce((t, r) => t + r.a11yScore, 0) / results.length;
+console.log(`Average a11y score: ${avg.toFixed(3)}`);
+console.log(failed ? "\n❌ FAIL — fix the issues above, redeploy, and re-run." : "\n✅ PASS");
+
+process.exit(failed ? 1 : 0);

package/dist/windsurf/.windsurf/skills/jahia-dev-start-local/SKILL.md

@@ -79,36 +79,28 @@ Follow the instructions on that page for the user's platform, then return here t
 
 ## Step 4 — Create a new site in Jahia
 
-Once the module is deployed to Jahia, create the site via the Provisioning API — **do not use the UI**.
+Once the module is deployed to Jahia, create the site via MCP:
 
-> ⚠️ **CRITICAL: syntax is `- createSite: ""`** — the empty string `""` after the colon is **mandatory**. Without it, Jahia returns HTTP 200 but silently creates nothing. Using `- createSite:` with nested properties is **wrong and will fail silently**.
-
-```bash
-MODULE_NAME=<module-name>   # value of "name" in package.json
-
-cat > /tmp/create-site.yaml <<EOF
-- createSite: ""
-  siteKey: ${MODULE_NAME}
-  title: "My Site"
-  defaultLanguage: en
-  serverName: localhost
-  templateSet: ${MODULE_NAME}
-EOF
-
-curl -u root:root1234 -X POST -H "Content-Type: application/yaml" \
-  --data-binary @/tmp/create-site.yaml \
-  http://localhost:8080/modules/api/provisioning
 ```
+tool: site.create
+args: {
+  "siteKey": "<module-name>",
+  "title": "My Site",
+  "templateSet": "<module-name>",
+  "defaultLanguage": "en",
+  "serverName": "localhost"
+}
+```
+
+Replace `<module-name>` with the `name` from `package.json`. `templateSet` must exactly match the deployed module name.
 
 Verify the site exists:
-```bash
-curl -s -u root:root1234 \
-  -H "Content-Type: application/json" -H "Origin: http://localhost:8080" \
-  -X POST http://localhost:8080/modules/graphql \
-  -d "{\"query\":\"{ jcr { nodeByPath(path:\\\"/sites/${MODULE_NAME}\\\") { name } } }\"}"
+
+```
+tool: site.list
 ```
 
-The response must contain `"name": "<module-name>"`. If it returns `null`, the site was not created — check that `templateSet` exactly matches the deployed module name.
+The site key must appear in the response. If it does not, check that `templateSet` exactly matches the deployed module name.
 
 Then open **Page Builder** at http://localhost:8080/jahia/page-builder to start building.
 
@@ -119,8 +111,8 @@ Then open **Page Builder** at http://localhost:8080/jahia/page-builder to start
 - [ ] `docker compose up --wait` completes without errors (Docker path)
 - [ ] Jahia UI is reachable at http://localhost:8080
 - [ ] Module deployed to Jahia (`yarn build && yarn jahia-deploy` run; or `yarn dev` in user terminal for interactive development)
-- [ ] Site created via Provisioning API (`createSite: ""` with correct templateSet)
-- [ ] GraphQL confirms `/sites/<site-key>` node exists
+- [ ] Site created via `site.create` MCP tool with correct `templateSet`
+- [ ] `site.list` confirms site key exists
 
 ## Troubleshooting
 

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

@@ -0,0 +1,258 @@
+---
+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-dev-define-content-type` — define the content types you will query
+- `/jahia-java-jcr` — implement back-end JCR logic around the query
+