@jahia/agentic 0.0.0

package/dist/claude/.claude/skills/jahia-content-move-content/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: jahia-content-move-content
+description: Moves and reorganizes JCR content nodes in Jahia. Use when asked to restructure content folders, nest flat content into sections, rename or move nodes, or tidy up a content tree.
+---
+
+# Skill: jahia-content-move-content
+
+Reorganizes the JCR content tree — moving nodes into sub-folders, renaming them, and reordering them — using the Jahia GraphQL API.
+
+---
+
+## Prerequisites
+
+- Jahia running at `http://localhost:8080`
+- Credentials: `root` / `root1234` (default)
+- GraphQL endpoint: `http://localhost:8080/modules/graphql`
+
+**Always include both auth flags:**
+```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": "..."}'
+```
+
+> ⚠️ The `Origin` header is **required** — omitting it returns `Permission denied`.
+
+---
+
+## Step 1 — Audit the current content tree
+
+Before moving anything, map out what exists and where:
+
+```bash
+# List all content folders and their direct children
+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/mySite/contents\") { descendants(fieldFilter: {filters: [{fieldName: \"primaryNodeType.name\", evaluation: EQUAL, value: \"jnt:contentFolder\"}]}) { nodes { path name } } } } }"
+  }'
+```
+
+Or use a JCR-SQL2 query for a flat list of all content items:
+
+```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 { nodesByQuery(query: \"SELECT * FROM [jnt:content] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027) ORDER BY [jcr:path] ASC\", queryLanguage: SQL2) { nodes { path primaryNodeType { name } } } } }"
+  }'
+```
+
+---
+
+## Step 2 — Create target sub-folders
+
+If destination folders don't exist yet, create them with `mix:title` for a proper display label:
+
+```bash
+# Create a sub-folder
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { addNode(parentPathOrId: \"/sites/mySite/contents/articles\", name: \"getting-started\", primaryNodeType: \"jnt:contentFolder\") { node { path } } } }"
+  }'
+
+# Set a human-readable title on the folder
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/getting-started\") { addMixins(mixins: [\"mix:title\"]) mutateProperty(name: \"jcr:title\") { setValue(language: \"en\", value: \"Getting Started\") } } } }"
+  }'
+```
+
+---
+
+## Step 3 — Move a node
+
+Use `move` on a `mutateNode` to relocate a node to a new parent. The node keeps its name:
+
+```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": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/my-article\") { move(parentPathOrId: \"/sites/mySite/contents/articles/getting-started\") } } }"
+  }'
+```
+
+> ⚠️ `move` does **not** support a `name` argument — use `rename` separately if needed.
+
+### Rename a node in place
+
+```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": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles\") { rename(name: \"reference-pages\") } } }"
+  }'
+```
+
+To move **and** rename, call `move` then `rename` in sequence, or combine in one mutation:
+
+```graphql
+mutation {
+  jcr {
+    mutateNode(pathOrId: "/sites/mySite/contents/articles/old-name") {
+      move(parentPathOrId: "/sites/mySite/contents/articles/getting-started")
+    }
+    rename: mutateNode(pathOrId: "/sites/mySite/contents/articles/getting-started/old-name") {
+      rename(name: "new-name")
+    }
+  }
+}
+```
+
+### Batch move with Python
+
+```python
+import subprocess, json
+
+def gql(q):
+    r = subprocess.run(["curl","-s","-u","root:root1234",
+        "-H","Origin: http://localhost:8080",
+        "-H","Content-Type: application/json",
+        "-X","POST","http://localhost:8080/modules/graphql",
+        "-d", json.dumps({"query": q})], capture_output=True, text=True)
+    d = json.loads(r.stdout)
+    if "errors" in d: print("ERR:", d["errors"][0]["message"][:80])
+    return d
+
+moves = [
+    ("/sites/mySite/contents/articles/getting-started",
+     "/sites/mySite/contents/articles/core-concepts"),
+    ("/sites/mySite/contents/articles/graphql-api",
+     "/sites/mySite/contents/articles/api-reference"),
+]
+
+for src, dest in moves:
+    r = gql(f'mutation {{ jcr {{ mutateNode(pathOrId: "{src}") {{ move(parentPathOrId: "{dest}") }} }} }}')
+    ok = "errors" not in r
+    print(f"  {'✓' if ok else '✗'} {src.split('/')[-1]} → {dest.split('/')[-1]}")
+```
+
+---
+
+## Step 4 — Reorder siblings
+
+To control the display order within a folder, use `reorder` after moving:
+
+```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": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/intro\") { reorder(reorderNodes: {moveBeforeOrAfter: BEFORE, target: \"advanced\"}) } } }"
+  }'
+```
+
+---
+
+## Step 5 — Publish after moving
+
+Moving a node unpublishes it in the live workspace. Always republish after reorganizing:
+
+```bash
+# Publish a single node
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/getting-started/my-article\") { publish(languages: [\"en\"]) } } }"
+  }'
+
+# Publish everything under a folder at once
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNodesByQuery(query: \"SELECT * FROM [jnt:content] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027)\", queryLanguage: SQL2) { publish(languages: [\"en\"]) } } }"
+  }'
+```
+
+---
+
+## Step 6 — Verify
+
+```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 { nodesByQuery(query: \"SELECT * FROM [jnt:content] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027)\", queryLanguage: SQL2) { nodes { path } } } }"
+  }'
+```
+
+---
+
+## Common errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `Permission denied` | Missing `Origin` header | Add `-H "Origin: http://localhost:8080"` |
+| `ItemExistsException` | A node with that name already exists at the destination | Choose a different name or use `rename` after moving |
+| `PathNotFoundException` | Source or destination path doesn't exist | Verify paths with `nodeByPath` first |
+| `move` returns `null` | Node was already at that location | Verify the current path first |
+| Content disappears from live after move | Move unpublishes — normal JCR behaviour | Run `publish` after every move |
+
+---
+
+## Workflow summary
+
+```
+1. Audit      → list current paths and types
+2. Plan       → map old paths to new paths/folders
+3. Create     → addNode for any new folders needed
+4. Move       → mutateNode { move(...) } for each item
+5. Publish    → mutateNodesByQuery { publish(...) } for all affected content
+6. Verify     → query back and confirm structure
+```

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

