Drop the floor step; put `name:` before the command

Message

The floor read the test-count banner and failed the run if it dropped below what a green run reported. It was guarding a real hole -- sigil test silently skips files in test/ that do not match test-.sgl or -test.sgl, so a rename can shrink the suite while CI stays green -- but that hole belongs to sigil test, and fixing it there fixes it once for every repo instead of pasting ten lines of shell into each one. Filed separately; a --strict flag is the shape.

Removing it also removes its only consumer, so sigil test runs plainly again and the output capture and the artifact step go with it.

name: now precedes the command. Keyword arguments are order-free in the job language already, so this is the same step form and compiles to an identical script -- it just does not bury the step's name underneath the code it names.

Changed

 .kiln/ci.sgv | 176 +++++++++++++++++++++++++++++++++-----------------------------------------------------------------------------------------------------------------------------------------------
 1 file changed, 33 insertions(+), 143 deletions(-)

Diff

.kiln/ci.sgvmodified

@@ -1,76 +1,40 @@

−1

;;; ci.sgv -- sigil-css CI, defined NATIVELY in kiln's job language.

;;; ci.sgv -- sigil-css CI, defined natively in kiln's job language.

;;;

−3

;;; No `.kiln/ci.sh`. The steps below ARE the pipeline; there is no shell

−4

;;; script wrapping them. This is the pilot shape intended to be copied

−5

;;; across the extracted repos, so the reasoning is recorded here rather

−6

;;; than only in the task note. Every claim below was measured on kiln

−7

;;; ad9b9c5 and sigil-css ebd81a4, 2026-09-01, and re-checked by an

−8

;;; adversarial reviewer that found four of them wrong the first time.

;;; No `.kiln/ci.sh`. The three steps below ARE the pipeline.

;;;

;;; `on:` IS MANDATORY AND ITS ABSENCE IS SILENT. A workflow with no `on:`

−11

;;; matches no event, produces no error and no run, and reads exactly like

−12

;;; a controller fault rather than like this file. It does not even lint:

−13

;;; a pipeline with no `on:` reports "OK -- no problems found".

;;; matches no event, produces no error and no run, and still lints OK --

;;; so a missing `on:` reads exactly like a controller fault rather than

;;; like this file.

;;;

−15

;;; NO `branch:` FILTER ON `push`, deliberately. A filter would narrow

−16

;;; coverage to one ref; this library has none to spare. `(pull-request)`

−17

;;; is NOT declared: kiln's matcher accepts the trigger, but no run of that

−18

;;; kind has ever been observed on this controller, and declaring coverage

−19

;;; nobody has seen fire is how a green comes to mean less than it looks.

−20

;;; Unlike sigil-http and sigil-json, this repo carries no `.woodpecker.yml`

−21

;;; at all -- it has never had CI of any kind.

+10

;;; NO `branch:` FILTER ON `push`, deliberately: a filter would narrow

+11

;;; coverage to one ref. `(pull-request)` is not declared either -- kiln's

+12

;;; matcher accepts it, but no run of that kind has been observed on this

+13

;;; controller, and declaring coverage nobody has seen fire is how a green

+14

;;; comes to mean less than it looks.

;;;

−23

;;; SINGLE NODE, FOUR NAMED STEPS -- not four jobs. Every node gets its own

−24

;;; worker and its own workspace, with the tree delivered again per node

−25

;;; (`runner.sgl` takes `backend-workspace` and calls `provide-source!`

−26

;;; inside the per-node path). Splitting the stages across nodes would mean

−27

;;; shipping the workspace `build/` between them -- 1.8 MB for this repo

−28

;;; after `sigil build` in a delivered tree -- which is the artifact fan-in

−29

;;; path kiln's own `.kiln/ci.sgv` records as unproven on the persistent

−30

;;; backend. And it would not be enough: `sigil deps install` leaves a LINK

−31

;;; FARM in the workspace (`.sigil/deps`, 2 entries here, all 2 symlinks)

−32

;;; pointing at content under `$HOME/.sigil/deps`, so a restored copy of it

−33

;;; dangles unless $HOME is shared between the nodes -- an unstated

−34

;;; dependency on worker statefulness, true on today's single persistent

−35

;;; host and false anywhere else. sigil-http's `.woodpecker.yml` records

−36

;;; the same constraint in its own header. The honest cost of one node is that

−37

;;; the operator gets ONE status instead of three; that is a symptom of the

−38

;;; missing ledger below, not of the node count.

+16

;;; ONE NODE, NOT THREE JOBS. Every node gets its own worker and its own

+17

;;; delivered tree, and `sigil deps install` leaves a link farm in the

+18

;;; workspace pointing at content under $HOME -- so splitting the stages

