OpenCore MES Try the demo

Docs Installation 2

Install on a Linux server

On this page

Everything below is done on the server, in a root shell (sudo -i), unless a step says otherwise. The installation's settings are one file, /etc/opencore-mes/opencore-mes.env. Where a step runs something as the service's user with those settings, it first opens that user's shell (IN-15 shows how), and closes it after.

IN-10Prepare the server
PurposePostgreSQL, Caddy, Node, the system user and its directories, the database role.
Done byIT
Before you start
  • A fresh Ubuntu 24.04 server; its DNS name points at it.
  • A source archive of the version you install, unpacked on your workstation (it holds ops/).
#Do thisYou should seeDone
1On your workstation, in the unpacked source archive: copy the provisioning script to the server.
scp ops/demo/provision.sh root@<server name>:/root/
—
2On the server, run it with the Node version you choose (leave NODE_VERSION out for the latest).
NODE_VERSION=<v24.11.0> bash /root/provision.sh
It installs postgresql caddy curl ca-certificates python3 xz-utils libatomic1 bubblewrap, Node in /opt/node (its checksum checked) with /usr/local/bin/node, the system user opencore, /srv/opencore-mes/releases and /var/lib/opencore-mes/events, the database role opencore (local socket, peer authentication, may create databases) and the role mes_query the query page reads as. It is safe to run again.
3Check what it installed.
node -v
sudo -u postgres psql -Atc 'select version()'
systemctl is-active postgresql caddy
Node 24 or later; PostgreSQL 16 or later; active twice.
4Make the folder for the settings and keys.
install -d -m 0750 -o root -g opencore /etc/opencore-mes
—
provision.sh does not install the service, harden the host or set up backups: those are IN-11, IN-14 and IN-18.
IN-11Harden the host
PurposeSSH by key only, a firewall, bans after failed SSH logins, security updates.
Done byIT
Before you start
  • You sign in to the server with an SSH key (keep a second session open while you do step 3).
  • The variables below are named for the demo; the script is for any such server.
#Do thisYou should seeDone
1On your workstation, in the source archive: see where the server stands. Nothing is changed.
export DEMO_HOST=<server name> DEMO_PORT=<SSH port> DEMO_KEY=<path to your SSH key>
ops/demo/harden.sh status
Listening ports, the firewall, SSH's settings, updates, fail2ban, backup timers, time sync.
2Still on your workstation (same terminal): SSH by key only.
ops/demo/harden.sh ssh
Cannot be undone. Passwords stop working for SSH at once. If your key does not sign in, you are locked out of SSH and need the host's console to get back in: keep the second session open until you have signed in again with the key.
/etc/ssh/sshd_config.d/00-0-opencore-mes.conf: no passwords, root by key only, 3 tries; it checks that your key still signs in.
3The firewall.
ops/demo/harden.sh firewall
Cannot be undone. Everything not let through is refused at once. If the SSH port you gave is not the one you use, you are locked out and need the host's console.
ufw: incoming denied but your SSH port, 80 and 443 (TCP, and UDP for HTTP/3).
4Bans after failed SSH logins.
ops/demo/harden.sh fail2ban
SSH banned for an hour after 5 failures.
5On the server: Ubuntu's automatic security updates (not done by the script). Answer Yes when asked.
apt-get install -y unattended-upgrades
dpkg-reconfigure -plow unattended-upgrades
Security updates install by themselves; harden.sh status reports them.
6Encrypt the disk or volume that holds /var/lib/postgresql and /var/backups: your host's encrypted volumes, or LUKS when the server is installed.Data at rest is encrypted. The product does not do this for you.
IN-12Install a release
PurposeThe application's files, in a release folder that the service runs from.
Done byIT
Before you start
  • The source archive copied to the server (e.g. /root/opencore-mes-<version>.tar.gz). Name the release folder yourself: its version and date, e.g. 1.0.0-20261006.
