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

Jesús Pérez
The hook did exactly what it declares: offer. Its own header says it does not bind, that it turns «I did not know it existed» into «I knew and I chose». What it never built was the second half: that the choice is recorded. Without it, declining with judgement and never looking leave the same hole — none — so across a session of three hours and twenty-two minutes the procedure was served eight times, declined eight, and nobody could notice. The layer where that was meant to be recorded had been finished for months: ADR accepted, schema with a hard constraint, migration applied, seven verbs exported, zero records. No mechanism was missing: a caller was.
Case 0/8: the advice that never kept the answer

🕵️ 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.

Case No. 0/8Classification: ANTI-PAP · THE ADVICE THAT NEVER KEPT THE ANSWERStatus: RESUELTO
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-file served 8
  • mode run generate-case-file executed 0
  • qa:case-file-howto served → 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 accountADR-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 confidenceThe `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 nothingAnd 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.
MicrotaskVerifiable
Count cases and replaysnu scripts/build/gen-case-file.nu --check
Confirm the page serves what the disk claimscurl -s --compressed localhost:3030/expedientes | grep -oE 'href="/expedientes/casos/[^"]*"' | sort -u
Confirm a run is open before reporting stepsontoref run status — and read the output, not the exit code
Confirm what was edited is what runsjust 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 sogate:just test-machine-output
  • The source is not the running system until it is installedgate:just check-runtime
  • The record's shape was already written: 'Read with 'pending or 'okcontract:.ontoref/reflection/schemas/interaction.ncl#events
  • A number that cannot be traced is dropped, never estimatedmode:generate-case-file/gather_metrics
  • The howto governing the series, which this session did read 4 times out of 8qa: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.

The project's full vocabulary →

Was this useful? Rate it
Got something to add? Tell me what you think, what you'd suggest, or whether we should keep exploring this topic.
· reads

We use cookies to help this site function, understand service usage, and support marketing efforts. Cookie Policy for more info.