@jahia/agentic 0.0.0

package/dist/opencode/.agents/skills/jahia-dev-jexperience/SKILL.md

@@ -0,0 +1,269 @@
+---
+name: jahia-dev-jexperience
+description: Integrate a Jahia JavaScript module with jExperience and jCustomer — set up the local stack, push visitor events from client components, visualize data in Kibana, and package dashboards for deployment.
+allowed-tools: Bash, Read, Write, Edit
+---
+
+## What is jExperience / jCustomer?
+
+**jCustomer** (built on Apache Unomi) collects and processes visitor events to create personalized digital experiences. **jExperience** is the Jahia module that bridges Jahia with jCustomer — it injects the `window.wem` tracker into every page and exposes dashboards inside jContent.
+
+Together they form Jahia's **DXP** (Digital Experience Platform). You only need this skill when you want to track interactions, build personalization, or visualize visitor data.
+
+---
+
+## Step 1 — Set up jCustomer locally
+
+### 1a — Update `docker-compose.yml`
+
+Give the `jahia` service a static IP, add three containers, and declare the subnet:
+
+```yaml
+services:
+  jahia:
+    # ... existing config ...
+    networks:
+      default:
+        ipv4_address: 172.16.1.100
+
+  elasticsearch:
+    image: elasticsearch:7.17.28
+    ports:
+      - 9200:9200
+    environment:
+      discovery.type: single-node
+      cluster.name: jahia-es-cluster
+
+  kibana:
+    image: kibana:7.17.28
+    ports:
+      - 5601:5601
+    environment:
+      discovery.type: single-node
+      elasticsearch.hosts: http://elasticsearch:9200
+
+  jcustomer:
+    image: jahia/jcustomer:2.6
+    depends_on:
+      - elasticsearch
+    ports:
+      - 9443:9443
+      - 8181:8181
+      - 8102:8102
+    environment:
+      UNOMI_ELASTICSEARCH_ADDRESSES: elasticsearch:9200
+      UNOMI_ELASTICSEARCH_CLUSTERNAME: jahia-es-cluster
+      UNOMI_CLUSTER_PUBLIC_ADDRESS: http://localhost:8181
+      UNOMI_CLUSTER_INTERNAL_ADDRESS: https://jcustomer:9443
+      UNOMI_THIRDPARTY_PROVIDER1_IPADDRESSES: 172.16.1.100
+      UNOMI_THIRDPARTY_PROVIDER1_ALLOWEDEVENTS: login,updateProperties
+      UNOMI_ROOT_PASSWORD: karaf
+      UNOMI_HAZELCAST_TCPIP_MEMBERS: jcustomer
+
+networks:
+  default:
+    ipam:
+      config:
+        - subnet: 172.16.1.0/24
+```
+
+### 1b — Update `docker/provisioning.yml`
+
+Append at the end of the file:
+
+```yaml
+# Install and start jExperience
+- installModule:
+    - "mvn:org.jahia.modules/jexperience/3.6.2"
+    - "mvn:org.jahia.modules/jexperience-dashboards/1.0.0"
+  autoStart: true
+  uninstallPreviousVersion: true
+
+# Connect jExperience to jCustomer
+- editConfiguration: "org.jahia.modules.jexperience.settings"
+  configIdentifier: "global"
+  properties:
+    jexperience.jCustomerURL: "https://jcustomer:9443"
+    jexperience.jCustomerUsername: "karaf"
+    jexperience.jCustomerPassword: "karaf"
+    jexperience.jCustomerTrustAllCertificates: "true"
+    jexperience.jCustomerUsePublicAddressesForAdmin: "false"
+    jexperience.jCustomerKey: "670c26d1cc413346c3b2fd9ce65dab41"
+
+# Configure Kibana dashboards proxy
+- editConfiguration: "org.jahia.modules.kibana_dashboards_provider"
+  properties:
+    kibana_dashboards_provider.kibanaURL: "http://kibana:5601"
+    kibana_dashboards_provider.kibanaUser: "elastic"
+    kibana_dashboards_provider.kibanaPassword: "ELASTIC_PASSWORD"
+    kibana_dashboards_provider.KibanaProxy.enable: "true"
+    kibana_dashboards_provider.KibanaProxy.cloud: "true"
+- installModule:
+    - "mvn:org.jahia.modules/kibana-dashboards-provider/1.4.0"
+  autoStart: true
+  uninstallPreviousVersion: true
+```
+
+### 1c — Start the stack
+
+```bash
+docker compose down jahia && docker compose up --wait
+```
+
+### 1d — Enable jExperience on the site
+
+1. Open **Administration → Modules → jExperience → Usage in sites**
+2. Check the box next to your site. Repeat for **jExperience Dashboards**.
+3. Open jContent — a new **jExperience** tab should appear in the vertical bar (refresh if needed).
+
+---
+
+## Step 2 — Push events from a client component
+
+jExperience injects `window.wem` (Web Experience Manager) into every page. It is only available in the browser — use it inside `.client.tsx` files.
+
+### Event model
+
+Every event has two parts:
+
+| Part | What it is | Helper |
+|------|------------|--------|
+| **source** | Where the event happened (usually the current page) | `wem.buildSourcePage()` |
+| **target** | What happened (the action) | `wem.buildTarget(id, type, properties)` |
+
+### Full example — feedback widget
+
+```tsx
+// src/components/FeedbackWidget/definition.cnd
+// [hydrogen:feedbackWidget] > jnt:content, hydrogenmix:component
+//  - question (string) = 'Was this helpful?'
+```
+
+```tsx
+// Widget.client.tsx
+import { useState } from "react";
+
+export default function Widget({ question }: { question: string }) {
+  const [sent, setSent] = useState(false);
+
+  const handler = (happy: boolean) => () => {
+    const source = wem.buildSourcePage();
+    const target = wem.buildTarget("feedback", "click", { happy });
+    const event = wem.buildEvent("click", target, source);
+    wem.collectEvents({ events: [event] });
+    setSent(true);
+  };
+
+  if (sent) return <aside>Thank you for your feedback!</aside>;
+
+  return (
+    <aside>
+      {question}
+      <button type="button" onClick={handler(true)}>Yes</button>
+      <button type="button" onClick={handler(false)}>No</button>
+    </aside>
+  );
+}
+```
+
+```tsx
+// default.server.tsx
+import { jahiaComponent, Island } from "@jahia/javascript-modules-library";
+import Widget from "./Widget.client.jsx";
+
+interface Props { question: string; }
+
+jahiaComponent(
+  { nodeType: "hydrogen:feedbackWidget", componentType: "view" },
+  ({ question }: Props) => (
+    <Island clientOnly component={Widget} props={{ question }}>
+      Loading…
+    </Island>
+  ),
+);
+```
+
+### `window.wem` API reference
+
+| Method | Signature | Returns |
+|--------|-----------|---------|
+| `buildSourcePage` | `()` | Source object for the current page |
+| `buildTarget` | `(id: string, type: string, properties?: object)` | Target object |
+| `buildEvent` | `(eventType: string, target, source)` | Event object |
+| `collectEvents` | `({ events: Event[] })` | Sends events to jCustomer |
+
+`buildTarget` properties are free-form — pass any serializable data you want to analyse downstream (e.g. `{ happy: true }`, `{ productId: "p-123" }`).
+
+> The `window.wem` object comes from the [apache/unomi-tracker](https://github.com/apache/unomi-tracker) package. Refer to its documentation for advanced event types.
+
+### Google Tag Manager alternative
+
+If your site uses GTM instead of jCustomer:
+
+```tsx
+dataLayer.push({ event: "feedback", happy });
+```
+
+---
+
+## Step 3 — Verify events in Kibana
+
+1. Open [localhost:5601](http://localhost:5601)
+2. Go to **Discover**, select the `*-event` index, and expand the time range
+3. Browse an event — confirm the `source.properties.pageInfo.pagePath` and `target.properties.happy` fields are present
+
+---
+
+## Step 4 — Create a Kibana dashboard
+
+### Create a saved search
+
+In **Discover**, add column filters for:
+- `eventType` = `click`
+- `itemType` = `event`
+- `target.itemId` = `feedback`
+- `target.itemType` = `click`
+
+Add display columns: `source.properties.pageInfo.pagePath`, `target.properties.happy`. Save as e.g. **All Feedbacks**.
+
+### Create the dashboard
+
+1. **Dashboards → Create dashboard**
+2. **Add from library** → add the saved search (table of all feedbacks)
+3. **Create visualization** → paste this KQL filter into the search bar:
+   ```
+   eventType: click and itemType: event and target.itemId: feedback and target.itemType: click
+   ```
+4. Drop **Records** onto the panel, then in **Break down by** select `target.properties.happy`. Use the **Status** color palette for red/green.
+5. **Save and return**, then **Save** the dashboard with a meaningful name — this name becomes the entry label inside Jahia's jExperience tab.
+
+---
+
+## Step 5 — Package the dashboard in the module
+
+Dashboards exported from Kibana are automatically imported when the module is deployed.
+
+1. In Kibana go to **Analytics → Overview → Manage → Saved Objects**
+2. Select your dashboard, click **Export** — you get a `.ndjson` file
+3. Save it to your module:
+   ```
+   settings/kibana-dashboard/dashboards/<dashboard-name>.ndjson
+   ```
+4. Deploy the module — the dashboard will appear in the jExperience tab on any Jahia instance running the module.
+
+---
+
+## Validation checklist
+- [ ] `docker compose up --wait` completed with elasticsearch, kibana, jcustomer healthy
+- [ ] jExperience and jExperience Dashboards enabled on the target site
+- [ ] jExperience tab visible in jContent
+- [ ] Client component uses `.client.tsx` extension and `Island clientOnly`
+- [ ] `wem.collectEvents` called with a valid event (source + target)
+- [ ] Events visible in Kibana Discover under `*-event` index
+- [ ] Dashboard saved and visible under the jExperience tab in Jahia
+- [ ] Dashboard `.ndjson` saved to `settings/kibana-dashboard/dashboards/` for packaging
+
+## References
+- Apache Unomi tracker: https://github.com/apache/unomi-tracker
+- KQL query syntax: https://www.elastic.co/guide/en/kibana/current/kuery-query.html
+- jExperience guide: https://github.com/Jahia/javascript-modules/blob/main/docs/2-guides/1-building-a-feedback-form/README.md

package/dist/opencode/.agents/skills/jahia-dev-ops/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: jahia-dev-ops
+description: >
+  Operational guidance for running Jahia in production: Docker Compose and
+  Kubernetes deployments, environment configuration, health monitoring,
+  log analysis, and provisioning via the Jahia Provisioning API. Use when
+  the user is deploying, maintaining, debugging, or scaling a Jahia instance
+  (DX, jCustomer, Augmented Search / Elasticsearch, Kibana, Unomi).
+allowed-tools: Read
+---
+
+# Jahia DevOps Skill
+
+This skill covers day-to-day operations of a Jahia platform environment.
+Detailed reference sheets are in `references/`.
+
+## Reference files
+
+| File | Content |
+|------|---------|
+| `references/docker.md` | Docker Compose stacks, environment variables, volume layout, networking, common run-commands |
+| `references/monitoring.md` | Health endpoints, log locations, JVM/GC tuning, Karaf console, alert patterns |
+| `references/provisioning.md` | Jahia Provisioning API (YAML scripts), module lifecycle, site import/export, JCR operations |
+
+## Quick orientation
+
+### Core components
+
+- **Jahia DX** (`jahia/jahia-ee` or `jahia/jahia`) — the main CMS node
+- **jCustomer / Apache Unomi** (`jahia/jcustomer`) — customer data platform
+- **Augmented Search** (`jahia/elasticsearch` wrapper) — search back-end
+- **Kibana** — Unomi analytics dashboard (optional)
+- **MariaDB / MySQL** — relational database for JCR metadata and Jackrabbit bundles
+
+### Typical task flow
+
+1. **Deploy** — pick the right Docker Compose file or Helm chart (see `references/docker.md`)
+2. **Configure** — set env vars for DB, cluster, mail, LDAP (see `references/docker.md`)
+3. **Provision** — push modules, create sites, seed content (see `references/provisioning.md`)
+4. **Monitor** — watch `/healthcheck`, logs, Karaf console (see `references/monitoring.md`)
+5. **Troubleshoot** — collect thread dump, heap dump, or GC log; check OSGi bundle state
+
+### Support escalation checklist
+
+When filing a Jahia Support ticket always attach:
+- `docker-compose.yml` (redact passwords)
+- `jahia.log` (last 500 lines minimum)
+- Output of `/healthcheck?includeDetails=true`
+- Output of `bundle:list` from Karaf console
+- JVM version: `java -version` inside the container

package/dist/opencode/.agents/skills/jahia-dev-ops/references/docker.md

@@ -0,0 +1,151 @@
+# Jahia Docker Reference
+
+## Image tags
+
+| Image | Stable tag pattern | Notes |
+|-------|--------------------|-------|
+| `jahia/jahia-ee` | `8.2.x.x` | Enterprise Edition (most deployments) |
+| `jahia/jahia` | `8.2.x.x` | Community Edition |
+| `jahia/jcustomer` | `2.6.x` | Apache Unomi-based CDP |
+| `jahia/elasticsearch` | `7.17.x-jahia` | Patched ES image for Augmented Search |
+
+Always pin to an exact version in production. Avoid `latest`.
+
+## Minimal single-node docker-compose.yml
+
+```yaml
+version: "3.8"
+services:
+  jahia:
+    image: jahia/jahia-ee:8.2.4.0
+    ports:
+      - "8080:8080"
+      - "7770:7770"   # Karaf SSH
+    environment:
+      JAHIA_ROOT_PASSWORD: changeme
+      DB_HOST: mariadb
+      DB_NAME: jahia
+      DB_USER: jahia
+      DB_PASS: jahia
+      PROCESSING_SERVER: "true"
+    volumes:
+      - jahia-data:/var/jahia
+      - jahia-logs:/var/log/jahia
+    depends_on:
+      mariadb:
+        condition: service_healthy
+
+  mariadb:
+    image: mariadb:10.11
+    environment:
+      MYSQL_DATABASE: jahia
+      MYSQL_USER: jahia
+      MYSQL_PASSWORD: jahia
+      MYSQL_ROOT_PASSWORD: root
+    volumes:
+      - mariadb-data:/var/lib/mysql
+    healthcheck:
+      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+
+volumes:
+  jahia-data:
+  jahia-logs:
+  mariadb-data:
+```
+
+## Key environment variables
+
+### Jahia DX
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `JAHIA_ROOT_PASSWORD` | *(required)* | `root` user password |
+| `DB_HOST` | `mariadb` | Database hostname |
+| `DB_PORT` | `3306` | Database port |
+| `DB_NAME` | `jahia` | Database name |
+| `DB_USER` | `jahia` | Database user |
+| `DB_PASS` | *(required)* | Database password |
+| `PROCESSING_SERVER` | `true` | Enable background processing (set false on non-primary cluster nodes) |
+| `CLUSTER_ENABLED` | `false` | Enable Hazelcast clustering |
+| `CLUSTER_NODES` | | Comma-separated `host:port` list of cluster peers |
+| `MAX_RAM_PERCENTAGE` | `70` | Heap ceiling as % of container RAM |
+| `EXTRA_JAVA_OPTS` | | Append arbitrary JVM flags |
+| `JAHIA_DEPLOY_ON_STARTUP` | | Comma-separated module JAR paths to deploy at first boot |
+| `OPERATING_MODE` | `development` | `development` or `production` |
+| `MAIL_SERVER` | | SMTP URI e.g. `smtp://mail.example.com:25` |
+| `MAIL_FROM` | | Sender address for system mail |
+| `MAIL_ADMIN` | | Admin notification address |
+
+### jCustomer / Unomi
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `UNOMI_ROOT_PASSWORD` | *(required)* | Admin password |
+| `UNOMI_ELASTICSEARCH_ADDRESSES` | `elasticsearch:9200` | ES cluster addresses |
+| `UNOMI_CLUSTER_KUBERNETES` | `false` | Enable K8s cluster discovery |
+| `UNOMI_THIRDPARTY_PROVIDER1_IPADDRESSES` | | Trusted IP ranges (for Jahia → Unomi calls) |
+| `EXTRA_JAVA_OPTS` | | Append JVM flags |
+
+### Elasticsearch (jahia image)
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `discovery.type` | `single-node` | Use `zen` for multi-node |
+| `ES_JAVA_OPTS` | `-Xms512m -Xmx512m` | Heap; set both to the same value |
+| `xpack.security.enabled` | `false` | Enable TLS/auth |
+
+## Volume layout inside the Jahia container
+
+```
+/var/jahia/           ← JAHIA_DATA_DIR (repo, bundles, configuration)
+  jackrabbit/         ← JCR workspace
+  modules/            ← Hot-deploy OSGi bundles (.jar)
+  patches/            ← groovy/cfg/spring patches applied at startup
+  digital-factory-config/  ← override jahia.properties / OSGi .cfg
+/var/log/jahia/       ← log4j output files
+  jahia.log
+  access.log
+  errors.log
+```
+
+## Useful run-time commands
+
+```bash
+# Tail combined Jahia logs
+docker compose logs -f jahia
+
+# Enter the container
+docker compose exec jahia bash
+
+# Karaf SSH console (password = same as JAHIA_ROOT_PASSWORD)
+ssh -p 7770 karaf@localhost
+
+# Force redeploy a module (drop the jar into hot-deploy)
+docker compose cp my-module-1.0.jar jahia:/var/jahia/modules/
+
+# Check resource usage
+docker stats jahia mariadb
+
+# One-shot health check
+curl -u root:changeme http://localhost:8080/healthcheck?includeDetails=true
+```
+
+## Cluster (Hazelcast) quick checklist
+
+1. Set `CLUSTER_ENABLED=true` on all nodes.
+2. All nodes must share the same `DB_*` credentials pointing at the same DB.
+3. `PROCESSING_SERVER=true` on exactly **one** node (the processing node).
+4. Expose port `5900` between containers/pods for Hazelcast.
+5. Mount a shared NFS or object-store volume for `/var/jahia/jackrabbit/repository/datastore`.
+6. Verify membership: Karaf console → `cluster:info`.
+
+## Kubernetes notes
+
+- Use the official Jahia Helm chart (`jahia/jahia`) from `https://charts.jahia.com`.
+- Set `jahia.processingServer.replicas=1` and `jahia.browsing.replicas=N`.
+- Use a `ReadWriteMany` PVC (e.g. EFS / NFS) for the datastore.
+- Liveness probe: `GET /healthcheck` — expect HTTP 200.
+- Readiness probe: `GET /healthcheck?includeDetails=true` — parse `"status":"GREEN"`.

package/dist/opencode/.agents/skills/jahia-dev-ops/references/monitoring.md

@@ -0,0 +1,195 @@
+# Jahia Monitoring Reference
+
+## Health endpoints
+
+| Endpoint | Auth | Returns |
+|----------|------|---------|
+| `GET /healthcheck` | None | `{"status":"GREEN"}` or non-200 |
+| `GET /healthcheck?includeDetails=true` | Basic (root) | Full JSON with per-probe status |
+| `GET /modules/healthcheck` | Basic (root) | Module-level detail |
+| `GET /live` | None | Kubernetes liveness (200 = alive) |
+| `GET /ready` | None | Kubernetes readiness (200 = ready to serve) |
+
+### Interpreting `/healthcheck?includeDetails=true`
+
+```json
+{
+  "status": "GREEN",      // GREEN | YELLOW | RED
+  "probes": {
+    "DatabaseProbe":    { "status": "GREEN" },
+    "ServerLoadProbe":  { "status": "YELLOW", "message": "Load: 3.4" },
+    "JCRProbe":         { "status": "GREEN" }
+  }
+}
+```
+
+A `RED` status means the instance should not receive traffic. A `YELLOW` means
+degraded but still functional. Common probe names: `DatabaseProbe`,
+`JCRProbe`, `ServerLoadProbe`, `ModulesProbe`, `ClusterProbe`.
+
+## Log files
+
+| File | Content |
+|------|---------|
+| `/var/log/jahia/jahia.log` | Main application log (INFO+) |
+| `/var/log/jahia/errors.log` | ERROR-only mirror of jahia.log |
+| `/var/log/jahia/access.log` | HTTP access log (Combined format) |
+| `/var/log/jahia/jahia_audit.log` | Security/audit events |
+| `/var/log/jahia/gc.log*` | GC log (if `-Xlog:gc*` enabled) |
+
+### Key log patterns to watch
+
+```
+# Module deployment failure
+ERROR.*BundleException
+ERROR.*Failed to deploy module
+
+# JCR / Jackrabbit errors
+ERROR.*RepositoryException
+ERROR.*ItemExistsException
+
+# DB connectivity
+ERROR.*Cannot get a connection
+ERROR.*Communications link failure
+
+# Out of memory / GC pressure
+java.lang.OutOfMemoryError
+GC overhead limit exceeded
+
+# Cluster split-brain
+WARN.*Hazelcast.*member.*left
+ERROR.*ClusterProbe
+
+# Session leaks / thread pool exhaustion
+WARN.*Maximum pool size reached
+WARN.*No active session
+```
+
+### Useful log grep commands
+
+```bash
+# All ERRORs in the last hour (adjust tail count)
+docker compose exec jahia grep "^[0-9].*ERROR" /var/log/jahia/jahia.log | tail -200
+
+# Module-related events today
+docker compose exec jahia grep -i "module\|bundle\|deploy" /var/log/jahia/jahia.log | grep "$(date +%Y-%m-%d)"
+
+# Slow queries (threshold 1000 ms is default)
+docker compose exec jahia grep "SlowQuery\|slow query" /var/log/jahia/jahia.log
+```
+
+## Karaf console
+
+Connect via SSH (port 7770 by default):
+
+```bash
+ssh -p 7770 karaf@localhost
+# Password = JAHIA_ROOT_PASSWORD
+```
+
+### Essential Karaf commands
+
+```
+# OSGi bundle state
+bundle:list                         # List all bundles + state
+bundle:list | grep -v Active        # Only non-Active bundles (problem candidates)
+bundle:diag <bundle-id>             # Diagnose a specific bundle (missing imports etc.)
+bundle:start <bundle-id>
+bundle:stop  <bundle-id>
+bundle:refresh <bundle-id>
+
+# Module management
+module:list                         # Jahia modules + version + state
+jahia:deploy <path-to-jar>          # Deploy a module from local path
+
+# Cluster
+cluster:info                        # Show Hazelcast cluster members
+cluster:manager-node                # Show which node is the manager
+
+# System info
+info                                # JVM / Karaf version summary
+threads                             # Thread count snapshot
+memory                              # Heap / non-heap usage
+
+# Log level (temporary, reverts on restart)
+log:set DEBUG org.jahia.services.content
+log:set INFO  org.jahia.services.content   # reset
+
+# Display live log tail inside Karaf
+log:tail
+```
+
+## JVM tuning
+
+### Heap sizing
+
+Set `MAX_RAM_PERCENTAGE` env var (e.g. `75`) to let the JVM auto-size to a
+percentage of container RAM. Alternatively set explicit flags via `EXTRA_JAVA_OPTS`:
+
+```
+EXTRA_JAVA_OPTS=-Xms2g -Xmx4g
+```
+
+Rule of thumb: 4 GB heap minimum for a single-node dev instance; 8–16 GB for
+production with content-heavy sites.
+
+### GC logging (add to EXTRA_JAVA_OPTS)
+
+```
+-Xlog:gc*:file=/var/log/jahia/gc.log:time,uptime,level,tags:filecount=5,filesize=20m
+```
+
+### Thread dump
+
+```bash
+# Get PID inside container
+docker compose exec jahia bash -c 'jps | grep Jahia'
+# Take dump (replace <PID>)
+docker compose exec jahia bash -c 'kill -3 <PID>'
+# Output goes to jahia.log
+```
+
+Or from Karaf: `threads --list` for a quick summary.
+
+### Heap dump on OOM (add to EXTRA_JAVA_OPTS)
+
+```
+-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/var/log/jahia/heapdump.hprof
+```
+
+## jCustomer (Unomi) monitoring
+
+```bash
+# Health
+curl http://localhost:8181/cxs/actuator/health
+
+# Cluster nodes (REST)
+curl -u karaf:karaf http://localhost:8181/cxs/cluster
+
+# Karaf console (port 8101)
+ssh -p 8101 karaf@localhost
+```
+
+## Elasticsearch monitoring
+
+```bash
+# Cluster health
+curl http://localhost:9200/_cluster/health?pretty
+
+# Index sizes
+curl http://localhost:9200/_cat/indices?v&h=index,docs.count,store.size
+
+# Pending tasks
+curl http://localhost:9200/_cluster/pending_tasks
+```
+
+## Alerting thresholds (suggested)
+
+| Metric | Warning | Critical |
+|--------|---------|---------|
+| Heap usage | 75 % | 90 % |
+| Jahia healthcheck status | YELLOW | RED |
+| DB connection pool | 80 % utilised | 95 % utilised |
+| Error log rate | > 10/min | > 50/min |
+| ES cluster health | YELLOW | RED |
+| GC pause (G1GC stop-the-world) | > 500 ms | > 2 s |