#Do thisYou should seeDone
1Unpack it as a release folder, owned by the service's user.
mkdir /srv/opencore-mes/releases/<build>
tar -xzf /root/<archive>.tar.gz -C /srv/opencore-mes/releases/<build> --strip-components=1
chown -R opencore:opencore /srv/opencore-mes/releases/<build>
The folder holds app/, ops/, package.json.
2Install its dependencies.
cd /srv/opencore-mes/releases/<build>
sudo -u opencore npm ci --omit=dev --no-audit --no-fund
node_modules/: the runtime dependencies (the framework, @opencore-mes/juris-kit, among them).
3Let the release name itself (in /healthz and the event log).
echo 'BUILD=<build>' > /srv/opencore-mes/releases/<build>/BUILD.env
—
4Make it the release that runs.
ln -sfn /srv/opencore-mes/releases/<build> /srv/opencore-mes/current
/srv/opencore-mes/current points at it.
IN-13Keys and settings
PurposeThe installation's settings, and the two keys kept outside the database and its backups.
Done byIT, and whoever keeps the keys
#Do thisYou should seeDone
1Make the two keys: seal.key seals the second-factor secrets (AES-256-GCM); integrity.key seals every record for the data integrity review.
openssl rand -hex 32 > /etc/opencore-mes/seal.key
openssl rand -hex 32 > /etc/opencore-mes/integrity.key
chown root:opencore /etc/opencore-mes/seal.key /etc/opencore-mes/integrity.key
chmod 0440 /etc/opencore-mes/seal.key /etc/opencore-mes/integrity.key
Cannot be undone. Only on a new installation. Run again, the first two lines replace the keys: second factors sealed with the old seal key can no longer be read (everyone sets theirs up again), and every integrity seal reads as changed until a reviewer seals everything again.
64 hex characters each, readable by root and the service only. With PROD=1 the service does not start without both, nor with the same key twice: it says what to set.
2Copy both keys off the server, to the place decided (item 9 of 1.4): a password manager, or a sealed envelope in a safe. Never with the database backups. Show each one to copy it:
cat /etc/opencore-mes/seal.key
cat /etc/opencore-mes/integrity.key
Lost, a sealed second factor cannot be read (people set theirs up again), and the integrity seals must be made again by a reviewer.
3Open the settings file in an editor.
nano /etc/opencore-mes/opencore-mes.env
An empty file opens.
4Paste the content below, change it to your decisions, save (Ctrl+O, Enter) and leave (Ctrl+X). Lines starting with # are notes, and stay as they are.
File /etc/opencore-mes/opencore-mes.env: paste into an editor, not the terminal
# OpenCore MES: this installation's settings. Never in the repository.
PROD=1
HOST=127.0.0.1
PORT=3000
DATABASE_URL=postgres:///opencore_mes
PGHOST=/var/run/postgresql
PLANT_TZ=<Europe/Paris>
EVENT_LOG_DIR=/var/lib/opencore-mes/events
TRUST_PROXY=1
SEAL_KEY_FILE=/etc/opencore-mes/seal.key
INTEGRITY_KEY_FILE=/etc/opencore-mes/integrity.key
# How people sign in: one or more of these (passwords of its own are on unless PASSWORDS=0).
# OIDC_ISSUER=https://login.plant.example
# OIDC_CLIENT_ID=opencore-mes
# OIDC_CLIENT_SECRET=<secret>
# LDAP_URL=ldaps://dc.plant.example:636
# LDAP_USER_DN={user}@plant.local
MFA=optional
# Wrong sign-in tries from one address before it is held for a while: <tries>/<minutes>.
# SIGN_IN_LIMIT=30/10
# Scripts walled in (IN-16), and the hosts services may reach.
SCRIPT_RUNNER_WRAP=/srv/opencore-mes/current/ops/script-runner-sandbox.sh
# SCRIPT_ISOLATION=required
MES_CONNECTION_HOSTS=<erp.plant.example,login.plant.example>
# Alerts (IN-19).
# ALERT_WEBHOOK_URL=<https://hooks.example/...>
# The copilot: none unless set.
# AI_PROVIDER=anthropic
# ANTHROPIC_API_KEY=<key>
—
5Let root and the service read it, nobody else.
chown root:opencore /etc/opencore-mes/opencore-mes.env
chmod 0640 /etc/opencore-mes/opencore-mes.env
—
IN-14The service and HTTPS
PurposeOpenCore MES started by systemd, behind Caddy.
Done byIT
#Do thisYou should seeDone
1Open the service's unit file in an editor.
nano /etc/systemd/system/opencore-mes.service
—
2Paste the content below (the demo's unit, with the plant's settings file), save and leave.
File /etc/systemd/system/opencore-mes.service: paste into an editor, not the terminal
[Unit]
Description=OpenCore MES
After=network-online.target postgresql.service
Wants=network-online.target
Requires=postgresql.service