+19

;;; across nodes means either shipping ~1.8 MB of `build/` between them or

+20

;;; depending on $HOME being shared between leases. Reasoning and

+21

;;; measurements: topics/kiln-native-pipeline-single-node-template.

;;;

−40

;;; WHAT A STEP NAME BUYS TODAY: readability, and nothing structural.

−41

;;; `nodeexec.sgl` wraps a named shell step in `##[kiln:section-start:<name>]`,

−42

;;; while the log viewer's parser (`web/views.sgl` `section-marker`, used by

−43

;;; both the fold view and the live SSE renderer) requires the prefix

−44

;;; `##[kiln:section-start ` -- space and timestamp, the LEGACY `.run`

−45

;;; grammar. The two do not meet, so a named step renders as a plain log

−46

;;; line. Two more things about the markers, for whoever reconciles the

−47

;;; grammar: a FAILING step emits no `section-end` at all (the program dies

−48

;;; under `set -e`), and `artifact` steps emit no markers whatsoever.

−49

;;; The names are still worth having -- they are the contract any future

−50

;;; comparison rests on, and a rename is a breaking change even when it

−51

;;; reads better -- but do not tell anyone they will see folds.

+23

;;; STEP NAMES DO NOT FOLD IN THE UI TODAY, and that is a kiln bug, not a

+24

;;; mistake here: `nodeexec.sgl` emits `##[kiln:section-start:<name>]` and

+25

;;; the log viewer's parser wants the legacy `##[kiln:section-start <ms>

+26

;;; <name>]`. Keep the names -- they are the contract any future

+27

;;; comparison rests on -- but expect plain log lines until that is fixed.

+28

;;; There is also no check ledger here: that whole contract lives in each

+29

;;; repo's `.kiln/ci.sh`, and this pipeline has none.

+30

;;; See topics/kiln-native-pipeline-emits-no-checks.

;;;

−53

;;; THERE IS NO CHECK LEDGER HERE, AND THAT IS STRUCTURAL. The

−54

;;; `$KILN_ARTIFACTS/checks.ledger` contract that `kiln-diff-checks` and the

−55

;;; conversion plan's floors are built on is written entirely by a repo's

−56

;;; own `.kiln/ci.sh` -- `grep -rn checks.ledger src/` in kiln returns

−57

;;; nothing. A natively-defined pipeline emits no ledger by construction.

−58

;;; The `floor` step below is therefore NOT that contract and must not be

−59

;;; read as it: it asserts only that the suite ran and reported at least the

−60

;;; counts a green local run reported.

−61

;;;

−62

;;; TIMEOUT 1800, AND WHAT THE CLAMP ACTUALLY DOES. `runner.sgl`

−63

;;; `node-worker-fm` computes `(min declared ceiling)` with NO diagnostic,

−64

;;; where ceiling is `safety.max_job_timeout`. 1800 equals that setting's

−65

;;; DEFAULT (`config.sgl:345`) -- it is a ceiling default, not a per-job

−66

;;; default -- so 1800 survives the clamp on a controller that has not

−67

;;; lowered the key, and is SILENTLY REDUCED on one that has. Nobody

−68

;;; copying this file should assume otherwise without reading the key.

−69

;;; The effective value is emitted once, in the `Persistent worker ready

−70

