Case 0/8: the advice that never kept the answer
Eight times it offered the procedure. Eight times it was declined. Zero times was it recorded — and the broken mechanism was the cure of an earlier case
🕵️ Show the full case file → 📋 Session protocol →
Case file · Code Homicide Dept.
The broken mechanism was not just any mechanism: it was the cure of an earlier case. It fired eighteen times, was heard all eighteen, and evaporated all eighteen. It cured the half it was asked for.
Show glossary
- PAP
- The project's architecture principles, rules and patterns. An anti-PAP drift is not a bug: it is code that contradicts or duplicates a source of truth already declared.
- orientation hook
- A hook that, on every prompt, asks the graph what governs THIS task and injects the pointer. Its own header declares that it does not bind: it turns «I did not know it existed» into «I knew and I chose».
- mode
- A procedure declared as a DAG of steps with owners. Some steps are 'Human: they exist so an agent cannot run the whole thing alone.
- witness
- A record that something happened, kept separate from the claim that it happened. Without one, «I considered it and set it aside» and «I never looked» leave the same hole: none.
- interaction trace
- The layer ADR-037 declares, where a session's acts become queryable instead of having to be mined out of prose written afterwards.
The protocol to declare, version and verify this → ontoref.dev
The double ledger — what it cost, and what it left
What the crime cost
- Session length (00:24:37 → 03:46:33) 3 h 22 min
- Human prompts 60
- Tool calls 554
- Times the hook served the orientation 18
mode:generate-case-fileserved 8mode run generate-case-fileexecuted 0qa:case-file-howtoserved → read 8 → 4- Claims made without a witness, later refuted 9
- Records in the interaction trace 0
What the session did produce
- Commits in outreach 6
- Commits in the spine 5
The suspects — the false leads
| The browser cache | “The cascade had not been looked at. Diagnosed before looking.” | ruled out |
| app.min.css | “A stylesheet the page does not load: the disk was grepped instead of reading the served <link> tags.” | ruled out |
| An empty page 2 | “An artefact of curl itself: without the HX-Request header the server answers something else. With it, 12 + 5 = 17.” | ruled out |
| The three-tree paginator | “A three-option menu missing the one that compiles. An incomplete search presented as a closed choice.” | ruled out |
| Seven cases with no verbatim source | “.coder/ was checked — the curated layer — and not the session records, which do keep the prompts.” | ruled out |
| Composing with mod | “Generalised from just --justfile, which resolves paths differently. Declaring the modules broke every recipe on first invocation.” | ruled out |
| project-root resolving empty | “Deduced from an error that only meant the function is not exported. The cause was a private copy of the helper.” | ruled out |
The weapon — The hook, up to that line
# ~/.claude/hooks/onre-prompt-orient.nu — its own header, lines 18-19 # # No ata. Inyecta un puntero, y un puntero es un consejo — la misma prosa que no ató las # otras cuatro veces. Lo que hace es convertir «no sabía que existía» en «lo sabía y elegí». print ($out | str join "\n") # ← and here the function ended
And the layer where that was meant to be recorded had been finished for months. ADR-037:
Accepted. Schema with a Hard constraint. Migration 0028, applied. Seven verbs exported.
The file never came into existence.
The turn — The same file, two calls more
# the same file, lines 154-157 — after the `print`, where nothing was
for p in $served {
let w = (do { ^$bin interaction pointer $"($p.k):($p.v)" --session $sid --quiet } | complete)
if $w.exit_code != 0 {
print $" [on+re] warn: puntero no registrado \(($p.k):($p.v)\) — ($w.stderr | str trim)"
# and in `qa show`, at the point the entry is actually served:
interaction pointer $"qa:($id)" --consumed --quiet
# served → status 'pending
# read → status 'ok
# an unclosed 'pending IS the finding
Writing it cost three more defects, all three found by executing and none by reading: the
sensor printed its confirmation inside qa show’s JSON; the cure lived for twenty
minutes only in the source while the hook kept running the installed copy; and the
detector for that very drift came back green over zero files on its first run — case 0/10
reproduced inside the gate written to prevent it.
The verdict
This hook is not just any instrument. It is the cure of case 8/4, «the discipline with no trigger» — that case was about four mechanisms nobody fired, and its cure was precisely this: serving what governs the task in the prompt itself. It fires. It fired eighteen times. It was heard. And it evaporated every time.
A project that cures and never verifies the cure accumulates half-cures, and that pattern is only visible if what was served and what was consumed are counted separately. Aggregated, this session reads «consumed half». Separated: the prose was read 4 times out of 8 and the procedure 0 out of 8. That is not distraction, it is a selection — reading is cheap and cedes nothing; running the DAG hands the wheel to steps with owners, two of them human.
The friction the procedure would have charged in twelve small instalments arrived whole at the end, in a single bill. The project’s own ontology had written it down before it happened: emergence with no floor is not wu-wei, it is drift; friction deferred, and deferred friction arrives as loss.
| The DAG was offered 8 times and invoked none | `interaction pointer` records what was served and `qa show` closes it on reading; `interaction pointers` pairs them PER TARGET. Aggregated, this case would read «50% consumed»; per target it says 4/8 on the prose and 0/8 on the procedure, which is the whole difference. |
| The session left no queryable account | ADR-037 already declared it: schema with a Hard constraint, migration 0028, seven verbs exported. The file never existed. No mechanism was missing: a caller was. |
| «Eleven hours» in the headline, with no artefact behind it | `gather_metrics` forbids the number that cannot be traced. It is step 1 of the procedure that was never invoked: nothing had to fail — not calling it was enough. |
| Nine claims delivered with confidence | The `governed-delivery` executor (ADR-066) derives status from the declared check's exit code and refuses the self-report that contradicts it. |
| The cure lived in the source, not in what runs | `just check-runtime` compares by content the spine's 283 files against the installed copy — the one a hook reaches when it resolves `ontoref` with `which`. |
| A `print` inside a machine surface | `just test-machine-output` parses the real output with `from json`. The exit code stayed 0 with the JSON broken: measuring the exit code is measuring the thing next to it. |
| «Running the DAG» sounds like paperwork: its steps execute nothing | And they do not execute: `mode run` prints them. But the DAG does not distribute work, it distributes OWNERSHIP — `gather_metrics` forbids the number that cannot be traced, `replay_session` is 'Both, `review` is 'Human. What declining skips is not the paperwork: it is who answers for each step. «Eleven hours» was published, the replays were composed on the side, and the agent approved itself. Three steps, three owners, none consulted. WITH A CORRECTION THIS CASE OWES ITSELF: that ownership is DECLARED, not enforced. Measured while writing the case file — `ONTOREF_ACTOR` is read in two places, to pick a directory and to pick an output format, and is never compared against the step's actor. Nothing stops an agent from reporting a 'Human step. Selling this as a gate would be a claim without a witness inside the case about claims without witnesses. |
The reconstruction — the session, replayed with protocol
What was asked — reconstructed from ~/.claude/projects/-Users-Akasha-Development-ontoref-outreach-site/b791be36-….jsonl, first `type=="user"` record — verified that the three lines are one message, not three. Kept in the original Spanish: a verbatim prompt is evidence, and translating it would make it a paraphrase
no se supone que https://ontoref.dev/docs/expedientes/protocolo.html debería reunir automáticamente los expedientes ? por qué no están todos y esto no funciona ?
What should have been asked
The page collects replays, not case files. Before touching anything: tell me how many cases there are and how many have a replay, with the command that counts it. If the answer is «replays are missing», that is `mode:generate-case-file` step 6, and you run it — you do not compose it on the side.
| Microtask | Verifiable |
| Count cases and replays | nu scripts/build/gen-case-file.nu --check |
| Confirm the page serves what the disk claims | curl -s --compressed localhost:3030/expedientes | grep -oE 'href="/expedientes/casos/[^"]*"' | sort -u |
| Confirm a run is open before reporting steps | ontoref run status — and read the output, not the exit code |
| Confirm what was edited is what runs | just check-runtime |
The gate before delegating: Compose nothing and delegate nothing until ontoref run status returns a run for this
mode. It returned null for the whole session and nobody looked.
The ADR trigger: «May a mechanism declare itself advice and not keep the answer?» It is an architectural decision with a consciously rejected alternative — the blocking gate — and a lasting constraint on every future advisory instrument.
Case law — what enforces the lesson today
- ✓A machine format that does not parse is a broken surface, and the exit code will not say so
gate:just test-machine-output - ✓The source is not the running system until it is installed
gate:just check-runtime - ✓The record's shape was already written: 'Read with 'pending or 'ok
contract:.ontoref/reflection/schemas/interaction.ncl#events - ✓A number that cannot be traced is dropped, never estimated
mode:generate-case-file/gather_metrics - ✓The howto governing the series, which this session did read 4 times out of 8
qa:case-file-howto
⊘Declared debt: Nothing obliges anyone to look at the ratio. interaction pointers pairs and reports, and no
gate reads it — deliberately: the tension it measures is a Spiral, and a Hard biconditional
there is the pattern this project forbids by name. But the honest outcome is that this lesson
ended up SERVABLE with its consumption UNOBLIGED, which is the same shape as the defect the
case denounces, one plane up. And there is an uncollected bet: that the choice is recorded
does not prove it will be chosen better. What would settle it is a ratio measured over time —
the emergence proxy that the enforcement-vs-emergence tension declares absent. It would be
falsified like this: with the trace present and read, if the DAG keeps being declined 8 out
of 8 with the same wreckage, the cure is insufficient. Separately, filed as bl-051: the run
store cannot record steps with two concurrent sessions, so today the evidence that a DAG was
followed depends on nobody else working in the tree.
One bet remains uncollected, and the case does not hide it: that the choice is recorded does not prove it will be chosen better. That will be known by counting. If, with the trace in plain view, the procedure keeps being declined eight times out of eight, the fix was insufficient and we will be back here. That figure does not exist yet — and that it does not exist is exactly what this case came to repair.
From the project vocabulary (7)
- Gate
- Typed prerequisites and policies controlling FSM state transitions in a project.
- PAP
- Project's Architecture Principles.
- Sensor
- Feedback control in a coding-agent harness: the check that fires AFTER the model generates, correcting what a guide could not prevent.
- Spiral
- Resolution mode of a Yin/Yang tension where neither pole wins and the system oscillates between them with synthesis emerging from the motion itself.
- anti-PAP
- Approach that violates the project's PAP outright.
- on+re
- Shorthand for the Ontoref dual layer: ontology (`.ontoref/ontology/`: core.ncl, state.ncl, gate.ncl, manifest.ncl — what IS) + reflection (`.ontoref/reflection/`: modes, backlog, constraints, qa — what BECOMES).
- ontoref
- The protocol itself: a typed, queryable surface on which a project declares WHAT IT IS (ontology) and HOW IT ACTS (reflection), so a claim about the project can be contradicted by a machine and not only by a reader.