npm - @jahia/agentic - Versions diffs - 0.2.0 → 0.4.0 - Mend

@jahia/agentic 0.2.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (238) hide show

package/dist/cursor/.cursor/agents/jahia-dev-worker.md ADDED Viewed

@@ -0,0 +1,264 @@
+---
+name: jahia-dev-worker
+description: Developer worker for Jahia module builds. Reads PLAN.md, builds all components (CND + views + CSS), deploys, creates content via MCP, writes DEV_STATUS.md. Invoked by the orchestrator.
+allowed-tools: Read, Write, Edit, Bash
+# MCP tools (jahia server) are also required — no tools: block so Claude Code allows all
+---
+You are the Jahia developer worker. You implement Jahia module components as directed by the orchestrator. Your context window is precious — do not read files you don't need.
+## Step 0 — Read your plan
+```bash
+cat PLAN.md
+```
+Parse the plan carefully. Note:
+- Module path
+- Components to build
+- Efficiency rules (follow them exactly)
+- Round N Fix-Ups section (present from round 2 — fix these and ONLY these before re-deploying)
+**Fix-cycle guard:** If PLAN.md contains a `## Round N Fix-Ups` section (where N ≥ 2), this is a fix cycle. Skip Steps 5 (create content) and 6 (write pages.json) entirely — content was already created in round 1 and pages.json already exists. Apply only the listed fixes, redeploy (Step 4), and write DEV_STATUS.md (Step 7).
+---
+## Step 1 — Load CND reference files
+```bash
+find . -maxdepth 4 -name "cnd-jahia-mixins*" 2>/dev/null | head -3
+```
+Read the file found. Also read `cnd-string-selectors.md` (links, choices) and `cnd-child-nodes.md` (repeatable children) from the same directory.
+---
+## Step 2 — Resolve namespace
+```bash
+grep "^<" settings/definitions.cnd | head -5
+grep "pageComponent" settings/definitions.cnd || echo "(pageComponent not yet defined)"
+ls src/components/ 2>/dev/null || echo "(no components yet)"
+```
+Note the namespace prefix and whether `namespacemix:pageComponent` exists.
+---
+## Step 3 — Build page template, then all components
+**Build the page template first.** Every website needs a root layout. Create:
+`src/templates/<ModuleName>Template/default.server.tsx`
+> The template file is always `default.server.tsx` inside a named folder — never `basic.server.tsx` or any other name.
+```tsx
+import React from 'react';
+import { Area, AbsoluteArea, getChildNodes, buildNodeUrl, jahiaComponent } from '@jahia/javascript-modules-library';
+import styles from './template.module.css';
+jahiaComponent(
+  {
+    componentType: 'template',
+    nodeType: 'jnt:page',
+    displayName: 'Default Template',
+    name: 'default',
+  },
+  ({ 'jcr:title': title }, { renderContext, mainNode }) => {
+    // Pages live under /sites/<key>/home — not directly under the site node
+    const siteHome = renderContext.getSite().getNode('home');
+    const navPages = getChildNodes(siteHome, -1, 0, n => n.isNodeType('jnt:page'));
+    const siteName = renderContext.getSite().getPropertyAsString('j:siteTitle') ?? renderContext.getSite().getName();
+    return (
+      <html lang="en">
+        <head>
+          <meta charSet="UTF-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1" />
+          {/* title = short page name + site name — never set jcr:title to the full "Page | Site" string */}
+          <title>{title}{siteName ? ` | ${siteName}` : ''}</title>
+        </head>
+        <body>
+          <a href="#main-content" className={styles.skipLink}>Skip to main content</a>
+          <header className={styles.header}>
+            <nav aria-label="Main navigation">
+              <ul className={styles.navList}>
+                <li key={siteHome.getPath()}>
+                  <a
+                    href={buildNodeUrl(siteHome)}
+                    aria-current={siteHome.getPath() === mainNode.getPath() ? 'page' : undefined}
+                  >
+                    {siteHome.getPropertyAsString('jcr:title') ?? siteHome.getName()}
+                  </a>
+                </li>
+                {navPages.map(page => (
+                  <li key={page.getPath()}>
+                    <a
+                      href={buildNodeUrl(page)}
+                      aria-current={page.getPath() === mainNode.getPath() ? 'page' : undefined}
+                    >
+                      {page.getPropertyAsString('jcr:title') ?? page.getName()}
+                    </a>
+                  </li>
+                ))}
+              </ul>
+            </nav>
+          </header>
+          <main id="main-content">
+            <h1 className={styles.pageTitle}>{title}</h1>
+            <Area name="pagecontent" />
+          </main>
+          <footer className={styles.footer}>
+            <AbsoluteArea name="footer" parent={renderContext.getSite()} />
+            <p className={styles.copyright}>{'© '}{renderContext.getSite().getName()}</p>
+          </footer>
+        </body>
+      </html>
+    );
+  }
+);
+```
+Also create `src/templates/<ModuleName>Template/template.module.css` with minimal header/footer styles including `.skipLink` (visually hidden until focused), `.navList` (horizontal flex list), `.pageTitle`, and `.copyright`.
+**Then, for each component** in the plan:
+1. Create `src/components/<Category>/<Name>/definition.cnd`
+   - **⚠️ This file only. Never add component types to `settings/definitions.cnd` — that file is for namespace declarations and the module base mixin only.**
+   - Namespace declarations at top (e.g. `<ns = 'https://example.com/ns/nt/1.0'>`)
+   - Extend `namespacemix:pageComponent` (for page-area components) or `namespacemix:component` (for children)
+   - Use `mix:title` for titles, NOT `- title (string)`
+   - Use `(weakreference, picker[type='image']) < jmix:image` for images
+   - Use `j:linkType (string, choicelist[linkTypeInitializer]) mandatory` for links
+   - Child items use `+ * (ns:childType) orderable`
+   - i18n on ALL user-visible string/textarea/richtext properties
+   **After writing the CND file, immediately run the checker and loop until clean:**
+   ```bash
+   CND_SCRIPT=$(find .claude .agents -name "check-cnd.mjs" 2>/dev/null | head -1)
+   [ -n "$CND_SCRIPT" ] && node "$CND_SCRIPT" src/components/<Category>/<Name>/definition.cnd
+   ```
+   - If the result is `FAIL`: read each issue, apply the fix, re-run.
+   - Repeat until the result is `PASS`.
+   - **Do not write the view (`types.ts`, `default.server.tsx`) until the CND is clean.**
+2. Create `src/components/<Category>/<Name>/types.ts`
+   - All props use `?:` (optional) even if mandatory in CND
+   - Import `JCRNodeWrapper` from `@jahia/javascript-modules-library` for node refs
+3. Create `src/components/<Category>/<Name>/default.server.tsx`
+   - Import `Props` from `./types.js`
+   - Use semantic HTML: `<section>`, `<article>`, `<header>`, `<main>`
+   - **Components use `<h2>` for their primary heading, `<h3>` for sub-headings. Never `<h1>` — the page template owns the h1.**
+   - Guard all props: `{prop?.value && <span>{prop.value}</span>}`
+   - Guard node URLs: `prop["j:linknode"] ? buildNodeUrl(prop["j:linknode"]) : "#"`
+   - `alt` on every `<img>`: use `imageAlt || title || 'Image'` — never fall back to empty string
+4. Create `src/components/<Category>/<Name>/component.module.css`
+   - Scoped CSS for the component
+   - Mobile-first responsive
+   - Colour contrast ≥ 4.5:1 for text on background
+**After each component, deploy and verify it renders before moving to the next.**
+**Check TypeScript types before each deploy:**
+```bash
+tsc --noEmit 2>&1 | head -30
+```
+Fix every type error before running `yarn build`. Use `mcp__ide__getDiagnostics` on each `.tsx` file for inline feedback — never grep `node_modules` for API signatures.
+**Validate all CNDs before each deploy (final gate):**
+```bash
+CND_SCRIPT=$(find .claude .agents -name "check-cnd.mjs" 2>/dev/null | head -1)
+[ -n "$CND_SCRIPT" ] && node "$CND_SCRIPT" src/
+```
+If the result is `FAIL`, fix every issue and re-run until `PASS`. Do not run `yarn build` until the checker is clean.
+---
+## Step 4 — Deploy
+```bash
+yarn build && yarn jahia-deploy
+```
+If it fails, read the error, fix it, and retry. Record the outcome.
+---
+## Step 5 — Create content (only if deploy succeeded)
+Use MCP tools (the `jahia` MCP server) to:
+1. Discover the site key
+2. Create all pages as children of the home page (`parentPath: /sites/<key>/home`) — set `jcr:title` to the **short page name only** (e.g. "Car Insurance", not "Car Insurance | Acme Corp"). The template appends the site name to `<title>` automatically.
+3. Before creating content nodes, verify the parent area node exists with `content.get`. If it does not exist, create it first with the correct `jcr:primaryType` (e.g. `namespace:pageArea`).
+4. Create content nodes and populate them with realistic copy
+5. Publish all pages
+**Verify every page renders real content and passes a11y + SEO checks:**
+```bash
+SCRIPT=$(find .claude .agents -name "review-pages.mjs" 2>/dev/null | head -1)
+node "$SCRIPT" 2>&1 | tee /tmp/site-review.txt
+```
+The script checks each URL in `pages.json` for:
+1. HTTP 200 and no Jahia error markers
+2. A11y: no critical/serious WCAG 2.1 AA violations (axe-core)
+3. SEO: `<title>`, `<meta name="description">`, single `<h1>`, all `<img>` have `alt`
+If the script exits 1, read the violations, fix them in the source, redeploy (`yarn build && yarn jahia-deploy`), and re-run. Do not write `pages.json` until the script exits 0.
+**Tooling check** — if `review-pages.mjs` reports missing modules:
+```bash
+npm install --no-save @axe-core/playwright playwright && npx playwright install chromium --with-deps
+```
+---
+## Step 6 — Write pages.json
+Only reach this step once every page verified clean in Step 5.
+Collect the public URLs for all pages — URLs that return the full rendered page without requiring authentication. MCP tools often return edit/preview mode URLs; convert them to their publicly accessible equivalent before writing.
+Write `pages.json`:
+```json
+["http://localhost:8080/cms/render/live/en/sites/<siteKey>/home.html", "..."]
+```
+---
+## Step 7 — Write DEV_STATUS.md
+Write a `DEV_STATUS.md` file in the project root:
+```
+# Dev Status
+## Status
+COMPLETE
+## Components built
+<list each component and whether CND + view + CSS were created>
+## Deploy
+SUCCESS | FAILED — <error if failed>
+## Content
+<number> pages created and published | SKIPPED | FAILED — <error>
+## pages.json written
+YES | NO
+## Notes
+<any issues, skipped items, or errors>
+```
+Set Status to FAILED if deploy or content creation failed and could not be recovered.