;;; ... timeout=N` line, and only on the persistent-worker path; on any

−71

;;; other backend it is printed nowhere. Note also that omitting `worker:`

−72

;;; entirely is NOT the same as declaring a default: `node-worker-fm`

−73

;;; returns #f and the node carries no frontmatter at all.

+32

;;; `timeout: 1800` is CLAMPED by `safety.max_job_timeout` with no

+33

;;; diagnostic -- a plain (min declared ceiling). 1800 is that key's

+34

;;; default, so it survives on a controller that has not lowered it and is

+35

;;; silently reduced on one that has. The effective value is printed once,

+36

;;; in `Persistent worker ready ... timeout=N`, and only on the

+37

;;; persistent-worker path.

(pipeline ci

on: #[ (push) (manual) ]

@@ -78,81 +42,7 @@

(job ci

worker: (worker timeout: 1800)

steps: #[

−81

−82

(shell "sigil deps install" name: deps)

−83

−84

(shell "sigil build" name: build)

−85

−86

;; `sigil test` is captured rather than piped: a pipeline's exit

−87

;; status is the LAST command's, so `sigil test | tee` reports tee's

−88

;; success and loses the failure. The `|| { rc=$?; ...; exit \"$rc\"; }`

−89

;; form keeps the real status while still printing the log.

−90

(shell "sigil test --no-color > kiln-test.out 2>&1 || { rc=$?; cat kiln-test.out; exit \"$rc\"; }

−91

cat kiln-test.out"

−92

name: test)

−93

−94

;; THE FLOOR. `sigil test` already exits 1 when it finds NO test

−95

;; files, so this exists for the PARTIAL case: a file that stops

−96

;; matching the `test-*.sgl` / `*-test.sgl` discovery pattern is

−97

;; dropped SILENTLY and the run stays green on a smaller suite.

−98

;; Both numbers come from a green local run of ebd81a4:

−99

;; `Files: 1 of 1 run`, `Tests: 33 passed`.

−100

;;

−101

;; `tail -1`, NOT `head -1`, AND THIS IS NOT A STYLE CHOICE. The

−102

;; step captures 2>&1, so anything a test prints lands in this file

−103

;; ahead of the summary. A test that emits a banner-shaped line

−104

;; ("Files: 9 of 9 run") makes `head -1` read the test's output

−105

;; instead of the summary. Measured on sigil-http: with `head -1` the

−106

;; floor stayed GREEN on a run that had fallen from 5 files / 167

−107

;; tests to 2 / 2. The real summary is always printed last, after the

−108

;; per-file loop, so `tail -1` reads it and the same input goes

−109

;; correctly red.

−110

;;

−111

;; The counts are read with a numeric guard because a numeric

−112

;; comparison in POSIX sh fails OPEN on an empty or non-numeric

−113

;; value. Exit 2 marks that case, and the wording is the point:

−114

;; KILN SEES 1 AND 2 IDENTICALLY (both are a failed node), so the

−115

;; distinction lives in the log for a human, not in the run status.

−116

;;

−117

;; The file floor is only load-bearing where the count is above 1.

−118

;; `Files: 0 of N run` is unreachable -- the line prints only when

−119

;; discovery found something, and every discovered file increments

−120

;; the completed counter on every outcome path -- so in a repo with

−121

;; ONE test file `files >= 1` is a tautology and the test count is

−122

;; the only real assertion. It is kept anyway so all 58 copies of

−123

;; this file have the same shape; say so where it applies.

−124

;;

−125

;; THIS REPO IS THAT CASE: it has ONE test file, so `files >= 1`

−126

;; here CANNOT FAIL and is decorative. The test-count floor is the

−127

;; only assertion in this step that can go red. The total-loss case

−128

;; is still covered, by `sigil test` itself, which exits 1 when it

−129

;; finds no test files at all.

−130

;;

−131

;; One case this floor mis-labels, worth knowing before a repo with

−132

;; NATIVE tests copies it: `sigil test` exits 1 on no tests only when

−133

;; BOTH the native and the .sgl sets are empty. A repo carrying a

−134

;; `build/*/bin/test-*` binary whose entire .sgl suite stops matching

−135

;; discovery gets exit 0, no `Files:` line, and a SETUP-FAILED here --

−136

;; a total loss of the .sgl suite reported as a tooling problem.

−137

;;

−138

;; NOTE FOR THE NEXT REPO: this step is the only part of the pipeline

−139

;; the job language cannot express. It is shell because there is

−140

;; nowhere else to put it, and that is how `ci.sh` starts.

−141

(shell "files=$(sed -n 's/^[[:space:]]*Files:[[:space:]]*\$[0-9][0-9]*\$ of .*/\\1/p' kiln-test.out | tail -1)

−142

tests=$(sed -n 's/^[[:space:]]*Tests:[[:space:]]*\$[0-9][0-9]*\$ passed.*/\\1/p' kiln-test.out | tail -1)

−143

for v in \"$files\" \"$tests\"; do

−144

case \"$v\" in '' | *[!0-9]*) echo \"SETUP-FAILED: floor could not read a count from kiln-test.out\"; exit 2 ;; esac

−145

done

−146

echo \"floor: files=$files (min 1), tests=$tests (min 33)\"

−147

[ \"$files\" -ge 1 ] || { echo \"FLOOR BREACHED: $files test files ran, expected at least 1\"; exit 1; }

−148

[ \"$tests\" -ge 33 ] || { echo \"FLOOR BREACHED: $tests tests ran, expected at least 33\"; exit 1; }

−149

echo 'floor: ok'"

−150

name: floor)

−151

−152

;; Staged last on purpose, and note what that costs: steps run under

−153

;; `set -e` and there is no post/always construct, so this does NOT

−154

;; run when an earlier step fails -- measured, $KILN_ARTIFACTS comes

−155

;; back empty on a red run. Exactly the run whose output you would

−156

;; most want kept.

−157

(artifact "kiln-test.out" as: "test-output.txt")

+45

(shell name: deps "sigil deps install")

+46

(shell name: build "sigil build")

+47

(shell name: test "sigil test")

]))