@@ -0,0 +1,144 @@
+---
+name: jahia-content-query-content
+description: Queries JCR content from a running Jahia instance via the GraphQL API. Use when asked to list, inspect, or retrieve content nodes, check what content exists, or audit a site's content.
+---
+
+# Skill: jahia-content-query-content
+
+Retrieves JCR content from a running Jahia instance using the GraphQL JCR query API.
+
+---
+
+## Prerequisites
+
+- Jahia running at `http://localhost:8080`
+- Credentials: `root` / `root1234` (default)
+- GraphQL endpoint: `http://localhost:8080/modules/graphql`
+
+**Auth pattern — always use both flags:**
+```bash
+curl -u root:root1234 \
+     -H "Content-Type: application/json" \
+     -H "Origin: http://localhost:8080" \
+     ...
+```
+
+> ⚠️ The `Origin: http://localhost:8080` header is **required**. Requests without it return `Permission denied` even with correct credentials.
+
+---
+
+## Query patterns
+
+### 1 — Get a node by path
+
+```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/mySite/contents/articles\") { children { nodes { name path primaryNodeType { name } } } } } }"
+  }'
+```
+
+### 2 — Query by node type (JCR-SQL2)
+
+```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 { nodesByQuery(query: \"SELECT * FROM [namespace:typeName] WHERE ISDESCENDANTNODE(\u0027/sites/mySite\u0027) ORDER BY [jcr:created] DESC\", queryLanguage: SQL2) { nodes { name path uuid } } } }"
+  }'
+```
+
+### 3 — Read node properties (including i18n)
+
+```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/mySite/contents/articles/my-article\") { name uuid properties(language: \"en\") { name value } } } }"
+  }'
+```
+
+> ⚠️ **i18n properties require `language:` in the `properties()` call.** Without it, i18n properties are returned empty.
+
+### 4 — Filter by property value
+
+```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 { nodesByQuery(query: \"SELECT * FROM [namespace:article] WHERE [product] = \u0027jahia\u0027 AND ISDESCENDANTNODE(\u0027/sites/mySite\u0027)\", queryLanguage: SQL2) { nodes { name path } } } }"
+  }'
+```
+
+### 5 — List all sites
+
+```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 { nodesByQuery(query: \"SELECT * FROM [jnt:virtualsite] WHERE ISCHILDNODE(\u0027/sites\u0027)\", queryLanguage: SQL2) { nodes { name path } } } }"
+  }'
+```
+
+### 6 — Check publication status
+
+```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/mySite/contents/articles/my-article\") { name aggregatedPublicationInfo(language: \"en\") { publicationStatus } } } }"
+  }'
+```
+
+Publication status values: `PUBLISHED`, `MODIFIED`, `NOT_PUBLISHED`, `UNPUBLISHED`, `MARKED_FOR_DELETION`
+
+---
+
+## JCR-SQL2 quick reference
+
+```sql
+-- All nodes of a type under a path
+SELECT * FROM [ns:typeName] WHERE ISDESCENDANTNODE('/sites/mySite')
+
+-- Direct children only
+SELECT * FROM [ns:typeName] WHERE ISCHILDNODE('/sites/mySite/contents/articles')
+
+-- Filter by property
+SELECT * FROM [ns:typeName] WHERE [propName] = 'value'
+
+-- Order by date (newest first)
+SELECT * FROM [ns:typeName] WHERE ISDESCENDANTNODE('/sites/mySite') ORDER BY [jcr:created] DESC
+
+-- Limit results (pass limit/offset as query params)
+-- nodesByQuery(query: "...", queryLanguage: SQL2, limit: 10, offset: 0)
+```
+
+---
+
+## Common errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `Permission denied` | Missing `Origin` header | Add `-H "Origin: http://localhost:8080"` |
+| i18n properties returned empty | `language:` not specified | Add `language: "en"` to `properties()` call |
+| Node not found | Wrong path or node doesn't exist | Verify path with `nodeByPath(path: "/sites")` first |
+
+---
+
+## References
+
+- Jahia GraphQL API: `http://localhost:8080/modules/graphql` (open in browser for interactive playground)
+- JCR-SQL2 language spec: https://docs.adobe.com/content/docs/en/spec/jcr/2.0/6_Query.html