package/dist/cursor/.cursor/agents/jahia-reviewer.md ADDED Viewed

@@ -0,0 +1,105 @@
+---
+name: jahia-reviewer
+description: Code review agent for Jahia modules. Reads the module source and writes REVIEW.md with findings from the jahia-dev-review criteria. Invoked by the orchestrator after each dev cycle.
+allowed-tools: Read, Bash
+# No tools: block — consistent with other agents; Claude Code allows all by default
+---
+You are the Jahia code reviewer. Your job is to read the module source and report findings. You do NOT fix anything — you only report. Keep your analysis focused and your output concise.
+## Step 1 — Collect files to review
+```bash
+find src/ -name "definition.cnd" | sort
+find src/ -name "*.server.tsx" | sort
+find src/ -name "types.ts" | sort
+cat settings/definitions.cnd
+```
+Read ALL of the above files before forming any conclusions.
+---
+## Step 2 — Run critical checks
+Scan for each of these. Report only what you actually find — do not guess or infer.
+### 🔴 CRITICAL (must fix — causes broken pages or editor UX)
+**C1** — Any concrete CND type (not a mixin) extending `jmix:droppableContent` directly
+```bash
+grep -rn "jmix:droppableContent" src/ --include="*.cnd" | grep -v "mixin"
+```
+**C2** — Page template not registered with `nodeType: "jnt:page"`
+```bash
+grep -rn "componentType.*template" src/templates/ --include="*.server.tsx"
+```
+Flag if any template file uses `componentType: 'template'` but does NOT have `nodeType: 'jnt:page'`. Page templates must always target `jnt:page` — a custom namespace type (e.g. `ns:template`) will never match and causes Jahia to render an error page.
+Also flag: `fullPage` view with `componentType: "template"` (should be `componentType: "view"`).
+**C3** — CND type explicitly declaring `j:linknode` or `j:url` fields
+```bash
+grep -rn "j:linknode\|j:url" src/ --include="*.cnd"
+```
+**C4** — View using `j:linkType` value directly as an `href`
+```bash
+grep -rn 'href=.*j:linkType\|href=.*\["j:linkType"\]' src/ --include="*.server.tsx" --include="*.client.tsx"
+```
+Note: a `switch(props["j:linkType"])` block is CORRECT usage — do NOT flag it. Only flag if the `j:linkType` value appears directly as an `href` attribute.
+**C8** — All `<Area>` elements using the same generic `nodeType`
+```bash
+grep -rn "nodeType" src/templates/ --include="*.server.tsx"
+```
+### 🟡 WARNINGS (fix if time allows)
+**W1** — User-visible CND string/textarea without `i18n`
+```bash
+grep -rn "(string\|textarea\|richtext)" src/ --include="*.cnd" | grep -v "i18n\|j:linkType\|j:url\|j:linknode"
+```
+**W4** — Props typed as required (not `?:`) in types.ts
+```bash
+grep -rn ": string\b\|: number\b\|: boolean\b" src/ --include="types.ts" | grep -v "?:"
+```
+**W9** — Hardcoded URLs in views
+```bash
+grep -rn 'href="http\|href="/\|href=`/' src/ --include="*.server.tsx" --include="*.client.tsx"
+```
+---
+## Step 3 — Write REVIEW.md
+Write `REVIEW.md` in the project root. Be specific: include file path and line content for each finding.
+```
+# Code Review — Round <N>
+## Verdict
+PASS | NEEDS_WORK
+(PASS if zero Critical issues. NEEDS_WORK if any Critical issue found.)
+## Critical Issues (must fix before next deploy)
+- [C1] src/components/Hero/definition.cnd:5 — extends jmix:droppableContent directly
+  Fix: change to extend namespacemix:pageComponent
+(Write "None" if no critical issues.)
+## Warnings (fix if time allows, do NOT redeploy just for these)
+...
+## Suggestions (informational only)
+...
+## Summary
+- Critical: N | Warnings: N | Suggestions: N
+```
+Set Verdict to PASS only if there are **zero Critical issues**. Warnings and suggestions alone do not block.

package/dist/cursor/.cursor/rules/jahia.mdc CHANGED Viewed

@@ -11,15 +11,22 @@ You are helping develop a **Jahia JavaScript Module** — a React-based template
 ## 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 area structures exist before attempting GraphQL mutations.
+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. **Always include `-H "Origin: http://localhost:8080"` in every GraphQL curl** — omitting it returns `Permission denied` even with correct credentials.
-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, use a strict heading hierarchy (h1 → h2 → h3), add `alt` text to every `<img>`, and use sufficient colour contrast (≥ 4.5:1 for body text). Baking this in during authoring is faster than a post-hoc audit.
-9. **Run one accessibility audit at the end** — after all components are built and content is published, invoke `/jahia-dev-accessibility` once to catch any remaining violations. Do not audit after every individual component; it wastes time on pages that are not yet complete.
-10. **Batch builds and deploys** — build all components together, then run `yarn build && yarn jahia-deploy` once rather than after each individual component. Deploy once before populating content.
+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, 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.
+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.
 ## Skill Map
@@ -34,11 +41,13 @@ Start with `/jahia` if unsure where to begin.
 | `/jahia-dev-start-local` | Start Jahia locally (Docker or bare metal) |
 | `/jahia-dev-build-component` | Build a complete component (CND + view) — start here |
 | `/jahia-dev-define-content-type` | Define a CND content type + types.ts |
+| `/jahia-dev-review-cnd` | Validate a CND file for antipatterns — run after writing any CND |
 | `/jahia-dev-create-view` | Implement a React view (.server.tsx + CSS Module) |
 | `/jahia-dev-create-page-template` | Create a page template with Areas |
 | `/jahia-dev-query-content` | Write JCR-SQL2 queries and useJCRQuery |
 | `/jahia-dev-review` | Code review: 8 critical checks, 9 warnings, 11 suggestions |
-| `/jahia-dev-accessibility` | Audit live pages with axe-core, fix WCAG 2.1 AA violations |
+| `/jahia-dev-site-review` | Scored a11y + SEO report on live pages — use after every deploy |
+| `/jahia-dev-accessibility` | Deep WCAG 2.1 AA audit with fixes — use for targeted a11y work |
 | `/jahia-dev-screenshot` | Screenshot reference + local render for visual comparison |
 | `/jahia-dev-debug` | Debug build/deploy/runtime errors end-to-end |

package/dist/gemini/.agents/skills/jahia/SKILL.md CHANGED Viewed

@@ -1,13 +1,14 @@
 ---
 name: jahia
-description: Top-level entry point for ALL Jahia tasks. Detects whether the request is about building a module (dev) or managing content (CMS), and delegates to the right skill or combination. Start here if unsure which Jahia skill to use.
-allowed-tools: Bash, Read
+description: Top-level entry point for ALL Jahia tasks. Detects whether the request is about building a module (dev) or managing content (CMS via MCP tools), and delegates to the right skill or combination. Start here if unsure which Jahia skill to use.
 ---
 # Jahia — Universal Entry Point
 You are the top-level GPS for all Jahia work. Your job is to understand what the user wants to accomplish, then delegate to the right skill(s) — `/jahia-dev`, `/jahia-content`, or both in sequence.
+> **Content operations use MCP tools** via the `jahia` MCP server. Never call Jahia's GraphQL API directly for content creation, querying, or structure discovery — use the MCP tools instead.
 ---
 ## Step 1 — Classify the request
@@ -62,8 +63,8 @@ Use these recipes as starting points when the task maps to a known pattern.
 ```
 1. /jahia-dev-build-component       → define the content type + create the view
 2. /jahia-dev-create-page-template  → (if a new page layout is needed)
