The proof manifesto, line by line
The greenhouse project's manifesto fits in 18 lines of YAML. Here is its actual syntax, what the engine does with it, and a read-back execution.
The previous article explained why every project has its own proof page.
This one opens the hood: a manifest is a small YAML file that declares where a
project’s evidence comes from, and the engine runs it every time the site is
built. The engine’s docstring (store/noyau/preuves.py) puts it bluntly: “so
that a proof cannot lie by omission”. And: “A manifest file is never copied by
hand into a page.”
The file, in full
The greenhouse project’s manifest, store/projets/serre/preuve.yml, is 18
lines long:
projet: serre
commandes:
- titre: Bus activés dans config.txt
commande: grep -E 'dtparam|dtoverlay' /boot/firmware/config.txt
- titre: Nœuds I2C et SPI
commande: ls /dev/i2c-* /dev/spidev* 2>/dev/null
- titre: Sondes 1-Wire
commande: cat /sys/bus/w1/devices/w1_bus_master1/w1_master_slaves 2>/dev/null || echo "aucune sonde"
compteurs:
- titre: Mesures de démonstration en base
base: /var/lib/serre/serre.db
sql: select count(*) from mesures
captures:
- image: ressources/serre-24h.png
titre: Le tableau de bord que le kit produit (données de démonstration)
limites:
- "Aucun capteur n'est branché : les bus sont activés, mais vides."
- La pompe et le débitmètre ne sont pas encore installés.
Four sections here. The engine accepts six: tests, commandes, compteurs,
fichiers, captures, limites. The self-hosting guide’s manifest
(store/projets/guide-pi/preuve.yml) uses all six. One detail verified in the
code: the projet: key is never read by the engine — it is the file’s path
(store/projets/<slug>/preuve.yml) that binds it to the project. The key is
declarative, not functional.
The syntax, section by section
commandes — a titre and a shell commande. The engine runs it with a
60 s maximum timeout, from the layer’s root (~/Documents/Athena). It
concatenates stdout and stderr, then keeps only the last 12 lines and the last
1,200 characters (_couper). The verdict is the return code: 0 = OK, otherwise
the code is displayed as-is.
compteurs — a titre, a SQLite base, an sql query. The database is
opened read-only (mode=ro URI): the manifest cannot write to the database
it measures. Only the first row of the result is displayed.
captures — an image and a titre, or just a path as plain text. The
engine checks that the image exists; the page shows it in a gallery.
limites — free text, rendered in a separate block at the bottom of the
page. A real YAML trap: a limit containing an unprotected colon is parsed as a
dictionary. The engine flattens it back (_aplatir_limite) rather than
displaying JSON — hence the quotes on the first limit above.
tests (absent here) — a fichier and a commande. The number of tests
displayed does not come from the command: it is counted in the source by a
regex (def test_…). The figure comes from the file, the OK/KO verdict comes
from the execution. Deleting a test lowers the figure, even if the command
still succeeds.
fichiers (absent here) — a list of paths. The engine displays the size
and the first 12 hexadecimal characters of the SHA-256. A delivered file whose
fingerprint changes is visible.
Relative paths starting with ressources/ or assets/ are resolved from
store/; all others from the layer’s root (_résoudre).
Two guards, not one
The engine distinguishes two moments, and it matters:
- Before the build,
contrôle()checks that every declared test file, delivered file, capture and database exists. Each missing item becomes an error instore/outils/site.py, and the build exits with a failure. A manifest pointing at a deleted file blocks the site. - During collection, a failing command blocks nothing:
collecter()never fails, the error is displayed in the page. A proof of failure is still a proof.
The displayed date (“recalculated on”) is the day of the collection, not a hand-written date.
Execution read back on 2026-11-21
I ran collecter('serre') this morning. Three results deserve to be shown
as-is.
I2C and SPI nodes — a failure displayed, not hidden
commande
ls /dev/i2c-* /dev/spidev* 2>/dev/nullsortie
/dev/spidev0.0
/dev/spidev0.1
code de retour 2SPI is there, I2C is not: the i2c-dev module is not loaded (lsmod does not
list it), so /dev/i2c-1 does not exist and ls exits with code 2. The proof
page displays that code instead of hiding it. That is exactly the contract.
The 1-Wire command, on the other hand, succeeds — and returns
00-1bd000000000, 00-9bd000000000, 00-5bd000000000. These 0x00-family
ROMs are ghosts of a floating bus, not probes (documented in HARDWARE.md).
The limites block declares it: “No sensor is plugged in”. The command proves
the bus answers; the limit says what it does not prove.
The counter returned 120 demonstration measurements in
/var/lib/serre/serre.db, and contrôle('serre') reported no problem.
The figures in this article are a dated snapshot. The proof page itself is recalculated at every site build — that is the whole difference between an article and a proof.
What it does not solve
The manifest chooses what is measured. I could write one that only measures what suits me; that is why it is public, in the repository, and why every command is visible on the page. You can read what is measured, and above all what is not.
One last point, verified: every command in the greenhouse manifest is
read-only (grep, ls, cat, select). A manifest runs with the permissions
of whoever builds the site — it must stay harmless. That is a writing rule, not
an engine guarantee.