package/dist/claude/.claude/skills/jahia-content-translate-content/SKILL.md

@@ -0,0 +1,297 @@
+---
+name: jahia-content-translate-content
+description: Adds language support to a Jahia site and translates existing content nodes. Use when asked to add a new language, fill in missing translations, or audit which content lacks i18n values.
+---
+
+# Skill: jahia-content-translate-content
+
+Adds languages to a Jahia site and populates i18n properties on existing content nodes via the GraphQL API.
+
+---
+
+## Prerequisites
+
+- Jahia running at `http://localhost:8080`
+- Credentials: `root` / `root1234` (default)
+- GraphQL endpoint: `http://localhost:8080/modules/graphql`
+
+**Always include both auth flags:**
+```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": "..."}'
+```
+
+> ⚠️ The `Origin` header is **required** — omitting it returns `Permission denied`.
+
+---
+
+## Step 1 — Enable the new language on the site
+
+Before creating or querying translations, the language must be declared on the site node.
+
+```bash
+# Check currently enabled languages
+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/mySite\") { properties(names: [\"j:languages\",\"j:defaultLanguage\"]) { name values } } } }"
+  }'
+
+# Add a language (e.g. "fr") — use setPropertiesBatch with the full new list
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite\") { setPropertiesBatch(properties: [{name: \"j:languages\", values: [\"en\", \"fr\"]}]) { path } } } }"
+  }'
+```
+
+> ⚠️ `j:languages` is a multi-valued property — always pass the **complete** list of languages, not just the new one. Passing only `["fr"]` would remove `"en"`.
+
+---
+
+## Step 2 — Audit content missing translations
+
+Query all i18n-bearing nodes and inspect which ones have empty values for the target language:
+
+```bash
+# Find all content nodes under /sites/mySite/contents
+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 { nodesByQuery(query: \"SELECT * FROM [jmix:i18n] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027) ORDER BY [jcr:path] ASC\", queryLanguage: SQL2) { nodes { path primaryNodeType { name } properties(language: \"fr\") { name value } } } } }"
+  }'
+```
+
+Or query a specific content type:
+
+```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 { nodesByQuery(query: \"SELECT * FROM [namespace:article] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027)\", queryLanguage: SQL2) { nodes { path properties(language: \"fr\") { name value } } } } }"
+  }'
+```
+
+Look for nodes where i18n fields (`jcr:title`, `body`, etc.) have empty or null `value`.
+
+---
+
+## Step 3 — Set i18n properties
+
+### Single node
+
+```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": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/my-article\") { setPropertiesBatch(properties: [{name: \"jcr:title\", value: \"Mon article\", language: \"fr\"}, {name: \"body\", value: \"<p>Contenu ici</p>\", language: \"fr\"}]) { path } } } }"
+  }'
+```
+
+> ⚠️ Use `setPropertiesBatch` (plural), not `setProperty` (singular — does not exist in the Jahia GraphQL API).
+
+### Critical ordering rule
+
+When a content type has **mandatory** i18n fields (other than `jcr:title`), set those **before** `jcr:title`. Setting `jcr:title` first can trigger a constraint check before all mandatory fields are present.
+
+The safe pattern — set all mandatory i18n fields in a single `setPropertiesBatch` call:
+
+```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": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/my-article\") { setPropertiesBatch(properties: [{name: \"body\", value: \"<p>Contenu ici</p>\", language: \"fr\"}, {name: \"jcr:title\", value: \"Mon article\", language: \"fr\"}]) { path } } } }"
+  }'
+```
+
+---
+
+## Step 4 — Bulk translation with Python
+
+For translating many nodes at once:
+
+```python
+import json
+from urllib.request import Request, urlopen
+
+JAHIA = "http://localhost:8080"
+AUTH = ("root", "root1234")
+
+import base64
+token = base64.b64encode(f"{AUTH[0]}:{AUTH[1]}".encode()).decode()
+HEADERS = {
+    "Content-Type": "application/json",
+    "Origin": JAHIA,
+    "Authorization": f"Basic {token}",
+}
+
+def gql(query):
+    body = json.dumps({"query": query}).encode()
+    req = Request(f"{JAHIA}/modules/graphql", data=body, headers=HEADERS, method="POST")
+    with urlopen(req) as r:
+        d = json.loads(r.read())
+    if "errors" in d:
+        print("ERR:", d["errors"][0]["message"][:120])
+    return d
+
+# 1. List all articles missing French title
+result = gql(
+    '{ jcr { nodesByQuery(query: "SELECT * FROM [namespace:article] '
+    "WHERE ISDESCENDANTNODE('/sites/mySite/contents') "
+    'ORDER BY [jcr:path] ASC", queryLanguage: SQL2) '
+    '{ nodes { path properties(language: "fr") { name value } } } } }'
+)
+
+nodes = result["data"]["jcr"]["nodesByQuery"]["nodes"]
+missing_fr = [
+    n["path"]
+    for n in nodes
+    if not any(p["name"] == "jcr:title" and p["value"] for p in n["properties"])
+]
+
+# 2. Set French translations (replace with actual translated values)
+translations = {
+    "/sites/mySite/contents/articles/article-1": ("Titre FR 1", "<p>Corps FR 1</p>"),
+    "/sites/mySite/contents/articles/article-2": ("Titre FR 2", "<p>Corps FR 2</p>"),
+}
+
+for path, (title, body) in translations.items():
+    r = gql(
+        f'mutation {{ jcr {{ mutateNode(pathOrId: "{path}") {{'
+        f' setPropertiesBatch(properties: ['
+        f'  {{name: "body", value: {json.dumps(body)}, language: "fr"}},'
+        f'  {{name: "jcr:title", value: {json.dumps(title)}, language: "fr"}}'
+        f' ]) {{ path }} }} }} }}'
+    )
+    ok = "errors" not in r
+    print(f"  {'✓' if ok else '✗'} {path.split('/')[-1]}")
+```
+
+---
+
+## Step 5 — Choicelist fields and view-level translations
+
+### Choicelist fields should NOT be i18n
+
+If a CND property uses a choicelist (e.g. `category`, `status`), its stored values are language-agnostic keys like `"featured"` or `"draft"`. The display label is translated **in the view**, not in the JCR.
+
+```tsx
+// In the view component — translate the stored key to a display label
+const STATUS_LABELS: Record<string, Record<string, string>> = {
+  en: { featured: "Featured", draft: "Draft" },
+  fr: { featured: "En vedette", draft: "Brouillon" },
+};
+
+const lang = renderContext.getMainResourceLocale().getLanguage();
+const statusKey = properties.status as string;
+const statusLabel = STATUS_LABELS[lang]?.[statusKey] ?? statusKey;
+```
+
+Do **not** add `i18n` to the CND property for choicelists — the key should be the same in all languages.
+
+### Hardcoded UI strings
+
+View-level strings that are not stored in JCR (button labels, headings, placeholder text) need locale-keyed label maps in the component:
+
+```tsx
+const LABELS = {
+  en: { readMore: "Read more", by: "By" },
+  fr: { readMore: "Lire la suite", by: "Par" },
+};
+
+const t = LABELS[renderContext.getMainResourceLocale().getLanguage()] ?? LABELS.en;
+// Usage: <a>{t.readMore}</a>
+```
+
+---
+
+## Step 6 — Clean up orphaned translation nodes
+
+When you remove the `i18n` flag from a CND property (or delete a language from the site), orphaned `j:translation_XX` child nodes may remain. Inspect and remove them if needed:
+
+```bash
+# Find translation sub-nodes for a content node
+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/mySite/contents/articles/my-article\") { children { nodes { name primaryNodeType { name } } } } } }"
+  }'
+
+# Delete an orphaned translation node
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { deleteNode(pathOrId: \"/sites/mySite/contents/articles/my-article/j:translation_fr\") }"
+  }'
+```
+
+---
+
+## Step 7 — Publish translations
+
+After setting i18n properties, republish to make them live:
+
+```bash
+# Publish a single node for a specific language
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNode(pathOrId: \"/sites/mySite/contents/articles/my-article\") { publish(languages: [\"fr\"]) } } }"
+  }'
+
+# Publish all articles in both languages
+curl -s -u root:root1234 \
+  -H "Content-Type: application/json" \
+  -H "Origin: http://localhost:8080" \
+  -X POST http://localhost:8080/modules/graphql \
+  -d '{
+    "query": "mutation { jcr { mutateNodesByQuery(query: \"SELECT * FROM [namespace:article] WHERE ISDESCENDANTNODE(\u0027/sites/mySite/contents\u0027)\", queryLanguage: SQL2) { publish(languages: [\"en\", \"fr\"]) } } }"
+  }'
+```
+
+---
+
+## Common errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `Permission denied` | Missing `Origin` header | Add `-H "Origin: http://localhost:8080"` |
+| i18n property returned empty after set | Missing `language:` in `properties()` query | Add `language: "fr"` to read call |
+| `ConstraintViolationException` on title set | Mandatory i18n field not set first | Use `setPropertiesBatch` with all mandatory fields in one call |
+| Language not appearing in site | `j:languages` mutation only had the new language | Pass the full list: `["en", "fr"]` |
+| Choicelist key changed per language | Property incorrectly declared `i18n` in CND | Remove `i18n` from the CND property; translate keys in the view |
+
+---
+
+## Workflow summary
+
+```
+1. Enable language   → mutateNode j:languages with full list
+2. Audit             → nodesByQuery with properties(language: "XX") to find gaps
+3. Translate         → setPropertiesBatch with language: "XX" for each i18n field
+4. View strings      → add locale-keyed label maps in .server.tsx
+5. Choicelists       → translate keys in the view, not the JCR
+6. Publish           → publish(languages: ["XX"]) for all affected nodes
+7. Verify            → query back with language: "XX" to confirm values
+```