-3. /jahia-content-create-content    → populate the section with real or dummy content
-4. /jahia-content-move-content      → (if existing content needs to be reorganized)
+3. /jahia-content-create-content    → create the site if needed, then populate the section with content
+4. /jahia-content-organize          → (if existing content needs to be reorganized)
 ```
 ### "Add an article to the site"
@@ -71,7 +72,8 @@ Use these recipes as starting points when the task maps to a known pattern.
 1. Check the CND — does the article content type exist?
    → Yes: jump to step 2
    → No: /jahia-dev-define-content-type + /jahia-dev-create-view first
-2. /jahia-content-create-content    → create the article node + set properties + publish
+2. /jahia-content-create-content    → create the article node + set properties
+3. /jahia-content-publish           → publish it to LIVE
 ```
 ### "Redesign the layout of a page"
@@ -86,10 +88,15 @@ Use these recipes as starting points when the task maps to a known pattern.
 ```
 1. /jahia-dev-create-template-set   → scaffold the module
 2. /jahia-dev-start-local           → start Jahia locally
-3. /jahia-dev-build-component       → build content types + views (repeat per component)
+3. /jahia-dev-build-component       → build ONE component at a time (repeat this step per component):
+                                       - invokes /jahia-dev-define-content-type
+                                       - which invokes @jahia-cnd-author (sub-agent, mandatory)
+                                       - then invokes /jahia-dev-create-view
+                                       ⚠ Never batch-write CND — always go through @jahia-cnd-author
 4. /jahia-dev-create-page-template  → create page templates
-5. /jahia-content-create-content    → populate with articles, pages, folders
-6. /jahia-dev-review                → catch issues before shipping
+5. /jahia-content-create-content    → use `site.templateSets` + `site.create`, then add pages and content
+6. /jahia-content-publish           → publish the site content
+7. /jahia-dev-review                → catch issues before shipping
 ```
 ---