[Service]
User=opencore
Group=opencore
WorkingDirectory=/srv/opencore-mes/current
EnvironmentFile=/etc/opencore-mes/opencore-mes.env
EnvironmentFile=-/srv/opencore-mes/current/BUILD.env
ExecStart=/usr/local/bin/node app/mes/server.mjs
Restart=always
RestartSec=3
KillMode=mixed
TimeoutStopSec=90
RestartPreventExitStatus=64
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true
ReadWritePaths=/var/lib/opencore-mes

[Install]
WantedBy=multi-user.target
—
3Open Caddy's configuration in an editor; delete what is in it.
nano /etc/caddy/Caddyfile
—
4Paste the content below with your server's name, save and leave.
File /etc/caddy/Caddyfile: paste into an editor, not the terminal
<mes.plant.example> {
	encode gzip
	reverse_proxy 127.0.0.1:3000
	header Strict-Transport-Security "max-age=31536000"
}
—
5Check it and load it.
caddy validate --config /etc/caddy/Caddyfile
systemctl reload caddy
Valid configuration. Caddy fetches the certificate by itself, and renews it.
6Do not start the service yet: the database comes first (IN-15).—
KillMode, TimeoutStopSec and RestartPreventExitStatus make a stop graceful: systemctl restart or stop (and an upgrade) first refuses new saves and waits for what is under way, at most SHUTDOWN_GRACE_MS (60 s), then stops; systemd waits 90 s before it kills. A database administrator can restart or stop the server from the Database area the same way; a Stop ends with 64, which keeps the service stopped until systemctl start opencore-mes.
The Database area: this server, restart and stop, errors, and the calls asked of the database
The Database area, for database administrators: this server, its errors, and what is asked of the database.
The Database area: this server, restart and stop, errors, and the calls asked of the databaseThe Database area, for database administrators: this server, its errors, and what is asked of the database.
IN-15The database and the first administrator
PurposeAn empty database, and the one person who sets up the rest.
Done byIT
#Do thisYou should seeDone
1Open a shell as the service's user.
sudo -u opencore bash
The prompt changes to opencore@….
2In that shell: load the settings and go to the release.
set -a; . /etc/opencore-mes/opencore-mes.env; set +a
cd /srv/opencore-mes/current
—
3Make the empty database.
node app/mes/db/reset.mjs --empty
Cannot be undone. It makes the database again: everything in it is lost, with no backup made first. Only on a new installation; it refuses a database whose audit trail is protected.
database opencore_mes: empty (the platform's built-ins only, nobody in it). Nobody can sign in yet.
4Name the first administrator: their sign-in id, their full name in quotes, and the server's address.
node app/mes/db/admin.mjs <id> "<Full name>" --url https://<server name>
Cannot be undone. It runs once per installation: refused once anybody is in People & departments. Check the sign-in id and the name before you press Enter; afterwards they are changed only through a change in People & departments.
<Name> (<id>) is the first administrator: designer, reviewer and executor, sign-in and database administrator, approver for Engineering, which governs the organization. Setup is open: … and a one-time link to set their password, for 3 days (PASSWORD_LINK_DAYS, or --days up to 14).
5Only if they sign in through your identity provider or directory, instead of the line above: the same without a password link (their id must be theirs there).
node app/mes/db/admin.mjs <id> "<Full name>" --no-password
Cannot be undone. The same: once per installation. Check the sign-in id and the name first.
The same, without a link.
6Leave the service user's shell.
exit
Back to root's prompt.
7Set the database's settings for a plant, then restart PostgreSQL once.
bash /srv/opencore-mes/current/ops/db/settings.sh --servers 1 --peak-wal-mbps 10 opencore_mes
systemctl restart postgresql
Cannot be undone. Measured on the load bench (ops/db/README.md): group commit, a cache sized to the host, 15-minute checkpoints with compressed page images, the audit trail's vacuum. It never changes synchronous_commit, fsync or full_page_writes. --servers is the number of servers writing to this PostgreSQL, 1 here: group commit (commit_delay) lets several servers share a flush of the log and holds one back, so one server runs without it; with several instances later, run the first command again with their number (a reload, no restart). --peak-wal-mbps is the plant's peak log rate in MB a second (10 covers four servers at 150 moves a second).
The settings it set, then restart needed for: shared_buffers, wal_buffers.
8Give the link to that person only.Whoever opens it first sets the password.
9Start the service, and make it start with the server.
systemctl daemon-reload
systemctl enable --now opencore-mes
systemctl is-active opencore-mes
active. The journal says what migrated and where it listens.
10Ask it how it is.
curl -fsS http://127.0.0.1:3000/healthz
"ok":true, the build, db up, audit ok, scripts.
11Open https://<server name>/ in a browser.The sign-in page, over HTTPS.
Caution. Never run reset.mjs on a database in use: it makes the database again, and everything in it is lost. It refuses a database whose audit trail is protected (IN-17).
IN-16Wall the script runner in
PurposeRule and service scripts run with no network and no files of the host's: the operating system's walls, not only Node's.
Done byIT
#Do thisYou should seeDone
1Install the AppArmor profile that lets bubblewrap make its walls (Ubuntu 23.10 and later).
install -m 0644 /srv/opencore-mes/current/ops/script-runner-sandbox.apparmor /etc/apparmor.d/opencore-mes-bwrap
apparmor_parser -r /etc/apparmor.d/opencore-mes-bwrap
—
2Restart, and ask it how its scripts run.
systemctl restart opencore-mes
curl -fsS http://127.0.0.1:3000/healthz
"scripts":{"network":"none","sandbox":"bwrap",…}
3Open the settings file, and remove the # before SCRIPT_ISOLATION=required; save and leave.
nano /etc/opencore-mes/opencore-mes.env
—
4Restart.
systemctl restart opencore-mes
From now on the service refuses to start without its walls, rather than run scripts outside them.
Data integrity: where it stands, open findings, closed lately and the periodic review
Data integrity: changes made in the database itself, outside the platform, found, reported and acknowledged.
Data integrity: where it stands, open findings, closed lately and the periodic reviewData integrity: changes made in the database itself, outside the platform, found, reported and acknowledged.
IN-17Protect the audit trail
PurposeThe audit trail out of the application's own reach: it may add to it and read it, never change or remove it.
Done byA database administrator
#Do thisYou should seeDone
1Run the protection script as the database's owner.
sudo -u postgres psql -v app=opencore -d opencore_mes -f /srv/opencore-mes/current/ops/db/protect-audit.sql
Cannot be undone. On purpose: from then on the application can never change or remove the audit trail, and reset.mjs refuses this database. Run it on the live database only, once the installation is in use.
The trail moves to the schema audit, owned by mes_audit; the application keeps SELECT, INSERT.
2Restart, and check the trail.
systemctl restart opencore-mes
curl -fsS http://127.0.0.1:3000/healthz
"audit":{"ok":true,…}
Run it again after an upgrade whose migration adds a column to the trail; such a migration fails at start on a protected database until a database administrator runs it as postgres (ops/db/README.md).
IN-18Backups and the restore test
PurposeNightly encrypted backups, WAL archiving for a restore to any moment of the last 35 days, all of it copied off the server encrypted, and monthly restores that prove them.
Done byIT
#Do thisYou should seeDone
1Make the backup key, readable by root only; copy it off the server with the other keys.
openssl rand -base64 48 > /etc/opencore-mes/backup.key
chown root:root /etc/opencore-mes/backup.key
chmod 0400 /etc/opencore-mes/backup.key
cat /etc/opencore-mes/backup.key
Cannot be undone. Only once. Run again, the first line replaces the key, and every backup made with the old one can no longer be read: keep the old key as long as its backups.
Without it, a backup cannot be read.
2Open the backup settings in an editor.
nano /etc/opencore-mes/backup.env
—
3Paste the content below, save and leave.
File /etc/opencore-mes/backup.env: paste into an editor, not the terminal
BACKUP_DATABASES="postgres:///opencore_mes"
BACKUP_DIR=/var/backups/opencore-mes
—
4Install the backup scripts and timers, and make a first backup and restore test.
bash /srv/opencore-mes/current/ops/backup/setup.sh backups
The scripts root-owned in /usr/local/lib/opencore-mes/backup/ (the timers run those, never a release's); backups nightly at 02:30 UTC, the restore test on the 1st of each month at 04:00 UTC; opencore_mes-<stamp>.dump.enc and its .sha256; restore test: passed.
5Make a backup now (whenever one is needed, e.g. before an upgrade).
systemctl start opencore-mes-backup.service
ls -lh /var/backups/opencore-mes
A new opencore_mes-<stamp>.dump.enc and its .sha256.
6Test a restore now.
systemctl start opencore-mes-restore-test.service
journalctl -u opencore-mes-restore-test --since -5min -o cat
restore test: the backup restored into a scratch database, its audit chain verified, then dropped. Keep this output: it is the evidence an auditor asks for.
7Switch WAL archiving on: from now on any moment of the last 35 days can be brought back, and 15 minutes at most are lost.
bash /srv/opencore-mes/current/ops/backup/setup.sh wal
Cannot be undone. PostgreSQL restarts once, the first time: the service reconnects by itself, and anyone saving at that moment is told to try again.
wal: archiving into /var/backups/opencore-mes/wal, then base backup:, wal check: and pitr test: passed (a point-in-time restore beside the live database, verified, removed). Weekly base backups (Sundays 01:30 UTC), an hourly check, the test on the 1st of each month at 04:30 UTC.
8Copies off the server: the first run makes /etc/opencore-mes/offsite.env, with every setting commented out, and stops.
bash /srv/opencore-mes/current/ops/backup/setup.sh offsite
offsite: … made, with no destination. Nothing is copied until it names one.
9Open it, remove the # before OFFSITE_RCLONE or OFFSITE_RSYNC and give where (item 6 of 1.4); save and leave. For rclone, set its remote up in /etc/opencore-mes/rclone.conf; for rsync, put the key in /etc/opencore-mes/offsite_ed25519 and the other host's key in offsite_known_hosts. Then lifecycle rules at the destination: dumps/ 15 days, monthly/ 400, base/ and wal/ 42.
nano /etc/opencore-mes/offsite.env
apt-get install -y rclone
rclone config --config /etc/opencore-mes/rclone.conf
—
10Switch the copies on.
bash /srv/opencore-mes/current/ops/backup/setup.sh offsite
offsite: … up to date; every 15 minutes from now on, each file sent once, encrypted, never changed or deleted there.
11For a failed job to be told: give /etc/opencore-mes/alert.env the same ALERT_WEBHOOK_URL as IN-19.
nano /etc/opencore-mes/alert.env
Each backup, WAL, copy and restore-test unit that fails posts <unit> failed on <server> there.
Caution. Without steps 7 to 10 these are nightly backups kept on the server: a failure or a lost server loses up to a day, or everything. Restoring for real: IN-42; to a moment, and on a new server from the copies: ops/backup/README.md.

harden.sh backups, wal and offsite, from your workstation, run steps 4, 7, and 8 and 10 with the scripts of your source archive (backups also makes the key and the settings when missing, backing up every database on the server but test and scratch ones).

The integration monitor's Health tab: an instance's database, audit chain, integrity and the hours behind
The monitor's Health tab: each instance's database, audit chain, data integrity, event log and scripts' walls, now and over time.
The integration monitor's Health tab: an instance's database, audit chain, integrity and the hours behindThe monitor's Health tab: each instance's database, audit chain, data integrity, event log and scripts' walls, now and over time.
IN-19Alerts and monitoring
PurposeHear about it when something breaks.
Done byIT
#Do thisYou should seeDone
1Open the settings file; remove the # before ALERT_WEBHOOK_URL and give your webhook's address; save and leave. (ALERT_MIN_SEVERITY is error unless set.)
nano /etc/opencore-mes/opencore-mes.env
—
2Restart.
systemctl restart opencore-mes
Each event at or above it is posted as { text, event }, the same kind at most once in ten minutes: the database down, the audit chain broken, data changed outside the platform, a crash.
3Set an uptime check from outside, every minute, on https://<server name>/healthz, alerting on anything but 200, and when scripts.network is not none.—
4Ship the journal off the server (your log platform), and watch for failed units (a failed backup fails its unit).
systemctl --failed
Nothing listed.
Sign-in administration: setup codes, and each person's sign-in, last sign-in, password link and sessions
Sign-in administration: password links and setup codes, second factors, locks and sessions.
Sign-in administration: setup codes, and each person's sign-in, last sign-in, password link and sessionsSign-in administration: password links and setup codes, second factors, locks and sessions.
IN-20First sign-in, and setting the plant up
PurposeThe plant's people, departments and roles, then the end of setup.
Done byThe first administrator
#Do thisYou should seeDone
1Open the link from IN-15 and set a password (12 characters or more), or sign in through your identity provider.The designer, with a banner: Setup is open.
2Design → People & departments: start a change; add the people, departments and their approval steps, and the roles. Submit it with Execute now (setup), signing it.It executes at once, marked setup. Every such change is in the audit trail with your signature.
3Check what it changed, then on the change's Execution box press It works (sign) (or Report a problem…, with a picture of the page).The change is verified. Until you do, it waits in your inbox, and past 24 hours you are reminded each day.
4Optional: what the sign-in page calls the id (a Windows user name, an employee number), the hint in its box (PLANT\username), and the plant's domains a typed id may carry: People & departments → Sign-in, in the same change or another, executed the same way.The sign-in page shows that label and hint; PLANT\jdoe or jdoe@plant.local signs in as jdoe.
5Everyone's first password, for people who sign in with a password here: Design → Sign-in administration → Setup codes for people with no password yet. Choose a department (or everyone) and how many days the codes last, then Make codes and download.A CSV file: each person's id, name, departments, a code of five capital letters, until when it works, and the address to open. Print the slips (or a mail merge), hand each to its person, then delete the file: it holds the codes.
6Each person opens the sign-in page, clicks I have a setup code, and types their sign-in id, the code and a new password twice.Their password is set; the code works once. Making codes again for the same people stops the earlier ones.
7Only where the plant also signs people in through its directory (Active Directory, LDAP): someone with a password here who has an account there moves to it from Your password (their name, top right): their directory password, then Switch to the directory.Their password here is taken off; they sign in with the directory's from then on.
8Choose the plant's approval level on the same tab: Full (a reviewer, then each department: a regulated plant keeps it), One approval (one approver of a department it touches signs, and it executes) or None (each designer signs their own changes, for a plant with nobody else to ask). Then, when the level's people are there (Full: someone besides the designers who can review; One: an approver of governance besides each designer), clear Setup is open in the same change; execute it the same way.
Cannot be undone. Not on one signature any more: opening setup again later is a change that governance reviews and approves.
From then on every change is reviewed and approved. The change says what is still missing if it cannot end yet.
9Decide how an approved change goes live, on the same tab under Execution: executed by hand by its executor, then verified (the default: the last signature leaves it approved; the executor named at its submission presses Execute when the plant is ready, then signs that it works or reports a problem; reminded after the hours set, 24 unless you say), or cleared: live at the last signature. By hand, give the executor role to those who will put changes live (Roles → Designer); you hold it already.Saved with the rest of the change, approved by governance. A plant that executes by hand cannot be left without an executor: the change says so.
10Note in the handover that the installation was set up this way, and that the changes made in setup (Designer → Changes → Setup) are covered by the plant's validation.—
The user guide (USERGUIDES.md) is for the people who design the plant from here.
IN-21Before go-live
PurposeThe installation as it should be, checked and signed.
Done byIT and the plant's quality or validation lead
#Do thisYou should seeDone
1Ask the service how it is.
curl -fsS http://127.0.0.1:3000/healthz
ok true; db up; audit.ok true; scripts.network none; the build you installed.
2Run the test pipeline on the server, against a test database (never the live one), as the service's user.
cd /srv/opencore-mes/current
sudo -u opencore env PGHOST=/var/run/postgresql TEST_DATABASE_URL=postgres:///opencore_mes_test EVENT_LOG_DIR=/var/lib/opencore-mes/test-events npm run test:all
all … stages passed. It makes and drops its own test databases; the name it is given must contain "test", so the live database is safe.
3From your workstation (the variables of IN-11 set): where the server stands.
ops/demo/harden.sh status
Only your SSH port, 80 and 443 listen from outside; SSH by key; updates on; fail2ban; backup and restore-test timers active; time in sync.
4The keys (seal, integrity, backup) are copied off the server, and the backup key is not stored with the backups.—
5The latest restore test passed (IN-18 step 6).—
6Setup has ended (IN-20 step 3), unless the plant decided otherwise and wrote why.Design → People & departments → Approvals: Setup is open not ticked.
7Execution as decided (IN-20): by hand, with the executors named.Design → People & departments → Approvals: Execution; Roles → Designer: executor.
8None of the demo's settings or timers are present.
grep -E 'DEMO|SEED_' /etc/opencore-mes/opencore-mes.env
systemctl list-timers | grep opencore-mes
No DEMO or SEED_ line; only the backup and restore-test timers.
9Sign-in policy as decided: MFA, password expiry (PASSWORD_MAX_DAYS), idle sign-out (SESSION_IDLE_MINUTES).—