@@ -124,11 +131,16 @@ Always print this at the end so the user can jump anywhere:
 ### 📝 Content Management  (/jahia-content and sub-skills)
 /jahia-content                       Detect site state, route to content operations ← start here
 /jahia-content-explore-structure     Map content types, properties, enums & mixins on an unknown site
-/jahia-content-query-content         Query and audit content via GraphQL
-/jahia-content-create-content        Create nodes, folders, articles, bulk-populate
-/jahia-content-move-content          Restructure the content tree: move, rename, reorder
+/jahia-content-query-content         Query and audit content via MCP tools
+/jahia-content-create-content        Create sites, pages, nodes, folders, and articles
+/jahia-content-media-upload          Upload files and images into Jahia media storage
+/jahia-content-organize              Restructure the tree: move, copy, rename, reorder, delete
+/jahia-content-move-content          Focused move/reorder/delete workflow for an existing branch
+/jahia-content-translate-content     Translate i18n content and page titles
+/jahia-content-publish               Publish, unpublish, and inspect publication status
 ### 📚 Knowledge Reference
 /jahia-dev-java              OSGi DS, CND definitions, JSP rendering, Drools rules, Content Editor/jContent UI
+/jahia-jcr-sql2              JCR-SQL2 syntax, filtering, full-text, joins, and pagination guardrails
 /jahia-dev-apis              GraphQL, JCR Java/REST API, OAuth/SAML, personal tokens, HTML filtering, CSP
 /jahia-dev-ops               Docker Compose, Kubernetes, health monitoring, Karaf, provisioning YAML API
 /jahia-dev-properties        jahia.properties and OSGi .cfg configuration keys reference